Attachment #5044 for bug #30263

View | Details | Raw Unified | Return to bug 30263
Collapse All | Expand All




				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
				abort(); // FIXME
			}
			if (!(c_attr->values[c_attr->value_count] = malloc(data_size))) {
			if (!(c_attr->values[c_attr->value_count] = strndup((char*)data_data, data_size))) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
				abort(); // FIXME
			}
			c_attr->length[c_attr->value_count] = data_size;
			memcpy(c_attr->values[c_attr->value_count], data_data, data_size);
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "value is \"%s\"", c_attr->values[c_attr->value_count]);
			c_attr->values[++c_attr->value_count] = NULL;
			break;
   Bug #30227: listener: assert null termination
   
   Check key_len and data_len >= 1.
   Check key and data are always '\0' terminated, especially data:
   C-strings are naturally '\0' terminated, binary data is artifically '\0'
   terminated by us.




#include <stdbool.h>
#include <sys/types.h>

#include <assert.h>
#include <univention/debug.h>

#include "common.h"

			CacheEntryAttribute **attribute, *c_attr;

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "attribute is \"%s\"", (char*)key_data);
			/* key name including '\0' */
			assert(key_size >= 1);
			assert('\0' == ((char *)key_data)[key_size - 1]);
			/* value including '\0' */
			assert(data_size >= 1);
			assert('\0' == ((char *)data_data)[data_size - 1]);

			for (attribute = entry->attributes, c_attr = NULL;
					attribute != NULL && *attribute != NULL;
					attribute++) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "current attribute is \"%s\"", c_attr->name);
				if (strncmp(c_attr->name, (char*)key_data, key_size) == 0)
					c_attr = *attribute;
					break;
				}
			}
			if (!c_attr) {
				if (!(entry->attributes = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute*)))) {
   Bug #30227: listener: allocation checking
   
   allocate and check in one statement to reduce code repetition.




				}
			}
			if (!c_attr) {
				if (!(entry->attributes = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute*)))) {
				if (entry->attributes == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
					abort(); // FIXME
				}
				if (!(c_attr = malloc(sizeof(CacheEntryAttribute)))) {
				if (c_attr == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "malloc failed");
					abort(); // FIXME
				}
				if (!(c_attr->name = strndup((char*)key_data, key_size))) {
				if (c_attr->name == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
					abort(); // FIXME
				}


				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "%s is at %p", c_attr->name, c_attr);
			}
			if (!(c_attr->length = realloc(c_attr->length, (c_attr->value_count + 2) * sizeof(int)))) {
			if (c_attr->values == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
				abort(); // FIXME
			}
			if (!(c_attr->values = realloc(c_attr->values, (c_attr->value_count + 2) * sizeof(char*)))) {
			if (c_attr->length == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
				abort(); // FIXME
			}
			// TODO: stdndup() copies until the first \0, which would be incorrect if data is binary!
			if (!(c_attr->values[c_attr->value_count] = strndup((char*)data_data, data_size))) {
			if (c_attr->values[c_attr->value_count] == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
				abort(); // FIXME
			}


		case TYPE_MODULES:
			entry->modules = realloc(entry->modules, (entry->module_count + 2) * sizeof(char*));
			if (!(entry->modules[entry->module_count] = strndup((char*)key_data, key_size))) {
			if (entry->modules[entry->module_count] == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
				abort(); // FIXME
			}
			entry->modules[++entry->module_count] = NULL;
			entry->module_count++;
			break;

		default: {
   Bug #30227: listener: simplify pointer logic
   
   Track the current CacheAttribute in local variable instead of
   calculating it again and again.




	while ((type = read_header(data, size, &pos, &key_data, &key_size, &data_data, &data_size)) > 0) {
		switch (type) {
		case TYPE_ATTRIBUTE: {
			CacheEntryAttribute **attribute, *c_attr;
			bool found = false;

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "attribute is \"%s\"", (char*)key_data);

			for (attribute = entry->attributes, c_attr = NULL;
					attribute != NULL && *attribute != NULL;
					attribute++) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "current attribute is \"%s\"", c_attr->name);
				if (strcmp(c_attr->name, (char*)key_data) == 0) {
					c_attr = *attribute;
					break;
				}
			}
			if (!c_attr) {
				entry->attributes = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute*));
				if (entry->attributes == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
					abort(); // FIXME
				}
				c_attr = malloc(sizeof(CacheEntryAttribute));
				if (c_attr == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "malloc failed");
					abort(); // FIXME
				}
				c_attr->name = strndup((char*)key_data, key_size);
				if (c_attr->name == NULL) {
				attribute=entry->attributes+entry->attribute_count;
				(*attribute)->name = strndup((char*)key_data, key_size);
				if ((*attribute)->name == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
					abort(); // FIXME
				}
				c_attr->values = NULL;
				c_attr->length = NULL;
				c_attr->value_count = 0;
				entry->attributes[entry->attribute_count++] = c_attr;
				entry->attributes[entry->attribute_count] = NULL;

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "%s is at %p", c_attr->name, c_attr);
			}
			c_attr->values = realloc((*attribute)->values, ((*attribute)->value_count + 2) * sizeof(char*));
			if (c_attr->values == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
				abort(); // FIXME
			}
			c_attr->length = realloc((*attribute)->length, ((*attribute)->value_count + 2) * sizeof(int));
			if (c_attr->length == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");
				abort(); // FIXME
			}
			// TODO: stdndup() copies until the first \0, which would be incorrect if data is binary!
			c_attr->values[c_attr->value_count] = strndup((char*)data_data, data_size);
			if (c_attr->values[c_attr->value_count] == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");
				abort(); // FIXME
			}
			c_attr->length[c_attr->value_count] = data_size;
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "value is \"%s\"", c_attr->values[c_attr->value_count]);
			c_attr->values[++c_attr->value_count] = NULL;
			(*attribute)->value_count++;
			break;
		}

   Bug #30227: listener: convert if() to switch()
   
   Use switch() instead of multiple if()s to handle different types.
   Move variables to section where they are needed.




/* Decode CacheEntry from data chunk. */
int parse_entry(void *data, u_int32_t size, CacheEntry *entry)
{
	FILE *file;
	enum type type;
	void *key_data, *data_data;
	u_int32_t key_size, data_size;
	u_int32_t pos=0;
	char *f;

	entry->attributes=NULL;
	entry->attribute_count=0;

	entry->module_count=0;

	while ((type = read_header(data, size, &pos, &key_data, &key_size, &data_data, &data_size)) > 0) {
		switch (type) {
		case TYPE_ATTRIBUTE: {
			CacheEntryAttribute **attribute;
			bool found = false;


			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "value is \"%s\"", (*attribute)->values[(*attribute)->value_count]);
			(*attribute)->values[(*attribute)->value_count+1] = NULL;
			(*attribute)->value_count++;
			break;
		}

		case TYPE_MODULES:
			entry->modules = realloc(entry->modules, (entry->module_count + 2) * sizeof(char*));
			entry->modules[entry->module_count] = strndup((char*)key_data, key_size);
			if (entry->modules[entry->module_count] == NULL) {

			}
			entry->modules[entry->module_count+1] = NULL;
			entry->module_count++;
			break;

		default: {
			FILE *file;
			char *f;

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "bad data block at position %d:", pos);
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "last 100 bytes of previous entry:");
			hex_dump(UV_DEBUG_ERROR, data, pos-1000 < 0 ? 0 : pos-1000, pos-1000 < 0 ? pos : 1000);


			return -1;
		}
		}
	}

	return 0;
   Bug #30227: listener: white space cleanup
   
   Remove traling blanks.
   Break long lines.
   Insert blanks before assignment, comparison, after keyword.
   Reformat header files.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_lowlevel.c (-10 / +22 lines)

Lines 100-106 static int write_header(void *data, u_int32_t size, u_int32_t *pos, enum type	Link Here

100

101

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "write_header key_size=%d data_size=%d", key_size, data_size);

101

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "write_header key_size=%d data_size=%d", key_size, data_size);

102

103

	need_memory = sizeof(struct cache_entry_header)+key_size+data_size;

103

	need_memory = sizeof(struct cache_entry_header) + key_size + data_size;

104

	if (*size < *pos+need_memory) {

104

	if (*size < *pos+need_memory) {

105

		while (*size < *pos+need_memory)

105

		while (*size < *pos+need_memory)

106

			*size += BUFSIZ;

106

			*size += BUFSIZ;

Lines 121-126 static int write_header(void *data, u_int32_t size, u_int32_t *pos, enum type	Link Here

121

	return 0;

121

	return 0;

122

123

124

/* Encode CacheEntry to data chunk. */

124

int unparse_entry(void **data, u_int32_t *size, CacheEntry *entry)

125

int unparse_entry(void **data, u_int32_t *size, CacheEntry *entry)

125

126

	CacheEntryAttribute **attribute;

127

	CacheEntryAttribute **attribute;

Lines 130-137 int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	Link Here

130

	int i, rv = -1;

131

	int i, rv = -1;

131

	u_int32_t pos=0;

132

	u_int32_t pos=0;

132

133

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

134

	for (attribute = entry->attributes;

134

		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

135

			attribute != NULL && *attribute != NULL;

136

			attribute++) {

137

		length = (*attribute)->length;

138

		for (value = (*attribute)->values, i = 0;

139

				*value != NULL;

140

				value++, i++) {

135

			rv = write_header(data, size, &pos, TYPE_ATTRIBUTE,

141

			rv = write_header(data, size, &pos, TYPE_ATTRIBUTE,

136

					(*attribute)->name, strlen((*attribute)->name) + 1,

142

					(*attribute)->name, strlen((*attribute)->name) + 1,

137

					*value, length[i]);

143

					*value, length[i]);

Lines 139-145 int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	Link Here

139

				goto out;

145

				goto out;

140

146

141

147

142

	for (module=entry->modules; module != NULL && *module != NULL; module++) {

148

	for (module = entry->modules;

149

			module != NULL && *module != NULL;

150

			module++) {

143

		rv = write_header(data, size, &pos, TYPE_MODULES,

151

		rv = write_header(data, size, &pos, TYPE_MODULES,

144

				*module, strlen(*module) + 1,

152

				*module, strlen(*module) + 1,

145

				NULL, 0);

153

				NULL, 0);

Lines 203-208 static enum type read_header(void data, u_int32_t size, u_int32_t pos, void **	Link Here

203

	return h->type;

211

	return h->type;

204

212

205

213

214

/* Decode CacheEntry from data chunk. */

206

int parse_entry(void *data, u_int32_t size, CacheEntry *entry)

215

int parse_entry(void *data, u_int32_t size, CacheEntry *entry)

207

216

208

	FILE *file;

217

	FILE *file;

Lines 224-230 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

224

233

225

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "attribute is \"%s\"", (char*)key_data);

234

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "attribute is \"%s\"", (char*)key_data);

226

235

227

			for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

236

			for (attribute = entry->attributes;

237

					attribute != NULL && *attribute != NULL;

238

					attribute++) {

228

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "current attribute is \"%s\"", (*attribute)->name);

239

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "current attribute is \"%s\"", (*attribute)->name);

229

				if (strcmp((*attribute)->name, (char*)key_data) == 0) {

240

				if (strcmp((*attribute)->name, (char*)key_data) == 0) {

230

					found = true;

241

					found = true;

Lines 232-238 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

232

243

233

244

234

			if (!found) {

245

			if (!found) {

235

				entry->attributes = realloc(entry->attributes, (entry->attribute_count+2)*sizeof(CacheEntryAttribute*));

246

				entry->attributes = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute*));

236

				if (entry->attributes == NULL) {

247

				if (entry->attributes == NULL) {

237

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

248

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

238

					abort(); // FIXME

249

					abort(); // FIXME

Lines 258-269 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

258

269

259

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "%s is at %p", (*attribute)->name, *attribute);

270

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "%s is at %p", (*attribute)->name, *attribute);

260

271

261

			(*attribute)->values = realloc((*attribute)->values, ((*attribute)->value_count+2)*sizeof(char*));

272

			(*attribute)->values = realloc((*attribute)->values, ((*attribute)->value_count + 2) * sizeof(char*));

262

			if ((*attribute)->values == NULL) {

273

			if ((*attribute)->values == NULL) {

263

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

274

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

264

				abort(); // FIXME

275

				abort(); // FIXME

265

276

266

			(*attribute)->length = realloc((*attribute)->length, ((*attribute)->value_count+2)*sizeof(int));

277

			(*attribute)->length = realloc((*attribute)->length, ((*attribute)->value_count + 2) * sizeof(int));

267

			if ((*attribute)->length == NULL) {

278

			if ((*attribute)->length == NULL) {

268

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

279

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "realloc failed");

269

				abort(); // FIXME

280

				abort(); // FIXME

Lines 279-285 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

279

			(*attribute)->values[(*attribute)->value_count+1] = NULL;

290

			(*attribute)->values[(*attribute)->value_count+1] = NULL;

280

			(*attribute)->value_count++;

291

			(*attribute)->value_count++;

281

		} else if (type == TYPE_MODULES) {

292

		} else if (type == TYPE_MODULES) {

282

			entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));

293

			entry->modules = realloc(entry->modules, (entry->module_count + 2) * sizeof(char*));

283

			entry->modules[entry->module_count] = strndup((char*)key_data, key_size);

294

			entry->modules[entry->module_count] = strndup((char*)key_data, key_size);

284

			if (entry->modules[entry->module_count] == NULL) {

295

			if (entry->modules[entry->module_count] == NULL) {

285

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");

296

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "strndup failed");

Lines 294-300 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

294

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "first 100 bytes of current entry:");

305

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "first 100 bytes of current entry:");

295

			hex_dump(UV_DEBUG_ERROR, data, pos, pos+1000 > size ? size-pos : 1000);

306

			hex_dump(UV_DEBUG_ERROR, data, pos, pos+1000 > size ? size-pos : 1000);

296

307

297

			if (asprintf(&f, "%s/bad_cache", cache_dir) < 0) abort();

308

			if (asprintf(&f, "%s/bad_cache", cache_dir) < 0)

309

				abort();

298

			if ((file = fopen(f, "w")) != NULL) {

310

			if ((file = fopen(f, "w")) != NULL) {

299

				fprintf(file, "Check log file");

311

				fprintf(file, "Check log file");

300

				fclose(file);

312

				fclose(file);

301

   Bug #30227: listener: handle allocation failures

313

   Bug #30227: listener: handle allocation failures

302

314

303

   Abort on failed allocations and writes.

315

   Abort on failed allocations and writes.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_lowlevel.c (-4 / +10 lines)

Lines 127-152 int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	Link Here

127

	char **value;

127

	char **value;

128

	char **module;

128

	char **module;

129

	int *length;

129

	int *length;

130

	int i;

130

	int i, rv = -1;

131

	u_int32_t pos=0;

131

	u_int32_t pos=0;

132

133

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

133

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

134

		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

134

		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

135

			write_header(data, size, &pos, TYPE_ATTRIBUTE,

135

			rv = write_header(data, size, &pos, TYPE_ATTRIBUTE,

136

					(*attribute)->name, strlen((*attribute)->name) + 1,

136

					(*attribute)->name, strlen((*attribute)->name) + 1,

137

					*value, length[i]);

137

					*value, length[i]);

138

			if (rv)

139

				goto out;

138

140

139

141

140

	for (module=entry->modules; module != NULL && *module != NULL; module++) {

142

	for (module=entry->modules; module != NULL && *module != NULL; module++) {

141

		write_header(data, size, &pos, TYPE_MODULES,

143

		rv = write_header(data, size, &pos, TYPE_MODULES,

142

				*module, strlen(*module) + 1,

144

				*module, strlen(*module) + 1,

143

				NULL, 0);

145

				NULL, 0);

146

		if (rv)

147

			goto out;

144

148

145

149

146

	/* allocated memory maybe bigger than size, but doesn't matter anyhow... */

150

	/* allocated memory maybe bigger than size, but doesn't matter anyhow... */

147

	*size = pos;

151

	*size = pos;

152

	rv = 0;

148

153

149

	return 0;

154

out:

155

	return rv;

150

156

151

157

152

static enum type read_header(void *data, u_int32_t size, u_int32_t *pos, void **key_data, u_int32_t *key_size, void **data_data, u_int32_t *data_size)

158

static enum type read_header(void *data, u_int32_t size, u_int32_t *pos, void **key_data, u_int32_t *key_size, void **data_data, u_int32_t *data_size)

153

   Bug #30227: listener: change function signature

159

   Bug #30227: listener: change function signature

154

160

155

   No need to use pointer indirection.

161

   No need to use pointer indirection.

156

   Change function to void as it does not return anything.

162

   Change function to void as it does not return anything.




}

/* assumption: enough memory as been allocated for us */
static void append_buffer(void *data, u_int32_t size, u_int32_t *pos, void *blob_data, u_int32_t blob_size)
{
	if (blob_size > 0) {
		memcpy(((char*)data) + *pos, blob_data, blob_size);
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "position was=%d is=%d", *pos, *pos+blob_size);
		*pos += blob_size;
	}
	return 0;
}

static int write_header(void **data, u_int32_t *size, u_int32_t *pos, enum type type, void* key_data, u_int32_t key_size, void* data_data, u_int32_t data_size)

	h.key_size = key_size;
	h.data_size = data_size;

	append_buffer(*data, *size, pos, &h, sizeof(struct cache_entry_header));
	append_buffer(*data, *size, pos, key_data, key_size);
	append_buffer(*data, *size, pos, data_data, data_size);

	return 0;
}

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {
		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {
			write_header(data, size, &pos, TYPE_ATTRIBUTE,
					(*attribute)->name, strlen((*attribute)->name) + 1,
					*value, length[i]);
		}
	}
	for (module=entry->modules; module != NULL && *module != NULL; module++) {
		write_header(data, size, &pos, TYPE_MODULES,
				*module, strlen(*module) + 1,
				NULL, 0);
	}

   Bug #30227: listener: magic types
   
   Replace magic numbers for attributes and modules by named enum.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_lowlevel.c (-8 / +13 lines)

Lines 43-48	Link Here

#include "common.h"

#include "common.h"

#include "cache_lowlevel.h"

#include "cache_lowlevel.h"

enum type {

	TYPE_ATTRIBUTE = 1,

	TYPE_MODULES = 2,

};

struct cache_entry_header {

struct cache_entry_header {

	u_int16_t type;

	u_int16_t type;

	u_int32_t key_size;

	u_int32_t key_size;

Lines 89-95 static int append_buffer(void *data, u_int32_t size, u_int32_t pos, void blo	Link Here

	return 0;

	return 0;

static int write_header(void **data, u_int32_t *size, u_int32_t *pos, u_int16_t type, void* key_data, u_int32_t key_size, void* data_data, u_int32_t data_size)

static int write_header(void **data, u_int32_t *size, u_int32_t *pos, enum type type, void* key_data, u_int32_t key_size, void* data_data, u_int32_t data_size)

	struct cache_entry_header h;

	struct cache_entry_header h;

	u_int32_t need_memory;

100

	u_int32_t need_memory;

Lines 128-140 int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	Link Here

128

133

129

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

134

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {

130

		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

135

		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

131

			write_header(data, size, &pos, 1,

136

			write_header(data, size, &pos, TYPE_ATTRIBUTE,

132

					(void*) (*attribute)->name, strlen((*attribute)->name)+1,

137

					(void*) (*attribute)->name, strlen((*attribute)->name)+1,

133

					(void*) *value, length[i]);

138

					(void*) *value, length[i]);

134

139

135

140

136

	for (module=entry->modules; module != NULL && *module != NULL; module++) {

141

	for (module=entry->modules; module != NULL && *module != NULL; module++) {

137

		write_header(data, size, &pos, 2,

142

		write_header(data, size, &pos, TYPE_MODULES,

138

				(void*) *module, strlen(*module)+1,

143

				(void*) *module, strlen(*module)+1,

139

				NULL, 0);

144

				NULL, 0);

140

145

Lines 145-151 int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	Link Here

145

	return 0;

150

	return 0;

146

151

147

152

148

static int read_header(void *data, u_int32_t size, u_int32_t *pos, void **key_data, u_int32_t *key_size, void **data_data, u_int32_t *data_size)

153

static enum type read_header(void *data, u_int32_t size, u_int32_t *pos, void **key_data, u_int32_t *key_size, void **data_data, u_int32_t *data_size)

149

154

150

	struct cache_entry_header *h;

155

	struct cache_entry_header *h;

151

156

Lines 159-165 static int read_header(void data, u_int32_t size, u_int32_t pos, void **key_da	Link Here

159

164

160

	h = (struct cache_entry_header*)((char*)data+*pos);

165

	h = (struct cache_entry_header*)((char*)data+*pos);

161

166

162

	if ((h->type != 1 && h->type != 2) || h->key_size == 0) {

167

	if ((h->type != TYPE_ATTRIBUTE && h->type != TYPE_MODULES) || h->key_size == 0) {

163

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%d type=%d key_size=%d data_size=%d", *pos, h->type, h->key_size, h->data_size);

168

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%d type=%d key_size=%d data_size=%d", *pos, h->type, h->key_size, h->data_size);

164

		*key_size = 0;

169

		*key_size = 0;

165

		*key_data = NULL;

170

		*key_data = NULL;

Lines 196-202 static int read_header(void data, u_int32_t size, u_int32_t pos, void **key_da	Link Here

196

int parse_entry(void *data, u_int32_t size, CacheEntry *entry)

201

int parse_entry(void *data, u_int32_t size, CacheEntry *entry)

197

202

198

	FILE *file;

203

	FILE *file;

199

	u_int16_t type;

204

	enum type type;

200

	void *key_data, *data_data;

205

	void *key_data, *data_data;

201

	u_int32_t key_size, data_size;

206

	u_int32_t key_size, data_size;

202

	u_int32_t pos=0;

207

	u_int32_t pos=0;

Lines 208-214 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

208

	entry->module_count=0;

213

	entry->module_count=0;

209

214

210

	while ((type = read_header(data, size, &pos, &key_data, &key_size, &data_data, &data_size)) > 0) {

215

	while ((type = read_header(data, size, &pos, &key_data, &key_size, &data_data, &data_size)) > 0) {

211

		if (type == 1) {

216

		if (type == TYPE_ATTRIBUTE) {

212

			CacheEntryAttribute **attribute;

217

			CacheEntryAttribute **attribute;

213

			bool found = false;

218

			bool found = false;

214

219

Lines 268-274 int parse_entry(void data, u_int32_t size, CacheEntry entry)	Link Here

268

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "value is \"%s\"", (*attribute)->values[(*attribute)->value_count]);

273

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "value is \"%s\"", (*attribute)->values[(*attribute)->value_count]);

269

			(*attribute)->values[(*attribute)->value_count+1] = NULL;

274

			(*attribute)->values[(*attribute)->value_count+1] = NULL;

270

			(*attribute)->value_count++;

275

			(*attribute)->value_count++;

271

		} else if (type == 2) {

276

		} else if (type == TYPE_MODULES) {

272

			entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));

277

			entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));

273

			entry->modules[entry->module_count] = strndup((char*)key_data, key_size);

278

			entry->modules[entry->module_count] = strndup((char*)key_data, key_size);

274

			if (entry->modules[entry->module_count] == NULL) {

279

			if (entry->modules[entry->module_count] == NULL) {

275

   Bug #30227: listener: skip strdup(dn)

280

   Bug #30227: listener: skip strdup(dn)

276

281

277

   No need to duplicate the dn for printing the cache entries.

282

   No need to duplicate the dn for printing the cache entries.




	DBC *cur;
	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));
	key.data = dn;
	key.size = strlen(dn)+1;
	key.flags = DB_DBT_REALLOC;
	data.flags = DB_DBT_REALLOC;


	cur->c_close(cur);
	free(key.data);
	free(data.data);
	return 0;
}

   Bug #30227: listener: rewrite copy_cache
   
   Fix all out-of-memory cases.
   
   Allocate structures once instead of incrementally increasing the arrays
   again and again, since the size is known from the source entry before
   hand.
   
   Always copy bv_len + 1 bytes and terminate with '\0'.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_entry.c (-65 / +70 lines)

Lines 195-200 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

195

	int i;

195

	int i;

196

	char *ucrval;

196

	char *ucrval;

197

	enum { DUPLICATES, UNIQUE_UID, UNIQUE_MEMBER } check;

197

	enum { DUPLICATES, UNIQUE_UID, UNIQUE_MEMBER } check;

198

	size_t len;

198

199

	/* convert LDAP entry to cache entry */

200

	/* convert LDAP entry to cache entry */

200

	memset(cache_entry, 0, sizeof(CacheEntry));

201

	memset(cache_entry, 0, sizeof(CacheEntry));

Lines 220-225 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

220

			goto result;

221

			goto result;

221

222

		c_attr->name = strdup(attr);

223

		c_attr->name = strdup(attr);

224

		if (!c_attr->name) {

225

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for CacheEntryAttribute.name failed");

226

			goto result;

227

223

		c_attr->values = NULL;

228

		c_attr->values = NULL;

224

		c_attr->length = NULL;

229

		c_attr->length = NULL;

225

		c_attr->value_count = 0;

230

		c_attr->value_count = 0;

Lines 270-299 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

270

				if (i < c_attr->value_count)

275

				if (i < c_attr->value_count)

271

					continue;

276

					continue;

272

277

273

			if ((c_attr->values = realloc(c_attr->values, (c_attr->value_count + 2) * sizeof(char*))) == NULL) {

278

			len = (*v)->bv_len;

274

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of values array failed");

279

			if (!(c_attr->length = realloc(c_attr->length, (c_attr->value_count + 2) * sizeof(int)))) {

280

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of length array failed");

275

				goto result;

281

				goto result;

276

282

277

			if ((c_attr->length = realloc(c_attr->length, (c_attr->value_count + 2) * sizeof(int))) == NULL) {

283

			if (!(c_attr->values = realloc(c_attr->values, (c_attr->value_count + 2) * sizeof(char*)))) {

278

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of length array failed");

284

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of values array failed");

279

				goto result;

285

				goto result;

280

286

281

			if ((*v)->bv_len == strlen((*v)->bv_val)) {

287

			if (!(c_attr->values[c_attr->value_count] = malloc(len + 1))) {

282

				if ((c_attr->values[c_attr->value_count] = strdup((*v)->bv_val)) == NULL) {

288

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for value failed");

283

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: strdup of value failed");

289

				goto result;

284

					goto result;

285

286

				c_attr->length[c_attr->value_count] = strlen(c_attr->values[c_attr->value_count]) + 1;

287

			} else {	// in this case something is strange about the string in bv_val, maybe contains a '\0'

288

				// the legacy approach is to copy bv_len bytes, let's stick with this and just terminate to be safe

289

				if ((c_attr->values[c_attr->value_count] = malloc(((*v)->bv_len + 1) * sizeof(char))) == NULL) {

290

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for value failed");

291

					goto result;

292

293

				memcpy(c_attr->values[c_attr->value_count], (*v)->bv_val, (*v)->bv_len);

294

				c_attr->values[c_attr->value_count][(*v)->bv_len] = '\0'; // terminate the string to be safe

295

				c_attr->length[c_attr->value_count] = (*v)->bv_len + 1;

296

290

291

			c_attr->length[c_attr->value_count] = len + 1;

292

			memcpy(c_attr->values[c_attr->value_count], (*v)->bv_val, len);

293

			c_attr->values[c_attr->value_count][len] = '\0';

297

			c_attr->values[++c_attr->value_count] = NULL;

294

			c_attr->values[++c_attr->value_count] = NULL;

298

295

299

296

Lines 353-415 char** cache_entry_changed_attributes(CacheEntry new, CacheEntry old)	Link Here

353

	return changes;

350

	return changes;

354

351

355

352

356

int copy_cache_entry(CacheEntry *cache_entry, CacheEntry *backup_cache_entry) {

353

int copy_cache_entry(CacheEntry *src, CacheEntry *dst)

357

	CacheEntryAttribute **curs, **curb;

354

358

	int i;

359

	int rv = 1;

355

	int rv = 1;

360

356

361

	memset(backup_cache_entry, 0, sizeof(CacheEntry));

357

	memset(dst, 0, sizeof(CacheEntry));

362

	for (curs = cache_entry->attributes; curs != NULL && *curs != NULL; curs++) {

358

363

		if ((backup_cache_entry->attributes = realloc(backup_cache_entry->attributes, (backup_cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute*))) == NULL) {

359

	int a, a_count = src->attribute_count;

364

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of attributes array failed");

360

	if (!(dst->attributes = calloc(a_count + 1, sizeof(CacheEntryAttribute*)))) {

361

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc of attributes array failed");

362

		goto result;

363

364

	for (a = 0; a < a_count; a++) {

365

		CacheEntryAttribute *a_dst, *a_src = src->attributes[a];

366

		int v, v_count = a_src->value_count;

367

368

		if ((a_dst = malloc(sizeof(CacheEntryAttribute))) == NULL) {

369

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for CacheEntryAttribute failed");

365

			goto result;

370

			goto result;

366

371

367

		if ((backup_cache_entry->attributes[backup_cache_entry->attribute_count] = malloc(sizeof(CacheEntryAttribute))) == NULL) {

372

		memset(a_dst, 0, sizeof(CacheEntryAttribute));

368

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for CacheEntryAttribute failed");

373

		dst->attributes[a] = a_dst;

374

375

		if (!(a_dst->name = strdup(a_src->name))) {

376

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup for CacheEntryAttribute.name failed");

369

			goto result;

377

			goto result;

370

378

371

		curb = &backup_cache_entry->attributes[backup_cache_entry->attribute_count];

379

372

		(*curb)->name = strdup((*curs)->name);

380

		a_dst->value_count = v_count;

373

		(*curb)->values = NULL;

381

		if (!(a_dst->values = calloc(a_dst->value_count + 1, sizeof(char*)))) {

374

		(*curb)->length = NULL;

382

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of values array failed");

375

		(*curb)->value_count = 0;

383

			goto result;

376

		backup_cache_entry->attributes[backup_cache_entry->attribute_count + 1] = NULL;

384

377

385

		if (!(a_dst->length = calloc(a_dst->value_count + 1, sizeof(int)))) {

378

		for (i = 0; i < (*curs)->value_count; i++) {

386

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of length array failed");

379

			if (((*curb)->values = realloc((*curb)->values, ((*curb)->value_count + 2) * sizeof(char*))) == NULL) {

387

			goto result;

380

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of values array failed");

388

381

				goto result;

389

		for (v = 0; v < v_count; v++) {

382

390

			char *v_dst, *v_src = a_src->values[v];

383

			if (((*curb)->length = realloc((*curb)->length, ((*curb)->value_count + 2) * sizeof(int))) == NULL) {

391

			int len = a_src->length[v];

384

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of length array failed");

392

393

			if (!(v_dst = malloc(len))) {

394

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc of value failed");

385

				goto result;

395

				goto result;

386

396

387

			if ((*curs)->length[i] == strlen((*curs)->values[i]) + 1) {

397

			memcpy(v_dst, v_src, len);

388

				if (((*curb)->values[(*curb)->value_count] = strdup((*curs)->values[i])) == NULL) {

398

			a_dst->values[v] = v_dst;

389

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup of value failed");

399

			a_dst->length[v] = len;

390

					goto result;

391

392

				(*curb)->length[(*curb)->value_count] = strlen((*curb)->values[(*curb)->value_count]) + 1;

393

			} else {

394

				if (((*curb)->values[(*curb)->value_count] = malloc(((*curs)->length[i]) * sizeof(char))) == NULL) {

395

					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for value failed");

396

					goto result;

397

398

				memcpy((*curb)->values[(*curb)->value_count], (*curs)->values[i], (*curs)->length[i]);

399

				(*curb)->length[(*curb)->value_count] = (*curs)->length[i];

400

401

			(*curb)->values[(*curb)->value_count+1] = NULL;

402

			(*curb)->value_count++;

403

400

404

		backup_cache_entry->attribute_count++;

401

		a_dst->values[v] = NULL;

402

403

	dst->attributes[a] = NULL;

404

405

	int m, m_count = src->module_count;

406

	if (!(dst->modules = calloc(m_count + 1, sizeof(char*)))) {

407

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc of module array failed");

408

		goto result;

405

409

406

	char **module_ptr;

410

	for (m = 0; m < m_count; m++) {

407

	for (module_ptr = cache_entry->modules; module_ptr != NULL && *module_ptr != NULL; module_ptr++) {

411

		if (!(dst->modules[m] = strdup(src->modules[m]))) {

408

		backup_cache_entry->modules = realloc(backup_cache_entry->modules, (backup_cache_entry->module_count + 2) * sizeof(char*));

412

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup of module failed");

409

		backup_cache_entry->modules[backup_cache_entry->module_count] = strdup(*module_ptr);

413

			goto result;

410

		backup_cache_entry->modules[backup_cache_entry->module_count +1] = NULL;

414

411

		backup_cache_entry->module_count++;

412

415

416

	dst->modules[m] = NULL;

417

413

	rv = 0;

418

	rv = 0;

414

result:

419

result:

415

	return rv;

420

	return rv;

416

   Bug #30227: listener: Rename cursors

421

   Bug #30227: listener: Rename cursors

417

422

418

   Use more expressive variable names than cur[12].

423

   Use more expressive variable names than cur[12].




{
	char **changes = NULL;
	int changes_count = 0;
	CacheEntryAttribute **curn, **curo;

	for (curn = new->attributes; curn != NULL && *curn != NULL; curn++) {
		for (curo = old->attributes; curo != NULL && *curo != NULL; curo++)
			if (strcmp((*curn)->name, (*curo)->name) == 0)
				break;
		if (curo != NULL && *curo != NULL && (*curn)->value_count == (*curo)->value_count) {
			int i;
			for (i = 0; i < (*curn)->value_count; i++)
				if (memcmp((*curn)->values[i], (*curo)->values[i], (*curn)->length[i]) != 0)
					break;
			if (i == (*curn)->value_count)
				continue;
		}

		changes = realloc(changes, (changes_count + 2) * sizeof(char*));
		changes[changes_count++] = (*curn)->name;
		changes[changes_count] = NULL;
	}

	for (curo = old->attributes; curo != NULL && *curo != NULL; curo++) {
		for (curn = new->attributes; curn != NULL && *curn != NULL; curn++)
			if (strcmp((*curn)->name, (*curo)->name) == 0)
				break;
		if (curn != NULL && *curn != NULL)
			continue;

		changes = realloc(changes, (changes_count + 2) * sizeof(char*));
		changes[changes_count++] = (*curo)->name;
		changes[changes_count] = NULL;
	}


}

int copy_cache_entry(CacheEntry *cache_entry, CacheEntry *backup_cache_entry) {
	CacheEntryAttribute **curs, **curb;
	int i;
	int rv = 1;

	memset(backup_cache_entry, 0, sizeof(CacheEntry));
	for (curs = cache_entry->attributes; curs != NULL && *curs != NULL; curs++) {
		if ((backup_cache_entry->attributes = realloc(backup_cache_entry->attributes, (backup_cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute*))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of attributes array failed");
			goto result;

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for CacheEntryAttribute failed");
			goto result;
		}
		curb = &backup_cache_entry->attributes[backup_cache_entry->attribute_count];
		(*curb)->name = strdup((*curs)->name);
		(*curb)->values = NULL;
		(*curb)->length = NULL;
		(*curb)->value_count = 0;
		backup_cache_entry->attributes[backup_cache_entry->attribute_count + 1] = NULL;

		for (i = 0; i < (*curs)->value_count; i++) {
			if (((*curb)->values = realloc((*curb)->values, ((*curb)->value_count + 2) * sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of values array failed");
				goto result;
			}
			if (((*curb)->length = realloc((*curb)->length, ((*curb)->value_count + 2) * sizeof(int))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of length array failed");
				goto result;
			}
			if ((*curs)->length[i] == strlen((*curs)->values[i]) + 1) {
				if (((*curb)->values[(*curb)->value_count] = strdup((*curs)->values[i])) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup of value failed");
					goto result;
				}
				(*curb)->length[(*curb)->value_count] = strlen((*curb)->values[(*curb)->value_count]) + 1;
			} else {
				if (((*curb)->values[(*curb)->value_count] = malloc(((*curs)->length[i]) * sizeof(char))) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for value failed");
					goto result;
				}
				memcpy((*curb)->values[(*curb)->value_count], (*curs)->values[i], (*curs)->length[i]);
				(*curb)->length[(*curb)->value_count] = (*curs)->length[i];
			}
			(*curb)->values[(*curb)->value_count+1] = NULL;
			(*curb)->value_count++;
		}
		backup_cache_entry->attribute_count++;
	}

	}
	free(changes);

	char **curl, **curr;

	for (curl = lentry->modules; curl != NULL && *curl != NULL; curl++) {
		for (curr = rentry->modules; curr != NULL && *curr != NULL; curr++)
			if (strcmp(*curl, *curr) == 0)
				break;
		if (curr != NULL && *curr != NULL)
			continue;
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:     module %s on lentry missing on rentry\n", *curl);
	}
	for (curr = rentry->modules; curr != NULL && *curr != NULL; curr++) {
		for (curl = lentry->modules; curl != NULL && *curl != NULL; curl++)
			if (strcmp(*curl, *curr) == 0)
				break;
		if (curl != NULL && *curl != NULL)
			continue;
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:     module %s on rentry missing on lentry\n", *curr);
	}
}
   Bug #30227: listener: declare functions extern
   
   Mark all functions as extern, because the compiler will otherwise expect
   the real declaration after the declaration.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/base64.h (-2 / +2 lines)

Lines 39-49	Link Here

#define BASE64_ENCODE_LEN(n)      (((n)+2)/3 * 4)

#define BASE64_ENCODE_LEN(n)      (((n)+2)/3 * 4)

#define BASE64_DECODE_LEN(n)      (((n)+3)/4 * 3)

#define BASE64_DECODE_LEN(n)      (((n)+3)/4 * 3)

int base64_encode(u_char const *src,

extern int base64_encode(u_char const *src,

	size_t srclength,

	size_t srclength,

	char *target,

	char *target,

	size_t targsize);

	size_t targsize);

int base64_decode(char const *src,

extern int base64_decode(char const *src,

	u_char *target,

	u_char *target,

	size_t targsize);

	size_t targsize);




} CacheMasterEntry;
#endif

extern int cache_init(void);
#ifdef WITH_DB42
extern int cache_get_master_entry(CacheMasterEntry *master_entry);
extern int cache_update_master_entry(CacheMasterEntry *master_entry,
		DB_TXN *dptxnp);
#endif
extern int cache_update_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
inline int cache_update_entry_lower(NotifierID id,
		char *dn,
		CacheEntry *entry);
extern int cache_delete_entry(NotifierID id,
		char *dn);
extern int cache_delete_entry_lower_upper(NotifierID id,
		char *dn);
extern int cache_update_or_deleteifunused_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
extern int cache_get_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
extern int cache_get_entry_lower_upper(NotifierID id,
		char *dn,
		CacheEntry *entry);
extern int cache_first_entry(DBC **cur,
		char **dn,
		CacheEntry *entry);
extern int cache_next_entry(DBC **cur,
		char **dn,
		CacheEntry *entry);
extern int cache_free_cursor(DBC *cur);
extern int cache_close(void);

/* deprecated with DB42*/
extern int cache_set_int(const char *key,
		const NotifierID value);
extern int cache_get_int(const char *key,
		NotifierID *value,
		const long def);

extern int cache_get_schema_id(const char *key,
		NotifierID *value,
		const long def);
extern int cache_set_schema_id(const char *key,
		const NotifierID value);

#endif /* _CACHE_H_ */




/* Initialize interal setting once. */
extern void cache_entry_init(void);

extern int cache_free_entry(char **dn,
		CacheEntry *entry);
extern int cache_dump_entry(char *dn,
		CacheEntry *entry,
		FILE *fp);
extern int cache_new_entry_from_ldap(char **dn,
		CacheEntry *cache_entry,
		LDAP *ld,
		LDAPMessage *ldap_entry);
extern int cache_entry_module_add(CacheEntry *entry,
		char *module);
extern int cache_entry_module_remove(CacheEntry *entry,
		char *module);
extern int cache_entry_module_present(CacheEntry *entry,
		char *module);
extern char** cache_entry_changed_attributes(CacheEntry *new,
		CacheEntry *old);

extern int copy_cache_entry(CacheEntry *cache_entry,
		CacheEntry *backup_cache_entry);

extern void compare_cache_entries(CacheEntry *lentry,
		CacheEntry *rentry);

#endif /* _CACHE_ENTRY_H_ */





#include "cache.h"

extern int unparse_entry(void **data,
		u_int32_t *size,
		CacheEntry *entry);
extern int parse_entry(void *data,
		u_int32_t size,
		CacheEntry *entry);
extern void hex_dump(int level,
		void *data,
		u_int32_t start,
		u_int32_t size);





#include "network.h"

extern int change_new_modules(univention_ldap_parameters_t *lp);
extern int change_update_schema(univention_ldap_parameters_t *lp);
extern int change_update_entry(univention_ldap_parameters_t *lp,
		NotifierID id,
		LDAPMessage *ldap_entry,
		char command);
extern int change_delete_dn(NotifierID id,
		char *dn,
		char command);
extern int change_update_dn(univention_ldap_parameters_t *lp,
		NotifierID id,
		char *dn,
		char command,

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/common.h (-1 / +1 lines)

Lines 33-39	Link Here

#ifndef _COMMON_H_

#ifndef _COMMON_H_

#define _COMMON_H_

#define _COMMON_H_

void drop_privileges(void);

extern void drop_privileges(void);

#ifdef DMALLOC

#ifdef DMALLOC

#include <dmalloc.h>

#include <dmalloc.h>

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/filter.h (-1 / +1 lines)

Lines 36-42	Link Here

#include "cache.h"

#include "cache.h"

#include "handlers.h"

#include "handlers.h"

int cache_entry_ldap_filter_match(struct filter **filter,

extern int cache_entry_ldap_filter_match(struct filter **filter,

	char *dn,

	char *dn,

	CacheEntry *entry);

	CacheEntry *entry);




	int prepared : 1;
} typedef Handler;

extern int handlers_init(void);
extern int handlers_free_all(void);
extern int handlers_load_path(char *filename);
extern int handlers_reload_all_paths(void);
extern int handlers_dump(void);
extern int handlers_update(char *dn,
	CacheEntry *new,
	CacheEntry *old,
	char command,
	CacheEntry *scratch);
extern int handler_update(char *dn,
	CacheEntry *new,
	CacheEntry *old,
	Handler *handler,
	char command,
	CacheEntry *scratch);
extern int handlers_delete(char *dn,
	CacheEntry *old,
	char command);
extern int handler_clean(Handler *handler);
extern int handlers_clean_all(void);
extern int handler_initialize(Handler *handler);
extern int handlers_initialize_all(void);
extern int handlers_postrun_all(void);
extern int handlers_set_data_all(char *key,
	char *value);
extern char *handlers_filter(void);

#endif /* _HANDLERS_H_ */




	char *buf;
} typedef NotifierClient;

extern void notifier_entry_free(NotifierEntry *entry);
extern int notifier_client_new(NotifierClient *client,
	const char *server,
	int starttls);
extern void notifier_client_destroy(NotifierClient *client);
extern int notifier_wait(NotifierClient *client,
	time_t timeout);

extern int notifier_recv_result(NotifierClient *client,
	time_t timeout);
extern NotifierMessage*  notifier_get_msg(NotifierClient *client,
	int msgid);

extern int notifier_get_dn(NotifierClient *client,
	NotifierID id);
extern int notifier_resend_get_dn(NotifierClient *client,
	int msgid,
	NotifierID id);
extern int notifier_get_dn_result(NotifierClient *client,
	int msgid,
	NotifierEntry *entry);
extern int notifier_alive_s(NotifierClient *client);
extern int notifier_get_id_s(NotifierClient *client,
	NotifierID *id);
extern int notifier_get_schema_id_s(NotifierClient *client,
	NotifierID *id);

#endif /* _NETWORK_H_ */

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/notifier.h (-1 / +1 lines)

Lines 40-46	Link Here

typedef void univention_krb5_parameters_t;

typedef void univention_krb5_parameters_t;

#endif

#endif

int notifier_listen(univention_ldap_parameters_t *lp,

extern int notifier_listen(univention_ldap_parameters_t *lp,

	univention_krb5_parameters_t *kp,

	univention_krb5_parameters_t *kp,

	int write_transaction_file,

	int write_transaction_file,

	univention_ldap_parameters_t *lp_local);

	univention_ldap_parameters_t *lp_local);

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/select_server.h (-2 / +2 lines)

Lines 40-46 struct server_list {	Link Here

	int conn_attemp;

	int conn_attemp;

};

};

void select_server(univention_ldap_parameters_t *lp);

extern void select_server(univention_ldap_parameters_t *lp);

int suspend_connect(void);

extern int suspend_connect(void);

#endif

#endif

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/signals.h (-3 / +3 lines)

Lines 33-41	Link Here

#ifndef _SIGNALS_H_

#ifndef _SIGNALS_H_

#define _SIGNALS_H_

#define _SIGNALS_H_

void signals_block(void);

extern void signals_block(void);

void signals_unblock(void);

extern void signals_unblock(void);

void signals_init(void);

extern void signals_init(void);

extern void exit_handler(int sig) __attribute__((noreturn));

extern void exit_handler(int sig) __attribute__((noreturn));




#include "network.h"

extern char *transaction_file;
extern int notifier_write_transaction_file(NotifierEntry entry);

#endif /* _TRANSFILE_H_ */
   Bug #30227: listener: white space cleanup
   
   Remove traling blanks.
   Break long lines.
   Insert blanks before assignment, comparison, after keyword.
   Reformat header files.




#define BASE64_ENCODE_LEN(n)      (((n)+2)/3 * 4)
#define BASE64_DECODE_LEN(n)      (((n)+3)/4 * 3)

int base64_encode(u_char const *src,
	size_t srclength,
	char *target,
	size_t targsize);
int base64_decode(char const *src,
	u_char *target,
	size_t targsize);

#endif /* _BASE64_H_ */




} CacheMasterEntry;
#endif

int cache_init(void);
#ifdef WITH_DB42
int cache_get_master_entry(CacheMasterEntry *master_entry);
int cache_update_master_entry(CacheMasterEntry *master_entry,
		DB_TXN *dptxnp);
#endif
int cache_update_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
inline int cache_update_entry_lower(NotifierID id,
		char *dn,
		CacheEntry *entry);
int cache_delete_entry(NotifierID id,
		char *dn);
int cache_delete_entry_lower_upper(NotifierID id,
		char *dn);
int cache_update_or_deleteifunused_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
int cache_get_entry(NotifierID id,
		char *dn,
		CacheEntry *entry);
int cache_get_entry_lower_upper(NotifierID id,
		char *dn,
		CacheEntry *entry);
int cache_first_entry(DBC **cur,
		char **dn,
		CacheEntry *entry);
int cache_next_entry(DBC **cur,
		char **dn,
		CacheEntry *entry);
int cache_free_cursor(DBC *cur);
int cache_close(void);

/* deprecated with DB42*/
int cache_set_int(const char *key,
		const NotifierID value);
int cache_get_int(const char *key,
		NotifierID *value,
		const long def);

int cache_get_schema_id(const char *key,
		NotifierID *value,
		const long def);
int cache_set_schema_id(const char *key,
		const NotifierID value);

#endif /* _CACHE_H_ */




			if (len >= 0) {
				char *base64_value;
				size_t srclen = attribute->length[j] - 1;
				base64_value = malloc(BASE64_ENCODE_LEN(srclen) + 1);
				if (!base64_value)
					return 1;
				base64_encode((u_char *)value, srclen, base64_value, BASE64_ENCODE_LEN(srclen) + 1);

			}
		}
	}
	for (module = entry->modules; module != NULL && *module != NULL; module++) {
		fprintf(fp, "listenerModule: %s\n", *module);
	}


{
	char **cur;

	for (cur = entry->modules; cur != NULL && *cur != NULL; cur++) {
		if (strcmp(*cur, module) == 0)
			return 0;
	}

	entry->modules = realloc(entry->modules, (entry->module_count + 2) * sizeof(char*));
	if (!entry->modules)
		return 1;
	entry->modules[entry->module_count++] = strdup(module);

{
	char **cur;

	for (cur = entry->modules; cur != NULL && *cur != NULL; cur++) {
		if (strcmp(*cur, module) == 0)
			break;
	}


	/* replace entry that is to be removed with last entry */
	free(*cur);
	entry->modules[cur-entry->modules] = entry->modules[entry->module_count - 1];
	entry->modules[--entry->module_count] = NULL;

	entry->modules = realloc(entry->modules, (entry->module_count + 1) * sizeof(char*));

	return 0;
}


	if (entry == NULL)
		return 0;
	for (cur = entry->modules; cur != NULL && *cur != NULL; cur++) {
		if (strcmp(*cur, module) == 0)
			return 1;
	}

	memset(cache_entry, 0, sizeof(CacheEntry));
	if (dn != NULL) {
		char *_dn = ldap_get_dn(ld, ldap_entry);
		if (*dn)
			free(*dn);
		*dn = strdup(_dn);
		ldap_memfree(_dn);
	}

	for (attr = ldap_first_attribute(ld, ldap_entry, &ber);
			attr != NULL;
			attr = ldap_next_attribute(ld, ldap_entry, ber)) {
		struct berval **val, **v;

		if ((cache_entry->attributes = realloc(cache_entry->attributes, (cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute*))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of attributes array failed");
			goto result;
		}

			check = UNIQUE_MEMBER;
		else
			check = DUPLICATES;
		if ((val = ldap_get_values_len(ld, ldap_entry, attr)) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ldap_get_values failed");
			goto result;
		}
		for (v = val; *v != NULL; v++) {
			if ((*v)->bv_val == NULL) {
				// check here, strlen behavior might be undefined in this case
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: ignoring bv_val of NULL with bv_len=%ld, ignoring, check attribute: %s of DN: %s", (*v)->bv_len, c_attr->name, *dn);
				goto result;

			if (memberUidMode && check == UNIQUE_UID) {
				/* avoid duplicate memberUid entries https://forge.univention.org/bugzilla/show_bug.cgi?id=17998 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len + 1) ) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate memberUid entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "memberUid: %s", c_attr->values[i]);

			if (uniqueMemberMode && check == UNIQUE_MEMBER) {
				/* avoid duplicate uniqueMember entries https://forge.univention.org/bugzilla/show_bug.cgi?id=18692 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len + 1)) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate uniqueMember entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "uniqueMember: %s", c_attr->values[i]);

				continue;
		}

		changes = realloc(changes, (changes_count + 2) * sizeof(char*));
		changes[changes_count++] = (*cur1)->name;
		changes[changes_count] = NULL;
	}

		if (cur1 != NULL && *cur1 != NULL)
			continue;

		changes = realloc(changes, (changes_count + 2) * sizeof(char*));
		changes[changes_count++] = (*cur2)->name;
		changes[changes_count] = NULL;
	}


int copy_cache_entry(CacheEntry *cache_entry, CacheEntry *backup_cache_entry) {
	CacheEntryAttribute **cur1, **cur2;
	int i;
	int rv = 1;

	memset(backup_cache_entry, 0, sizeof(CacheEntry));
	for (cur1 = cache_entry->attributes; cur1 != NULL && *cur1 != NULL; cur1++) {
		if ((backup_cache_entry->attributes = realloc(backup_cache_entry->attributes, (backup_cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute*))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of attributes array failed");
			goto result;
		}

			goto result;
		}
		cur2 = &backup_cache_entry->attributes[backup_cache_entry->attribute_count];
		(*cur2)->name = strdup((*cur1)->name);
		(*cur2)->values = NULL;
		(*cur2)->length = NULL;
		(*cur2)->value_count = 0;
		backup_cache_entry->attributes[backup_cache_entry->attribute_count + 1] = NULL;

		for (i = 0; i < (*cur1)->value_count; i++) {
			if (((*cur2)->values = realloc((*cur2)->values, ((*cur2)->value_count + 2) * sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of values array failed");
				goto result;
			}
			if (((*cur2)->length = realloc((*cur2)->length, ((*cur2)->value_count + 2) * sizeof(int))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of length array failed");
				goto result;
			}
			if ((*cur1)->length[i] == strlen((*cur1)->values[i]) + 1) {
				if (((*cur2)->values[(*cur2)->value_count] = strdup((*cur1)->values[i])) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup of value failed");
					goto result;
				}
				(*cur2)->length[(*cur2)->value_count] = strlen((*cur2)->values[(*cur2)->value_count]) + 1;
			} else {
				if (((*cur2)->values[(*cur2)->value_count] = malloc(((*cur1)->length[i]) * sizeof(char))) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for value failed");
					goto result;
				}
				memcpy((*cur2)->values[(*cur2)->value_count], (*cur1)->values[i], (*cur1)->length[i]);
				(*cur2)->length[(*cur2)->value_count] = (*cur1)->length[i];
			}
			(*cur2)->values[(*cur2)->value_count+1] = NULL;
			(*cur2)->value_count++;
		}
		backup_cache_entry->attribute_count++;
	}
	char **module_ptr;
	for (module_ptr = cache_entry->modules; module_ptr != NULL && *module_ptr != NULL; module_ptr++) {
		backup_cache_entry->modules = realloc(backup_cache_entry->modules, (backup_cache_entry->module_count + 2) * sizeof(char*));
		backup_cache_entry->modules[backup_cache_entry->module_count] = strdup(*module_ptr);
		backup_cache_entry->modules[backup_cache_entry->module_count +1] = NULL;
		backup_cache_entry->module_count++;
	}
	rv = 0;


void compare_cache_entries(CacheEntry *lentry, CacheEntry *rentry)
{
	char **changes;
	char **cur;
	int i;

	changes = cache_entry_changed_attributes(lentry, rentry);

	for (cur = changes; cur != NULL && *cur != NULL; cur++) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:     %s differs\n", *cur);

		for (i = 0; lentry->attributes != NULL && lentry->attributes[i] != NULL; i++) {
			if (strcmp(lentry->attributes[i]->name, *cur) == 0)
				break;
		}

		} else {
			int j;
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:         lentry = [");
			for (j = 0; lentry->attributes[i]->values &&
					lentry->attributes[i]->values[j] != NULL;
					j++) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, j == 0 ? "%s" : ", %s", lentry->attributes[i]->values[j]);

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "]\n");
		}

		for (i = 0; rentry->attributes != NULL && rentry->attributes[i] != NULL; i++) {
			if (strcmp(rentry->attributes[i]->name, *cur) == 0)
				break;
		}

		} else {
			int j;
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:         rentry = [");
			for (j = 0; rentry->attributes[i]->values &&
					rentry->attributes[i]->values[j] != NULL;
					j++) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, j == 0 ? "%s" : ", %s", rentry->attributes[i]->values[j]);

	}
	free(changes);

	char **cur1, **cur2;

	for (cur1 = lentry->modules; cur1 != NULL && *cur1 != NULL; cur1++) {
		for (cur2 = rentry->modules; cur2 != NULL && *cur2 != NULL; cur2++)
			if (strcmp(*cur1, *cur2) == 0)
				break;
		if (cur2 != NULL && *cur2 != NULL)
			continue;
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ALERT:     module %s on lentry missing on rentry\n", *cur1);
	}
	for (cur2 = rentry->modules; cur2 != NULL && *cur2 != NULL; cur2++) {
		for (cur1 = lentry->modules; cur1 != NULL && *cur1 != NULL; cur1++)
			if (strcmp(*cur1, *cur2) == 0)
				break;
		if (cur1 != NULL && *cur1 != NULL)




#include <ldap.h>

struct _CacheEntryAttribute {
	char *name;
	char **values;
	int *length;
	int value_count;
} typedef CacheEntryAttribute;

struct _CacheEntry {
	CacheEntryAttribute **attributes;
	int attribute_count;
	char **modules;
	int module_count;
} typedef CacheEntry;

/* Initialize interal setting once. */
extern void cache_entry_init(void);

int cache_free_entry(char **dn,
		CacheEntry *entry);
int cache_dump_entry(char *dn,
		CacheEntry *entry,
		FILE *fp);
int cache_new_entry_from_ldap(char **dn,
		CacheEntry *cache_entry,
		LDAP *ld,
		LDAPMessage *ldap_entry);
int cache_entry_module_add(CacheEntry *entry,
		char *module);
int cache_entry_module_remove(CacheEntry *entry,
		char *module);
int cache_entry_module_present(CacheEntry *entry,
		char *module);
char** cache_entry_changed_attributes(CacheEntry *new,
		CacheEntry *old);

int copy_cache_entry(CacheEntry *cache_entry,
		CacheEntry *backup_cache_entry);

void compare_cache_entries(CacheEntry *lentry,
		CacheEntry *rentry);

#endif /* _CACHE_ENTRY_H_ */

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_lowlevel.h (-7 / +10 lines)

Lines 35-46	Link Here

#include "cache.h"

#include "cache.h"

int	unparse_entry	(void		**data,

int unparse_entry(void **data,

			 u_int32_t	 *size,

		u_int32_t *size,

			 CacheEntry	 *entry);

		CacheEntry *entry);

int	parse_entry	(void		 *data,

int parse_entry(void *data,

			 u_int32_t	  size,

		u_int32_t size,

			 CacheEntry	 *entry);

		CacheEntry *entry);

void hex_dump(int level, void *data, u_int32_t start, u_int32_t size);

void hex_dump(int level,

		void *data,

		u_int32_t start,

		u_int32_t size);

#endif /* _CACHE_LOWLEVEL_ */

#endif /* _CACHE_LOWLEVEL_ */





#include "network.h"

int change_new_modules(univention_ldap_parameters_t *lp);
int change_update_schema(univention_ldap_parameters_t *lp);
int change_update_entry(univention_ldap_parameters_t *lp,
		NotifierID id,
		LDAPMessage *ldap_entry,
		char command);
int change_delete_dn(NotifierID id,
		char *dn,
		char command);
int change_update_dn(univention_ldap_parameters_t *lp,
		NotifierID id,
		char *dn,
		char command,
		univention_ldap_parameters_t *lp_local);
				 univention_ldap_parameters_t   *lp_local);

#endif /* _CHANGE_H_ */

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/filter.h (-3 / +3 lines)

Lines 36-43	Link Here

#include "cache.h"

#include "cache.h"

#include "handlers.h"

#include "handlers.h"

int	cache_entry_ldap_filter_match	(struct filter	**filter,

int cache_entry_ldap_filter_match(struct filter **filter,

					 char		 *dn,

	char *dn,

					 CacheEntry	 *entry);

	CacheEntry *entry);

#endif /* _FILTER_H_ */

#endif /* _FILTER_H_ */




#define HANDLER_UNSET_FLAG(handler, flag)	handler->state &= ~flag

struct filter {
	char *base;
	int scope;
	char *filter;
};

struct _Handler {
	PyObject *module;
	char *name;
	char *description;
	struct filter **filters;
	char **attributes;
	char *modrdn;
	PyObject *handler;
	PyObject *initialize;
	PyObject *clean;
	PyObject *postrun;
	PyObject *prerun;
	PyObject *setdata;
	struct _Handler *next;

	int state;
	int prepared : 1;
} typedef Handler;

int handlers_init(void);
int handlers_free_all(void);
int handlers_load_path(char *filename);
int handlers_reload_all_paths(void);
int handlers_dump(void);
int handlers_update(char *dn,
	CacheEntry *new,
	CacheEntry *old,
	char command,
	CacheEntry *scratch);
int handler_update(char *dn,
	CacheEntry *new,
	CacheEntry *old,
	Handler *handler,
	char command,
	CacheEntry *scratch);
int handlers_delete(char *dn,
	CacheEntry *old,
	char command);
int handler_clean(Handler *handler);
int handlers_clean_all(void);
int handler_initialize(Handler *handler);
int handlers_initialize_all(void);
int handlers_postrun_all(void);
int handlers_set_data_all(char *key,
	char *value);
char *handlers_filter(void);

#endif /* _HANDLERS_H_ */




typedef unsigned long NotifierID;

struct _NotifierEntry {
	NotifierID id;
	char *dn;
	char command; /* 'd'elete, 'm'odify, 'a'dd */
} typedef NotifierEntry;

struct _NotifierMessage {
	int id;
	char *result;
	struct _NotifierMessage *next;
} typedef NotifierMessage;

struct _NotifierClient {
	char *server;
	int protocol;
	int starttls;
	int fd;
	NotifierMessage *messages;
	int last_msgid;
	char *buf;
} typedef NotifierClient;

void notifier_entry_free(NotifierEntry *entry);
int notifier_client_new(NotifierClient *client,
	const char *server,
	int starttls);
void notifier_client_destroy(NotifierClient *client);
int notifier_wait(NotifierClient *client,
	time_t timeout);

int notifier_recv_result(NotifierClient *client,
	time_t timeout);
NotifierMessage*  notifier_get_msg(NotifierClient *client,
	int msgid);

int notifier_get_dn(NotifierClient *client,
	NotifierID id);
int notifier_resend_get_dn(NotifierClient *client,
	int msgid,
	NotifierID id);
int notifier_get_dn_result(NotifierClient *client,
	int msgid,
	NotifierEntry *entry);
int notifier_alive_s(NotifierClient *client);
int notifier_get_id_s(NotifierClient *client,
	NotifierID *id);
int notifier_get_schema_id_s(NotifierClient *client,
	NotifierID *id);

#endif /* _NETWORK_H_ */

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/notifier.h (-4 / +4 lines)

Lines 40-48	Link Here

typedef void univention_krb5_parameters_t;

typedef void univention_krb5_parameters_t;

#endif

#endif

int	notifier_listen	(univention_ldap_parameters_t	*lp,

int notifier_listen(univention_ldap_parameters_t *lp,

			 univention_krb5_parameters_t	*kp,

	univention_krb5_parameters_t *kp,

			 int				 write_transaction_file,

	int write_transaction_file,

			 univention_ldap_parameters_t *lp_local);

	univention_ldap_parameters_t *lp_local);

#endif /* _NOTIFIER_H_ */

#endif /* _NOTIFIER_H_ */

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/signals.h (-4 / +4 lines)

Lines 33-42	Link Here

#ifndef _SIGNALS_H_

#ifndef _SIGNALS_H_

#define _SIGNALS_H_

#define _SIGNALS_H_

void	signals_block	(void);

void signals_block(void);

void	signals_unblock	(void);

void signals_unblock(void);

void	signals_init	(void);

void signals_init(void);

extern void	exit_handler	(int sig) __attribute__((noreturn));

extern void exit_handler(int sig) __attribute__((noreturn));

#endif /* _SIGNALS_H_ */

#endif /* _SIGNALS_H_ */




#include "network.h"

extern char *transaction_file;
int notifier_write_transaction_file(NotifierEntry entry);

#endif /* _TRANSFILE_H_ */
   Bug #30227: listener: fix ucr memory leak
   
   For every entry * for every attribute two UCR variable for the duplicate
   check were allocated, but never freed.
   
   Also initialize unique handling once instead of parsing base.conf twice
   for each entry.




#include "cache_entry.h"
#include "base64.h"

static bool memberUidMode;
static bool uniqueMemberMode;

/* Initialize interal setting once. */
void cache_entry_init(void)
{
	ucrval = univention_config_get_string("listener/memberuid/skip");
	if (ucrval) {
		memberUidMode |= !strcmp(ucrval, "yes") || !strcmp(ucrval, "true");
		free(ucrval);
	}
	ucrval = univention_config_get_string("listener/uniquemember/skip");
	if (ucrval) {
		uniqueMemberMode |= !strcmp(ucrval, "yes") || !strcmp(ucrval, "true");
		free(ucrval);
	}
}

int cache_free_entry(char **dn, CacheEntry *entry)
{
	int i, j;

	char *attr;
	int rv = 1;

	bool memberUidMode = false;
	bool uniqueMemberMode = false;
	int i;
	char *ucrval;
	enum { DUPLICATES, UNIQUE_UID, UNIQUE_MEMBER } check;

	/* convert LDAP entry to cache entry */
	memset(cache_entry, 0, sizeof(CacheEntry));

		cache_entry->attributes[cache_entry->attribute_count++] = c_attr;
		cache_entry->attributes[cache_entry->attribute_count] = NULL;

		if (!strcmp(c_attr->name, "memberUid"))
			check = UNIQUE_UID;
		else if (!strcmp(c_attr->name, "uniqueMember"))
			check = UNIQUE_MEMBER;
		else
			check = DUPLICATES;
				memberUidMode = !strcmp(ucrval, "yes") || !strcmp(ucrval, "true");
				free(ucrval);
			}
		}
		uniqueMemberMode = false;
		if (!strncmp(c_attr->name, "uniqueMember", strlen("uniqueMember"))) {
			char *ucrval;
			ucrval = univention_config_get_string("listener/uniquemember/skip");

			if (ucrval) {
				uniqueMemberMode = !strcmp(ucrval, "yes") || !strcmp(ucrval, "true");
				free(ucrval);
			}
		}
		if ((val=ldap_get_values_len(ld, ldap_entry, attr)) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ldap_get_values failed");
			goto result;

				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: ignoring bv_val of NULL with bv_len=%ld, ignoring, check attribute: %s of DN: %s", (*v)->bv_len, c_attr->name, *dn);
				goto result;
			}
			if (memberUidMode && check == UNIQUE_UID) {
				/* avoid duplicate memberUid entries https://forge.univention.org/bugzilla/show_bug.cgi?id=17998 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len+1) ) {

				if (i < c_attr->value_count)
					continue;
			}
			if (uniqueMemberMode && check == UNIQUE_MEMBER) {
				/* avoid duplicate uniqueMember entries https://forge.univention.org/bugzilla/show_bug.cgi?id=18692 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len+1)) {

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_entry.h (+3 lines)

Lines 50-55 struct _CacheEntry {	Link Here

	int			  module_count;

	int			  module_count;

} typedef CacheEntry;

} typedef CacheEntry;

/* Initialize interal setting once. */

extern void cache_entry_init(void);

int	cache_free_entry		(char		**dn,

int	cache_free_entry		(char		**dn,

					 CacheEntry	 *entry);

					 CacheEntry	 *entry);

int	cache_dump_entry		(char		 *dn,

int	cache_dump_entry		(char		 *dn,

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/main.c (+1 lines)

Lines 556-561 int main(int argc, char* argv[])	Link Here

556

557

	/* XXX: we shouldn't block all signals for so long */

557

	/* XXX: we shouldn't block all signals for so long */

558

	signals_block();

558

	signals_block();

559

	cache_entry_init();

559

	cache_init();

560

	cache_init();

560

	handlers_init();

561

	handlers_init();

561

562

   Bug #30227: listener: Handle allocation failure

563

   Bug #30227: listener: Handle allocation failure

563

564

   Check for failed allocation and abort with error.

565

   Check for failed allocation and abort with error.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_entry.c (+4 lines)

Lines 97-102 int cache_dump_entry(char dn, CacheEntry entry, FILE *fp)	Link Here

				char *base64_value;

				char *base64_value;

				size_t srclen = attribute->length[j] - 1;

				size_t srclen = attribute->length[j] - 1;

				base64_value = malloc(BASE64_ENCODE_LEN(srclen)+1);

				base64_value = malloc(BASE64_ENCODE_LEN(srclen)+1);

100

				if (!base64_value)

101

					return 1;

100

				base64_encode((u_char *)value, srclen, base64_value, BASE64_ENCODE_LEN(srclen) + 1);

102

				base64_encode((u_char *)value, srclen, base64_value, BASE64_ENCODE_LEN(srclen) + 1);

101

				fprintf(fp, "%s:: %s\n", attribute->name, base64_value);

103

				fprintf(fp, "%s:: %s\n", attribute->name, base64_value);

102

				free(base64_value);

104

				free(base64_value);

Lines 122-127 int cache_entry_module_add(CacheEntry entry, char module)	Link Here

122

124

123

125

124

	entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));

126

	entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));

127

	if (!entry->modules)

128

		return 1;

125

	entry->modules[entry->module_count++] = strdup(module);

129

	entry->modules[entry->module_count++] = strdup(module);

126

	entry->modules[entry->module_count] = NULL;

130

	entry->modules[entry->module_count] = NULL;

127

131

128

   Bug #30227: listener: list entry

132

   Bug #30227: listener: list entry

129

133

130

   Use post-increment when storing new entries to make sure, that on error

134

   Use post-increment when storing new entries to make sure, that on error

131

   paths al elements are freed.

135

   paths al elements are freed.




	}

	entry->modules = realloc(entry->modules, (entry->module_count+2)*sizeof(char*));
	entry->modules[entry->module_count++] = strdup(module);
	entry->modules[entry->module_count] = NULL;
	entry->module_count++;

	return 0;
}

	/* replace entry that is to be removed with last entry */
	free(*cur);
	entry->modules[cur-entry->modules] = entry->modules[entry->module_count-1];
	entry->modules[--entry->module_count] = NULL;
	entry->module_count--;

	entry->modules = realloc(entry->modules, (entry->module_count+1)*sizeof(char*));


		}

		changes = realloc(changes, (changes_count+2)*sizeof(char*));
		changes[changes_count++] = (*cur1)->name;
		changes[changes_count] = NULL;
		changes_count++;
	}

	for (cur2 = old->attributes; cur2 != NULL && *cur2 != NULL; cur2++) {

			continue;

		changes = realloc(changes, (changes_count+2)*sizeof(char*));
		changes[changes_count++] = (*cur2)->name;
		changes[changes_count] = NULL;
		changes_count++;
	}

	return changes;
   Bug #30227: listener: simplify repeated dereference
   
   Replace lookup to current element with local variable.




int cache_new_entry_from_ldap(char **dn, CacheEntry *cache_entry, LDAP *ld, LDAPMessage *ldap_entry)
{
	BerElement *ber;
	CacheEntryAttribute *c_attr;
	char *attr;
	int rv = 1;


			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of attributes array failed");
			goto result;
		}
		if ((c_attr = malloc(sizeof(CacheEntryAttribute))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for CacheEntryAttribute failed");
			goto result;
		}
		c_attr->name = strdup(attr);
		c_attr->values = NULL;
		c_attr->length = NULL;
		c_attr->value_count = 0;
		cache_entry->attributes[cache_entry->attribute_count++] = c_attr;
		cache_entry->attributes[cache_entry->attribute_count] = NULL;

		memberUidMode = false;
		if (!strncmp(c_attr->name, "memberUid", strlen("memberUid"))) {
			char *ucrval;
			ucrval = univention_config_get_string("listener/memberuid/skip");


			}
		}
		uniqueMemberMode = false;
		if (!strncmp(c_attr->name, "uniqueMember", strlen("uniqueMember"))) {
			char *ucrval;
			ucrval = univention_config_get_string("listener/uniquemember/skip");


		for (v = val; *v != NULL; v++) {
			if ( (*v)->bv_val == NULL ) {
				// check here, strlen behavior might be undefined in this case
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: ignoring bv_val of NULL with bv_len=%ld, ignoring, check attribute: %s of DN: %s", (*v)->bv_len, c_attr->name, *dn);
				goto result;
			}
			if (memberUidMode) {
				/* avoid duplicate memberUid entries https://forge.univention.org/bugzilla/show_bug.cgi?id=17998 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len+1) ) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate memberUid entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "memberUid: %s", c_attr->values[i]);
						break;
					}
				}

			}
			if (uniqueMemberMode) {
				/* avoid duplicate uniqueMember entries https://forge.univention.org/bugzilla/show_bug.cgi?id=18692 */
				for (i = 0; i < c_attr->value_count; i++) {
					if (!memcmp(c_attr->values[i], (*v)->bv_val, (*v)->bv_len+1)) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate uniqueMember entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "uniqueMember: %s", c_attr->values[i]);
						break;
					}
				}

				if (i < c_attr->value_count)
					continue;
			}
			if ((c_attr->values = realloc(c_attr->values, (c_attr->value_count + 2) * sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of values array failed");
				goto result;
			}
			if ((c_attr->length = realloc(c_attr->length, (c_attr->value_count + 2) * sizeof(int))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of length array failed");
				goto result;
			}
			if ((*v)->bv_len == strlen((*v)->bv_val)) {
				if ((c_attr->values[c_attr->value_count] = strdup((*v)->bv_val)) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: strdup of value failed");
					goto result;
				}
				c_attr->length[c_attr->value_count] = strlen(c_attr->values[c_attr->value_count]) + 1;
			} else {	// in this case something is strange about the string in bv_val, maybe contains a '\0'
				// the legacy approach is to copy bv_len bytes, let's stick with this and just terminate to be safe
				if ((c_attr->values[c_attr->value_count] = malloc(((*v)->bv_len + 1) * sizeof(char))) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for value failed");
					goto result;
				}
				memcpy(c_attr->values[c_attr->value_count], (*v)->bv_val, (*v)->bv_len);
				c_attr->values[c_attr->value_count][(*v)->bv_len] = '\0'; // terminate the string to be safe
				c_attr->length[c_attr->value_count] = (*v)->bv_len + 1;
			}
			c_attr->values[++c_attr->value_count] = NULL;
			cache_entry->attributes[cache_entry->attribute_count]->value_count++;
		}
		cache_entry->attribute_count++;

		ldap_value_free_len(val);
		ldap_memfree(attr);
   Bug #30227: listener: simplify next value loop
   
   Remove variable and directly continue with next variable when duplicate
   value is detected.





	bool memberUidMode = false;
	bool uniqueMemberMode = false;
	bool duplicateMemberUid = false;
	bool duplicateUniqueMember = false;
	int i;

	/* convert LDAP entry to cache entry */

			}
			if (memberUidMode) {
				/* avoid duplicate memberUid entries https://forge.univention.org/bugzilla/show_bug.cgi?id=17998 */
				duplicateMemberUid = 0;
				for (i=0; i<cache_entry->attributes[cache_entry->attribute_count]->value_count; i++) {
					if (!memcmp(cache_entry->attributes[cache_entry->attribute_count]->values[i], (*v)->bv_val, (*v)->bv_len+1) ) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate memberUid entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "memberUid: %s", cache_entry->attributes[cache_entry->attribute_count]->values[i]);
						duplicateMemberUid = true;
						break;
					}
				}
				/* skip this memberUid entry if listener/memberuid/skip is set to yes */
				if (i < c_attr->value_count)
					continue;
				}
			}
			if (uniqueMemberMode) {
				/* avoid duplicate uniqueMember entries https://forge.univention.org/bugzilla/show_bug.cgi?id=18692 */
				duplicateUniqueMember = false;
				for (i=0; i<cache_entry->attributes[cache_entry->attribute_count]->value_count; i++) {
					if (!memcmp(cache_entry->attributes[cache_entry->attribute_count]->values[i], (*v)->bv_val, (*v)->bv_len+1) ) {
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Found a duplicate uniqueMember entry:");
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "DN: %s",  *dn);
						univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "uniqueMember: %s", cache_entry->attributes[cache_entry->attribute_count]->values[i]);
						duplicateUniqueMember = true;
						break;
					}
				}
				/* skip this uniqueMember entry if listener/uniquemember/skip is set to yes */
				if (i < c_attr->value_count)
					continue;
				}
			}
			if ((cache_entry->attributes[cache_entry->attribute_count]->values = realloc(cache_entry->attributes[cache_entry->attribute_count]->values, (cache_entry->attributes[cache_entry->attribute_count]->value_count+2)*sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of values array failed");
   Bug #30227: listener: simplify indirect pointers
   
   Replace pointer to pointer by pointer itself.





int cache_dump_entry(char *dn, CacheEntry *entry, FILE *fp)
{
	int i, j;
	char **module;
	char **value;

	fprintf(fp, "dn: %s\n", dn);
	for (i = 0; i < entry->attribute_count; i++) {
		CacheEntryAttribute *attribute = entry->attributes[i];
		for (j = 0; j < entry->attributes[i]->value_count; j++) {
			int len = attribute->length[j] - 1;
			char *c, *value = attribute->values[j];
			for (c = value; len >= 0; c++, len--) {
			for (c=*value; *c != '\0'; c++) {
				if (!isgraph(*c))
					break;
			}
			if (len >= 0) {
				char *base64_value;
				size_t srclen = attribute->length[j] - 1;
				base64_value = malloc(BASE64_ENCODE_LEN(srclen)+1);
				base64_encode((u_char *)value, srclen, base64_value, BASE64_ENCODE_LEN(srclen) + 1);
				fprintf(fp, "%s:: %s\n", attribute->name, base64_value);
				free(base64_value);
			} else {
				fprintf(fp, "%s: %s\n", attribute->name, value);
			}
		}
	}
   Bug #30227: listener: Fix NULL check
   
   Check pointer for NULL before freeing sub structures.
   Calling free(NULL) is okay.




		*dn = NULL;
	}

	if (entry->attributes) {
		for(i = 0; i < entry->attribute_count; i++) {
			if (entry->attributes[i]) {
				free(entry->attributes[i]->name);
				for (j = 0; j < entry->attributes[i]->value_count; j++)
					free(entry->attributes[i]->values[j]);
				free(entry->attributes[i]->values);
				free(entry->attributes[i]->length);
				free(entry->attributes[i]);
			}
		}
		if(entry->attributes[i]->values) {
			free(entry->attributes[i]->values);
		}
		if(entry->attributes[i]->length) {
			free(entry->attributes[i]->length);
		}
		if(entry->attributes[i]) {
			free(entry->attributes[i]);
		}
	}

	if (entry->attributes) {
		free(entry->attributes);
		entry->attributes = NULL;
		entry->attribute_count = 0;
	}

	if (entry->modules) {
		for (i = 0; i < entry->module_count; i++)
			free(entry->modules[i]);
		}
	}

	if(entry->modules) {
		free(entry->modules);
		entry->modules = NULL;
		entry->module_count = 0;
	}

	entry->modules = NULL;
	entry->module_count = 0;

	return 0;
}

   Bug #30227: listener: error by default
   
   Switch return value to return error by default and 0 only on success.




{
	BerElement *ber;
	char *attr;
	int rv = 1;

	bool memberUidMode = false;
	bool uniqueMemberMode = false;


		if ((cache_entry->attributes = realloc(cache_entry->attributes, (cache_entry->attribute_count+2)*sizeof(CacheEntryAttribute*))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of attributes array failed");
			rv = 1;
			goto result;
		}
		if ((cache_entry->attributes[cache_entry->attribute_count] = malloc(sizeof(CacheEntryAttribute))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for CacheEntryAttribute failed");
			rv = 1;
			goto result;
		}
		cache_entry->attributes[cache_entry->attribute_count]->name=strdup(attr);

		}
		if ((val=ldap_get_values_len(ld, ldap_entry, attr)) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "ldap_get_values failed");
			rv = 1;
			goto result;
		}
		for (v = val; *v != NULL; v++) {
			if ( (*v)->bv_val == NULL ) {
				// check here, strlen behavior might be undefined in this case
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: ignoring bv_val of NULL with bv_len=%ld, ignoring, check attribute: %s of DN: %s", (*v)->bv_len, cache_entry->attributes[cache_entry->attribute_count]->name, *dn);
				rv = 1;
				goto result;
			}
			if (memberUidMode) {

			}
			if ((cache_entry->attributes[cache_entry->attribute_count]->values = realloc(cache_entry->attributes[cache_entry->attribute_count]->values, (cache_entry->attributes[cache_entry->attribute_count]->value_count+2)*sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of values array failed");
				rv = 1;
				goto result;
			}
			if ((cache_entry->attributes[cache_entry->attribute_count]->length = realloc(cache_entry->attributes[cache_entry->attribute_count]->length, (cache_entry->attributes[cache_entry->attribute_count]->value_count+2)*sizeof(int))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: realloc of length array failed");
				rv = 1;
				goto result;
			}
			if ((*v)->bv_len == strlen((*v)->bv_val)) {
				if ((cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count]=strdup((*v)->bv_val)) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: strdup of value failed");
					rv = 1;
					goto result;
				}
				cache_entry->attributes[cache_entry->attribute_count]->length[cache_entry->attributes[cache_entry->attribute_count]->value_count]=strlen(cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count])+1;

				// the legacy approach is to copy bv_len bytes, let's stick with this and just terminate to be safe
				if ((cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count]=malloc(((*v)->bv_len+1)*sizeof(char))) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "cache_new_entry_from_ldap: malloc for value failed");
					rv = 1;
					goto result;
				}
				memcpy(cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count],(*v)->bv_val,(*v)->bv_len);

	}

	ber_free(ber, 0);
	rv = 0;

result:
	if (rv != 0)

int copy_cache_entry(CacheEntry *cache_entry, CacheEntry *backup_cache_entry) {
	CacheEntryAttribute **cur1, **cur2;
	int i=0;
	int rv=1;
	memset(backup_cache_entry, 0, sizeof(CacheEntry));
	for (cur1 = cache_entry->attributes; cur1 != NULL && *cur1 != NULL; cur1++) {
		if ((backup_cache_entry->attributes = realloc(backup_cache_entry->attributes, (backup_cache_entry->attribute_count+2)*sizeof(CacheEntryAttribute*))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of attributes array failed");
			rv = 1;
			goto result;
		}
		if ((backup_cache_entry->attributes[backup_cache_entry->attribute_count] = malloc(sizeof(CacheEntryAttribute))) == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for CacheEntryAttribute failed");
			rv = 1;
			goto result;
		}
		cur2 = &backup_cache_entry->attributes[backup_cache_entry->attribute_count];

		for (i = 0; i < (*cur1)->value_count; i++) {
			if (((*cur2)->values = realloc((*cur2)->values, ((*cur2)->value_count+2)*sizeof(char*))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of values array failed");
				rv = 1;
				goto result;
			}
			if (((*cur2)->length = realloc((*cur2)->length, ((*cur2)->value_count+2)*sizeof(int))) == NULL) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: realloc of length array failed");
				rv = 1;
				goto result;
			}
			if ((*cur1)->length[i] == strlen((*cur1)->values[i]) + 1) {
				if (((*cur2)->values[(*cur2)->value_count]=strdup((*cur1)->values[i])) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: strdup of value failed");
					rv = 1;
					goto result;
				}
				(*cur2)->length[(*cur2)->value_count]=strlen((*cur2)->values[(*cur2)->value_count])+1;
			} else {
				if (((*cur2)->values[(*cur2)->value_count]=malloc(((*cur1)->length[i])*sizeof(char))) == NULL) {
					univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "copy_cache_entry: malloc for value failed");
					rv = 1;
					goto result;
				}
				memcpy((*cur2)->values[(*cur2)->value_count],(*cur1)->values[i],(*cur1)->length[i]);

		backup_cache_entry->modules[backup_cache_entry->module_count+1] = NULL;
		backup_cache_entry->module_count++;
	}
	rv = 0;
result:
	return rv;
}
   Bug #30227: listener: dn memory leak
   
   Free dn on errors.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_entry.c (-1 / +1 lines)

Lines 328-334 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

328

329

result:

329

result:

330

	if (rv != 0)

330

	if (rv != 0)

331

		cache_free_entry(NULL, cache_entry);

331

		cache_free_entry(dn, cache_entry);

332

333

	return rv;

333

	return rv;

334

335

   Bug #30227: listener: use local dn variable

335

   Bug #30227: listener: use local dn variable

336

337

   Declare variable only in-scope.

337

   Declare variable only in-scope.

(-)a/branches/ucs-3.1/ucs/management/univention-directory-listener/src/cache_entry.c (-2 / +1 lines)

Lines 184-190 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

184

185

	BerElement *ber;

185

	BerElement *ber;

186

	char *attr;

186

	char *attr;

187

	char *_dn;

188

	int rv = 0;

187

	int rv = 0;

189

188

190

	bool memberUidMode = false;

189

	bool memberUidMode = false;

Lines 196-202 int cache_new_entry_from_ldap(char *dn, CacheEntry cache_entry, LDAP *ld, LDAP	Link Here

196

	/* convert LDAP entry to cache entry */

195

	/* convert LDAP entry to cache entry */

197

	memset(cache_entry, 0, sizeof(CacheEntry));

196

	memset(cache_entry, 0, sizeof(CacheEntry));

198

	if (dn != NULL) {

197

	if (dn != NULL) {

199

		_dn = ldap_get_dn(ld, ldap_entry);

198

		char *_dn = ldap_get_dn(ld, ldap_entry);

200

		if(*dn)

199

		if(*dn)

201

				free(*dn);

200

				free(*dn);

202

		*dn = strdup(_dn);

201

		*dn = strdup(_dn);

Return to bug 30263