}
/****************************************************************************
-return the sid and the type of the unix group
+ Return the sid and the type of the unix group.
****************************************************************************/
+
BOOL get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map, BOOL with_priv)
{
TDB_DATA kbuf, dbuf;
kbuf.dsize = strlen(key)+1;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) return False;
+ if (!dbuf.dptr)
+ return False;
ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddffd",
&map->gid, &map->sid_name_use, &map->nt_name, &map->comment, &map->systemaccount);
return True;
}
-
/****************************************************************************
-return the sid and the type of the unix group
+ Return the sid and the type of the unix group.
****************************************************************************/
+
BOOL get_group_map_from_gid(gid_t gid, GROUP_MAP *map, BOOL with_priv)
{
TDB_DATA kbuf, dbuf, newkey;
if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) continue;
+ if (!dbuf.dptr)
+ continue;
fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
}
/****************************************************************************
-return the sid and the type of the unix group
+ Return the sid and the type of the unix group.
****************************************************************************/
+
BOOL get_group_map_from_ntname(char *name, GROUP_MAP *map, BOOL with_priv)
{
TDB_DATA kbuf, dbuf, newkey;
if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) continue;
+ if (!dbuf.dptr)
+ continue;
fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
}
/****************************************************************************
- remove a group mapping entry
+ Remove a group mapping entry.
****************************************************************************/
+
BOOL group_map_remove(DOM_SID sid)
{
TDB_DATA kbuf, dbuf;
kbuf.dsize = strlen(key)+1;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) return False;
+ if (!dbuf.dptr)
+ return False;
SAFE_FREE(dbuf.dptr);
return True;
}
-
/****************************************************************************
-enumerate the group mapping
+ Enumerate the group mapping.
****************************************************************************/
+
BOOL enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
int *num_entries, BOOL unix_only, BOOL with_priv)
{
/* if the message isn't found then we still need to return a pointer
that can be freed. Pity. */
- if (!data.dptr) return strdup(msgid);
+ if (!data.dptr)
+ return strdup(msgid);
return (const char *)data.dptr;
}
/* fail completely if get null pointers passed */
SMB_ASSERT(keystr && valstr && timeout);
- if (!gencache_init()) return False;
+ if (!gencache_init())
+ return False;
keybuf.dptr = strdup(keystr);
keybuf.dsize = strlen(keystr);
databuf = tdb_fetch(cache, keybuf);
- if (databuf.dptr) {
+ if (databuf.dptr && databuf.dsize > TIMEOUT_LEN) {
char* entry_buf = strndup(databuf.dptr, databuf.dsize);
*valstr = (char*)malloc(sizeof(char) * (databuf.dsize - TIMEOUT_LEN));
+ SAFE_FREE(databuf.dptr);
sscanf(entry_buf, CACHE_DATA_FMT, (int*)timeout, *valstr);
SAFE_FREE(entry_buf);
ctime(timeout)));
return *timeout > time(NULL);
} else {
+ SAFE_FREE(databuf.dptr);
*valstr = NULL;
timeout = NULL;
DEBUG(10, ("Cache entry with key = %s couldn't be found\n", keystr));
* all of the entries. Validity verification is up to fn routine.
*/
databuf = tdb_fetch(cache, node->node_key);
+ if (!databuf.dptr || databuf.dsize <= TIMEOUT_LEN) {
+ SAFE_FREE(databuf.dptr);
+ continue;
+ }
entry = strndup(databuf.dptr, databuf.dsize);
+ SAFE_FREE(databuf.dptr);
valstr = (char*)malloc(sizeof(char) * (databuf.dsize - TIMEOUT_LEN));
sscanf(entry, CACHE_DATA_FMT, (int*)(&timeout), valstr);
tdb_search_list_free(first_node);
}
-
-
if (!dbuf.dptr) {
/* its a new record */
p = (void *)malloc(len + sizeof(rec));
- if (!p) goto failed;
+ if (!p)
+ goto failed;
memcpy(p, &rec, sizeof(rec));
- if (len > 0) memcpy((void *)((char*)p+sizeof(rec)), buf, len);
+ if (len > 0)
+ memcpy((void *)((char*)p+sizeof(rec)), buf, len);
dbuf.dptr = p;
dbuf.dsize = len + sizeof(rec);
/* we're adding to an existing entry */
p = (void *)malloc(dbuf.dsize + len + sizeof(rec));
- if (!p) goto failed;
+ if (!p)
+ goto failed;
memcpy(p, dbuf.dptr, dbuf.dsize);
memcpy((void *)((char*)p+dbuf.dsize), &rec, sizeof(rec));
- if (len > 0) memcpy((void *)((char*)p+dbuf.dsize+sizeof(rec)), buf, len);
+ if (len > 0)
+ memcpy((void *)((char*)p+dbuf.dsize+sizeof(rec)), buf, len);
SAFE_FREE(dbuf.dptr);
dbuf.dptr = p;
tdb_chainlock(tdb, kbuf);
dbuf = tdb_fetch(tdb, kbuf);
- if (dbuf.dptr == NULL || dbuf.dsize == 0) goto failed;
+ if (dbuf.dptr == NULL || dbuf.dsize == 0)
+ goto failed;
memcpy(&rec, dbuf.dptr, sizeof(rec));
if (rec.len > 0) {
(*buf) = (void *)malloc(rec.len);
- if (!(*buf)) goto failed;
+ if (!(*buf))
+ goto failed;
memcpy(*buf, dbuf.dptr+sizeof(rec), rec.len);
} else {
failed:
tdb_chainunlock(tdb, kbuf);
+ SAFE_FREE(dbuf.dptr);
return False;
}
tdb_delete(namecache_tdb, key);
+ SAFE_FREE(value.dptr);
value = tdb_null;
goto done;
tdb_delete(namecache_tdb, key);
+ SAFE_FREE(value.dptr);
value = tdb_null;
goto done;
/* There is no cached universal groups in netlogon_unigrp.tdb */
/* for this user. */
- if (!data.dptr) return NULL;
+ if (!data.dptr)
+ return NULL;
/* Transfer data to receiver's memory context */
group_count = IVAL(&((uint32*)data.dptr)[0],0);
size = dbuf.dsize + sizeof(share_mode_entry);
p = malloc(size);
- if (!p)
+ if (!p) {
+ SAFE_FREE(dbuf.dptr);
return False;
+ }
memcpy(p, dbuf.dptr, sizeof(*data));
fill_share_mode(p + sizeof(*data), fsp, port, op_type);
memcpy(p + sizeof(*data) + sizeof(share_mode_entry), dbuf.dptr + sizeof(*data),
dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
- if (!dbuf.dptr) {
+ if (!dbuf.dptr) {
return 0;
}
dbuf = tdb_fetch(posix_lock_tdb, kbuf);
- if (!dbuf.dptr) {
+ if (!dbuf.dptr) {
return 0;
}
return True;
fail:
- SAFE_FREE(dbuf.dptr);
- return False;
+
+ SAFE_FREE(dbuf.dptr);
+ return False;
}
/****************************************************************************
goto fail;
}
- SAFE_FREE(dbuf.dptr);
+ SAFE_FREE(dbuf.dptr);
DEBUG(10,("add_posix_lock: File %s: type = %s: start=%.0f size=%.0f: dev=%.0f inode=%.0f\n",
fsp->fsp_name, posix_lock_type_name(lock_type), (double)start, (double)size,
(double)fsp->dev, (double)fsp->inode ));
- return True;
+ return True;
fail:
- SAFE_FREE(dbuf.dptr);
- return False;
+
+ SAFE_FREE(dbuf.dptr);
+ return False;
}
/****************************************************************************
posix_lock_type_name(pl->lock_type), (double)pl->start, (double)pl->size,
(unsigned int)num_overlapping_records ));
- SAFE_FREE(dbuf.dptr);
+ SAFE_FREE(dbuf.dptr);
return num_overlapping_records;
fail:
- SAFE_FREE(dbuf.dptr);
- return -1;
+
+ SAFE_FREE(dbuf.dptr);
+ return -1;
}
/****************************************************************************
continue;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) continue;
+ if (!dbuf.dptr)
+ continue;
fstrcpy(name_type, kbuf.dptr+strlen(ENTRY_PREFIX));
wins_ip=*interpret_addr2(ip_str);
/* Don't reload replica records */
- if (!ip_equal(wins_ip, our_fake_ip))
+ if (!ip_equal(wins_ip, our_fake_ip)) {
+ SAFE_FREE(dbuf.dptr);
continue;
+ }
/* Don't reload released or tombstoned records */
- if ((wins_flags&WINS_STATE_MASK) != WINS_ACTIVE)
+ if ((wins_flags&WINS_STATE_MASK) != WINS_ACTIVE) {
+ SAFE_FREE(dbuf.dptr);
continue;
+ }
/* Allocate the space for the ip_list. */
if((ip_list = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr))) == NULL) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("initialise_wins: Malloc fail !\n"));
return False;
}
name, type, ttl, inet_ntoa(ip_list[0]), nb_flags));
}
+ SAFE_FREE(dbuf.dptr);
SAFE_FREE(ip_list);
}
if (strncmp(kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
DEBUG(0,("upgrade_to_version_3:moving form\n"));
if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms)));
return False;
}
if (tdb_delete(tdb_drivers, kbuf) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers)));
return False;
}
if (strncmp(kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
DEBUG(0,("upgrade_to_version_3:moving printer\n"));
if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers)));
return False;
}
if (tdb_delete(tdb_drivers, kbuf) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers)));
return False;
}
if (strncmp(kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers)));
return False;
}
if (tdb_delete(tdb_drivers, kbuf) != 0) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers)));
return False;
}
driver.defaultdatatype);
i=0;
- while (len < dbuf.dsize)
- {
+ while (len < dbuf.dsize) {
fstring *tddfs;
tddfs = (fstring *)Realloc(driver.dependentfiles,
SAFE_FREE(dbuf.dptr);
- if (len != dbuf.dsize)
- {
+ if (len != dbuf.dsize) {
SAFE_FREE(driver.dependentfiles);
return get_a_printer_driver_3_default(info_ptr, drivername, arch);
* See comments in get_a_printer_2_default()
*/
- if (lp_default_devmode(lp_servicenumber(sharename)) && !info.devmode)
- {
+ if (lp_default_devmode(lp_servicenumber(sharename)) && !info.devmode) {
DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
printername));
info.devmode = construct_nt_devicemode(printername);
*/
if ( info.devmode ) {
- ZERO_STRUCT(info.devmode->devicename);
- fstrcpy(info.devmode->devicename, info_ptr->printername);
+ ZERO_STRUCT(info.devmode->devicename);
+ fstrcpy(info.devmode->devicename, info_ptr->printername);
}
/*
SAFE_FREE(data.dptr);
return rap_jobid;
}
+ SAFE_FREE(data.dptr);
/* Not found - create and store mapping. */
rap_jobid = ++next_rap_jobid;
if (rap_jobid == 0)
SAFE_FREE(data.dptr);
return True;
}
+ SAFE_FREE(data.dptr);
return False;
}
key.dptr = (char *)&jinfo;
key.dsize = sizeof(jinfo);
data = tdb_fetch(rap_tdb, key);
- if (!data.dptr || (data.dsize != sizeof(uint16)))
+ if (!data.dptr || (data.dsize != sizeof(uint16))) {
+ SAFE_FREE(data.dptr);
return;
+ }
memcpy(&rap_jobid, data.dptr, sizeof(uint16));
SAFE_FREE(data.dptr);
ZERO_STRUCT( pjob );
- if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 )
+ if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
+ SAFE_FREE(ret.dptr);
return NULL;
+ }
SAFE_FREE(ret.dptr);
return &pjob;
len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
- if (buflen != len)
- {
+ if (buflen != len) {
char *tb;
tb = (char *)Realloc(buf, len);
buf = tb;
newlen = len;
}
- }
- while ( buflen != len );
+ } while ( buflen != len );
/* Store new data */
data = tdb_fetch(pdb->tdb, key);
release_print_db(pdb);
- if (!data.dptr || data.dsize != sizeof(pid_t))
+ if (!data.dptr || data.dsize != sizeof(pid_t)) {
+ SAFE_FREE(data.dptr);
return (pid_t)-1;
+ }
memcpy(&updating_pid, data.dptr, sizeof(pid_t));
SAFE_FREE(data.dptr);
if (data.dsize % 8) {
DEBUG(0,("get_printer_notify_pid_list: Size of record for printer %s not a multiple of 8 !\n", printer_name ));
tdb_delete_by_string(tdb, NOTIFY_PID_LIST_KEY );
+ SAFE_FREE(data.dptr);
ZERO_STRUCT(data);
return data;
}
kbuf.dsize = strlen(keystr)+1;
dbuf = tdb_fetch(tdb, kbuf);
- if (!dbuf.dptr) return -1;
+ if (!dbuf.dptr)
+ return -1;
ZERO_STRUCTP(ps);
prs_init(ps, 0, mem_ctx, UNMARSHALL);
key.dptr = keyval;
key.dsize = len;
data = tdb_fetch(tdb, key);
- if (!data.dptr || data.dsize != sizeof(int32))
+ if (!data.dptr || data.dsize != sizeof(int32)) {
+ SAFE_FREE(data.dptr);
return -1;
-
+ }
+
ret = IVAL(data.dptr,0);
SAFE_FREE(data.dptr);
return ret;
key.dptr = keyval;
key.dsize = len;
data = tdb_fetch(tdb, key);
- if (!data.dptr || data.dsize != sizeof(uint32))
+ if (!data.dptr || data.dsize != sizeof(uint32)) {
+ SAFE_FREE(data.dptr);
return False;
-
+ }
+
*value = IVAL(data.dptr,0);
SAFE_FREE(data.dptr);
return True;
/* Allocate the space for the ip_list. */
if((ip_list = (struct in_addr *)talloc(mem_ctx, num_ips * sizeof(struct in_addr))) == NULL) {
+ SAFE_FREE(dbuf.dptr);
DEBUG(0,("initialise_wins: talloc fail !\n"));
return;
}
ip_list[i] = *interpret_addr2(ip_str);
}
+ SAFE_FREE(dbuf.dptr);
+
/* add all entries that have 60 seconds or more to live */
if ((ttl - 60) > time_now || ttl == PERMANENT_TTL) {
if(ttl != PERMANENT_TTL)