{
auth_methods *list = NULL;
auth_methods *t = NULL;
- auth_methods *tmp;
NTSTATUS nt_status;
if (!text_list) {
for (;*text_list; text_list++) {
if (load_auth_module(*auth_context, *text_list, &t)) {
- DLIST_ADD_END(list, t, tmp);
+ DLIST_ADD_END(list, t, auth_methods *);
}
}
/* To use these macros you must have a structure containing a next and
prev pointer */
+#ifndef _DLINKLIST_H
+#define _DLINKLIST_H
+
/* hook into the front of the list */
#define DLIST_ADD(list, p) \
-{ \
+do { \
if (!(list)) { \
(list) = (p); \
(p)->next = (p)->prev = NULL; \
(p)->prev = NULL; \
(list) = (p); \
}\
-}
+} while (0)
/* remove an element from a list - element doesn't have to be in list. */
#define DLIST_REMOVE(list, p) \
-{ \
+do { \
if ((p) == (list)) { \
(list) = (p)->next; \
if (list) (list)->prev = NULL; \
if ((p)->next) (p)->next->prev = (p)->prev; \
} \
if ((p) != (list)) (p)->next = (p)->prev = NULL; \
-}
+} while (0)
/* promote an element to the top of the list */
#define DLIST_PROMOTE(list, p) \
-{ \
- DLIST_REMOVE(list, p) \
- DLIST_ADD(list, p) \
-}
+do { \
+ DLIST_REMOVE(list, p); \
+ DLIST_ADD(list, p); \
+} while (0)
/* hook into the end of the list - needs a tmp pointer */
-#define DLIST_ADD_END(list, p, tmp) \
-{ \
+#define DLIST_ADD_END(list, p, type) \
+do { \
if (!(list)) { \
(list) = (p); \
(p)->next = (p)->prev = NULL; \
} else { \
- for ((tmp) = (list); (tmp)->next; (tmp) = (tmp)->next) ; \
- (tmp)->next = (p); \
+ type tmp; \
+ for (tmp = (list); tmp->next; tmp = tmp->next) ; \
+ tmp->next = (p); \
(p)->next = NULL; \
- (p)->prev = (tmp); \
+ (p)->prev = tmp; \
} \
-}
+} while (0)
/* insert 'p' after the given element 'el' in a list. If el is NULL then
this is the same as a DLIST_ADD() */
}\
} while (0)
-/* demote an element to the top of the list, needs a tmp pointer */
+/* demote an element to the end of the list, needs a tmp pointer */
#define DLIST_DEMOTE(list, p, tmp) \
-{ \
- DLIST_REMOVE(list, p) \
- DLIST_ADD_END(list, p, tmp) \
-}
+do { \
+ DLIST_REMOVE(list, p); \
+ DLIST_ADD_END(list, p, tmp); \
+} while (0)
+
+/* concatenate two lists - putting all elements of the 2nd list at the
+ end of the first list */
+#define DLIST_CONCATENATE(list1, list2, type) \
+do { \
+ if (!(list1)) { \
+ (list1) = (list2); \
+ } else { \
+ type tmp; \
+ for (tmp = (list1); tmp->next; tmp = tmp->next) ; \
+ tmp->next = (list2); \
+ if (list2) { \
+ (list2)->prev = tmp; \
+ } \
+ } \
+} while (0)
+
+#endif /* _DLINKLIST_H */
{
struct smbldap_state *tmp_ldap_state;
struct smbldap_state_lookup *t;
- struct smbldap_state_lookup *tmp;
if ((tmp_ldap_state = smbldap_find_state(ld))) {
SMB_ASSERT(tmp_ldap_state == smbldap_state);
t = SMB_XMALLOC_P(struct smbldap_state_lookup);
ZERO_STRUCTP(t);
- DLIST_ADD_END(smbldap_state_lookup_list, t, tmp);
+ DLIST_ADD_END(smbldap_state_lookup_list, t, struct smbldap_state_lookup *);
t->ld = ld;
t->smbldap_state = smbldap_state;
}
return NT_STATUS_UNSUCCESSFUL;
}
- cli_set_timeout(cli, 10000); /* 10 seconds. */
+ cli_set_timeout(cli, 30000); /* 10 seconds. */
if (dest_ip)
ip = *dest_ip;
struct in_addr ip )
{
struct browse_cache_record *browc;
- struct browse_cache_record *tmp_browc;
time_t now = time( NULL );
browc = SMB_MALLOC_P(struct browse_cache_record);
browc->ip = ip;
- DLIST_ADD_END(lmb_browserlist, browc, tmp_browc);
+ DLIST_ADD_END(lmb_browserlist, browc, struct browse_cache_record *);
if( DEBUGLVL( 3 ) ) {
Debug1( "nmbd_browserdb:create_browser_in_lmb_cache()\n" );
void (*continuation)(void *private_data, BOOL success),
void *private_data)
{
- struct winbindd_async_request *state, *tmp;
+ struct winbindd_async_request *state;
SMB_ASSERT(continuation != NULL);
state->continuation = continuation;
state->private_data = private_data;
- DLIST_ADD_END(child->requests, state, tmp);
+ DLIST_ADD_END(child->requests, state, struct winbindd_async_request *);
schedule_async_request(child);
* the messages are sent in the order they were received. JRA.
*/
- DLIST_ADD_END(notify_queue_head, pnqueue, tmp_ptr);
+ DLIST_ADD_END(notify_queue_head, pnqueue, struct notify_queue *);
num_messages++;
}
if ( sec_desc ) {
uint32 sk_size = sk_record_data_size( sec_desc );
REGF_HBIN *sk_hbin;
- REGF_SK_REC *tmp = NULL;
/* search for it in the existing list of sd's */
/* size value must be self-inclusive */
nk->sec_desc->size = sec_desc_size(sec_desc) + sizeof(uint32);
- DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, tmp );
+ DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, REGF_SK_REC *);
/* update the offsets for us and the previous sd in the list.
if this is the first record, then just set the next and prev
SMB_BIG_UINT offset, SMB_BIG_UINT count)
{
static BOOL set_lock_msg;
- blocking_lock_record *blr, *tmp;
+ blocking_lock_record *blr;
NTSTATUS status;
if(in_chained_smb() ) {
return False;
}
- DLIST_ADD_END(blocking_lock_queue, blr, tmp);
+ DLIST_ADD_END(blocking_lock_queue, blr, blocking_lock_record *);
/* Ensure we'll receive messages when this is unlocked. */
if (!set_lock_msg) {
while (offset + 4 <= data_size) {
size_t next_offset = IVAL(pdata,offset);
- struct ea_list *tmp;
struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset + 4, data_size - offset - 4, NULL);
if (!eal) {
return NULL;
}
- DLIST_ADD_END(ea_list_head, eal, tmp);
+ DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
if (next_offset == 0) {
break;
}
BOOL all_aces_are_inherit_only = (fsp->is_directory ? True : False);
canon_ace *file_ace = NULL;
canon_ace *dir_ace = NULL;
- canon_ace *tmp_ace = NULL;
canon_ace *current_ace = NULL;
BOOL got_dir_allow = False;
BOOL got_file_allow = False;
if ((psa->flags & (SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT)) ==
(SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT)) {
- DLIST_ADD_END(dir_ace, current_ace, tmp_ace);
+ DLIST_ADD_END(dir_ace, current_ace, canon_ace *);
/*
* Note if this was an allow ace. We can't process
*/
if (current_ace && !(psa->flags & SEC_ACE_FLAG_INHERIT_ONLY)) {
- DLIST_ADD_END(file_ace, current_ace, tmp_ace);
+ DLIST_ADD_END(file_ace, current_ace, canon_ace *);
/*
* Note if this was an allow ace. We can't process
for (curr_ace = ace_list; curr_ace; curr_ace = curr_ace_next) {
mode_t new_perms = (mode_t)0;
canon_ace *allow_ace_p;
- canon_ace *tmp_ace;
curr_ace_next = curr_ace->next; /* So we can't lose the link. */
curr_ace->attr = ALLOW_ACE;
curr_ace->perms = (mode_t)0;
- DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
+ DLIST_DEMOTE(ace_list, curr_ace, canon_ace *);
continue;
}
curr_ace->attr = ALLOW_ACE;
curr_ace->perms = (new_perms & ~curr_ace->perms);
- DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
+ DLIST_DEMOTE(ace_list, curr_ace, canon_ace *);
}
/* Pass 3 above - deal with deny group entries. */
for (curr_ace = ace_list; curr_ace; curr_ace = curr_ace_next) {
- canon_ace *tmp_ace;
canon_ace *allow_ace_p;
canon_ace *allow_everyone_p = NULL;
curr_ace->perms = allow_everyone_p->perms & ~curr_ace->perms;
else
curr_ace->perms = (mode_t)0;
- DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
-
+ DLIST_DEMOTE(ace_list, curr_ace, canon_ace *);
}
/* Doing this fourth pass allows Windows semantics to be layered
}
if (other_ace) {
- DLIST_DEMOTE(list_head, other_ace, ace);
+ DLIST_DEMOTE(list_head, other_ace, canon_ace *);
}
/* We have probably changed the head of the list. */
struct timeval end_time,
char *private_data, size_t private_len)
{
- struct pending_message_list *tmp_msg;
struct pending_message_list *msg;
msg = TALLOC_ZERO_P(NULL, struct pending_message_list);
}
}
- DLIST_ADD_END(deferred_open_queue, msg, tmp_msg);
+ DLIST_ADD_END(deferred_open_queue, msg, struct pending_message_list *);
DEBUG(10,("push_message: pushed message length %u on "
"deferred_open_queue\n", (unsigned int)msg_len));
if (sizeret) {
for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
- struct ea_list *listp, *tmp;
+ struct ea_list *listp;
if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
continue;
(unsigned int)*pea_total_len, dos_ea_name,
(unsigned int)listp->ea.value.length ));
}
- DLIST_ADD_END(ea_list_head, listp, tmp);
+ DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
}
/* Add on 4 for total length. */
if (*pea_total_len) {
size_t offset = 0;
while (offset + 2 < data_size) {
- struct ea_list *tmp;
struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
unsigned int namelen = CVAL(pdata,offset);
}
offset += (namelen + 1); /* Go past the name + terminating zero. */
- DLIST_ADD_END(ea_list_head, eal, tmp);
+ DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
}
size_t bytes_used = 0;
while (offset < data_size) {
- struct ea_list *tmp;
struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
if (!eal) {
return NULL;
}
- DLIST_ADD_END(ea_list_head, eal, tmp);
+ DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
offset += bytes_used;
}
TDB_DATA key, next;
TDB_LIST_NODE *list = NULL;
TDB_LIST_NODE *rec = NULL;
- TDB_LIST_NODE *tmp = NULL;
for (key = tdb_firstkey(tdb); key.dptr; key = next) {
/* duplicate key string to ensure null-termination */
rec->node_key = key;
- DLIST_ADD_END(list, rec, tmp);
+ DLIST_ADD_END(list, rec, TDB_LIST_NODE *);
DEBUG(18, ("checking %s matched pattern %s\n", key_str, pattern));
} else {