key                40 examples/perfcounter/perf_writer.c     char key[NAME_LEN];
key                43 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, obj.index, "inst");
key                46 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, sdata, TDB_INSERT);
key                53 examples/perfcounter/perf_writer.c     char key[NAME_LEN];
key                57 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, counter.index, NULL);
key                58 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, counter.name, TDB_INSERT);
key                60 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, counter.index + 1, NULL);
key                61 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, counter.help, TDB_INSERT);
key                63 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, counter.index, "rel");
key                64 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, counter.relationships, TDB_INSERT);
key                68 examples/perfcounter/perf_writer.c 	make_key(key, NAME_LEN, counter.index, "type");
key                71 examples/perfcounter/perf_writer.c 	add_key(rt.cnames, key, sdata, TDB_INSERT);
key               111 examples/perfcounter/perf_writer.c     char key[NAME_LEN];
key               115 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, counter.index, NULL);
key               125 examples/perfcounter/perf_writer.c     add_key(rt.cdata, key, sdata, tdb_flags);
key               138 examples/perfcounter/perf_writer.c     char key[NAME_LEN];
key               141 examples/perfcounter/perf_writer.c     memset(key, 0, NAME_LEN);
key               142 examples/perfcounter/perf_writer.c     sprintf(key, "%di%d", parentObjInd, instanceInd);
key               143 examples/perfcounter/perf_writer.c     add_key_raw(rt.cdata, key, instData, dsize, tdb_flags);
key               146 examples/perfcounter/perf_writer.c     memset(key, 0, NAME_LEN);
key               147 examples/perfcounter/perf_writer.c     sprintf(key, "%di%dname", parentObjInd, instanceInd);
key               148 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, name, tdb_flags);
key               156 examples/perfcounter/perf_writer.c     char key[NAME_LEN];
key               160 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, 1, NULL);
key               163 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, sdata, tdb_flags);
key               166 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, 0, "PerfTime");
key               168 examples/perfcounter/perf_writer.c     add_key(rt.cdata, key, sdata, tdb_flags);
key               169 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, 0, "PerfTime100nSec");
key               172 examples/perfcounter/perf_writer.c     add_key(rt.cdata, key, sdata, tdb_flags);
key               174 examples/perfcounter/perf_writer.c     make_key(key, NAME_LEN, 0, "PerfFreq");
key               176 examples/perfcounter/perf_writer.c     add_key(rt.cnames, key, sdata, tdb_flags);
key                33 examples/perfcounter/perf_writer_util.c   TDB_DATA key, data;
key                35 examples/perfcounter/perf_writer_util.c   key.dptr = keystring;
key                36 examples/perfcounter/perf_writer_util.c   key.dsize = strlen(keystring);
key                40 examples/perfcounter/perf_writer_util.c   tdb_store(db, key, data, flags);
key                45 examples/perfcounter/perf_writer_util.c   TDB_DATA key, data;
key                47 examples/perfcounter/perf_writer_util.c   key.dptr = keystring;
key                48 examples/perfcounter/perf_writer_util.c   key.dsize = strlen(keystring);
key                52 examples/perfcounter/perf_writer_util.c   tdb_store(db, key, data, flags);
key               129 examples/printing/prtpub.c void map_generic_boolean(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key)
key               134 examples/printing/prtpub.c 	printf("%s: %s\n", key, boolval ? "TRUE" : "FALSE");
key               135 examples/printing/prtpub.c 	SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_BINARY, &boolval, sizeof(boolval));
key               138 examples/printing/prtpub.c void map_generic_dword(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key)
key               146 examples/printing/prtpub.c 	printf("%s: %d\n", key, dword);
key               147 examples/printing/prtpub.c 	SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_DWORD, (BYTE *) &dword, sizeof(dword));
key               150 examples/printing/prtpub.c void map_generic_multi_sz(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key, int size)
key               162 examples/printing/prtpub.c 	printf("%s:\n", key);
key               169 examples/printing/prtpub.c 	SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_MULTI_SZ, strings_out, 
key                26 lib/crypto/arcfour.c _PUBLIC_ void arcfour_init(struct arcfour_state *state, const DATA_BLOB *key) 
key                37 lib/crypto/arcfour.c 		j += (state->sbox[ind] + key->data[ind%key->length]);
key                71 lib/crypto/arcfour.c _PUBLIC_ void arcfour_crypt_blob(uint8_t *data, int len, const DATA_BLOB *key) 
key                74 lib/crypto/arcfour.c 	arcfour_init(&state, key);
key                84 lib/crypto/arcfour.c 	DATA_BLOB key = data_blob(keystr, 16);
key                86 lib/crypto/arcfour.c 	arcfour_crypt_blob(data, len, &key);
key                88 lib/crypto/arcfour.c 	data_blob_free(&key);
key                10 lib/crypto/arcfour.h void arcfour_init(struct arcfour_state *state, const DATA_BLOB *key);
key                12 lib/crypto/arcfour.h void arcfour_crypt_blob(uint8_t *data, int len, const DATA_BLOB *key);
key                31 lib/crypto/hmacmd5.c _PUBLIC_ void hmac_md5_init_rfc2104(const uint8_t *key, int key_len, HMACMD5Context *ctx)
key                42 lib/crypto/hmacmd5.c                 MD5Update(&tctx, key, key_len);
key                45 lib/crypto/hmacmd5.c                 key = tk;
key                52 lib/crypto/hmacmd5.c         memcpy( ctx->k_ipad, key, key_len);
key                53 lib/crypto/hmacmd5.c         memcpy( ctx->k_opad, key, key_len);
key                69 lib/crypto/hmacmd5.c _PUBLIC_ void hmac_md5_init_limK_to_64(const uint8_t *key, int key_len,
key                78 lib/crypto/hmacmd5.c 	hmac_md5_init_rfc2104(key, key_len, ctx);
key               108 lib/crypto/hmacmd5.c _PUBLIC_ void hmac_md5(const uint8_t key[16], const uint8_t *data, int data_len, uint8_t *digest)
key               111 lib/crypto/hmacmd5.c 	hmac_md5_init_limK_to_64(key, 16, &ctx);
key                34 lib/crypto/hmacmd5.h void hmac_md5_init_limK_to_64(const uint8_t *key, int key_len,
key                38 lib/crypto/hmacmd5.h void hmac_md5(const uint8_t key[16], const uint8_t *data, int data_len, uint8_t *digest);
key                39 lib/crypto/hmacmd5.h void hmac_md5_init_rfc2104(const uint8_t *key, int key_len, HMACMD5Context *ctx);
key                39 lib/crypto/hmacmd5test.c 		DATA_BLOB key;
key                47 lib/crypto/hmacmd5test.c 	testarray[0].key	= data_blob_repeat_byte(0x0b, 16);
key                51 lib/crypto/hmacmd5test.c 	testarray[1].key	= data_blob_string_const("Jefe");
key                55 lib/crypto/hmacmd5test.c 	testarray[2].key	= data_blob_repeat_byte(0xaa, 16);
key                59 lib/crypto/hmacmd5test.c 	testarray[3].key	= strhex_to_data_blob(tctx, "0102030405060708090a0b0c0d0e0f10111213141516171819");
key                63 lib/crypto/hmacmd5test.c 	testarray[4].key	= data_blob_repeat_byte(0x0c, 16);
key                67 lib/crypto/hmacmd5test.c 	testarray[5].key	= data_blob_repeat_byte(0xaa, 80);
key                71 lib/crypto/hmacmd5test.c 	testarray[6].key	= data_blob_repeat_byte(0xaa, 80);
key                76 lib/crypto/hmacmd5test.c 	testarray[7].key        = data_blob(NULL, 0);
key                78 lib/crypto/hmacmd5test.c 	for (i=0; testarray[i].key.data; i++) {
key                83 lib/crypto/hmacmd5test.c 		hmac_md5_init_rfc2104(testarray[i].key.data, testarray[i].key.length, &ctx);
key                92 lib/crypto/hmacmd5test.c 			dump_data(0, testarray[i].key.data, testarray[i].key.length);
key                35 lib/crypto/hmacsha256.c _PUBLIC_ void hmac_sha256_init(const uint8_t *key, size_t key_len, struct HMACSHA256Context *ctx)
key                46 lib/crypto/hmacsha256.c                 SHA256_Update(&tctx, key, key_len);
key                49 lib/crypto/hmacsha256.c                 key = tk;
key                56 lib/crypto/hmacsha256.c         memcpy( ctx->k_ipad, key, key_len);
key                57 lib/crypto/hmacsha256.c         memcpy( ctx->k_opad, key, key_len);
key                34 lib/crypto/hmacsha256.h void hmac_sha256_init(const uint8_t *key, size_t key_len, struct HMACSHA256Context *ctx);
key                25 lib/popt/popthelp.c 		struct poptOption * key, 
key                30 lib/popt/popthelp.c     if (key->shortName == '?')
key               540 lib/replace/crypt.c static void ufc_mk_keytab(char *key)
key               552 lib/replace/crypt.c       v1 |= k1[*key   & 0x7f]; k1 += 128;
key               553 lib/replace/crypt.c       v2 |= k1[*key++ & 0x7f]; k1 += 128;
key               655 lib/replace/crypt.c char *ufc_crypt(const char *key,const char *salt)
key               668 lib/replace/crypt.c     StrnCpy(ktab, key, 8);
key               683 lib/replace/replace.h char *ufc_crypt(const char *key, const char *salt);
key               195 lib/replace/test/testsuite.c #define TEST_SETENV(key, value, overwrite, result) do { \
key               198 lib/replace/test/testsuite.c 	_ret = setenv(key, value, overwrite); \
key               203 lib/replace/test/testsuite.c 			key, value, overwrite); \
key               206 lib/replace/test/testsuite.c 	_v=getenv(key); \
key               211 lib/replace/test/testsuite.c 			key); \
key               218 lib/replace/test/testsuite.c 			key, result, _v); \
key               223 lib/replace/test/testsuite.c #define TEST_UNSETENV(key) do { \
key               225 lib/replace/test/testsuite.c 	unsetenv(key); \
key               226 lib/replace/test/testsuite.c 	_v=getenv(key); \
key                38 lib/tdb/common/freelistcheck.c 	TDB_DATA key, data;
key                41 lib/tdb/common/freelistcheck.c 	key.dptr = (unsigned char *)&rec_ptr;
key                42 lib/tdb/common/freelistcheck.c 	key.dsize = sizeof(rec_ptr);
key                43 lib/tdb/common/freelistcheck.c 	return tdb_store(mem_tdb, key, data, TDB_INSERT);
key               406 lib/tdb/common/io.c int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
key               408 lib/tdb/common/io.c 		   int (*parser)(TDB_DATA key, TDB_DATA data,
key               426 lib/tdb/common/io.c 		return parser(key, data, private_data);
key               433 lib/tdb/common/io.c 	result = parser(key, data, private_data);
key               463 lib/tdb/common/lock.c int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
key               465 lib/tdb/common/lock.c 	return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
key               471 lib/tdb/common/lock.c int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key)
key               473 lib/tdb/common/lock.c 	return tdb_lock_nonblock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
key               477 lib/tdb/common/lock.c int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
key               479 lib/tdb/common/lock.c 	return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
key               483 lib/tdb/common/lock.c int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
key               485 lib/tdb/common/lock.c 	return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
key               488 lib/tdb/common/lock.c int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
key               490 lib/tdb/common/lock.c 	return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
key               493 lib/tdb/common/lock.c int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
key               495 lib/tdb/common/lock.c 	return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
key               498 lib/tdb/common/lock.c int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
key               500 lib/tdb/common/lock.c 	return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
key                35 lib/tdb/common/open.c static unsigned int default_tdb_hash(TDB_DATA *key)
key                41 lib/tdb/common/open.c 	for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
key                42 lib/tdb/common/open.c 		value = (value + (key->dptr[i] << (i*5 % 24)));
key                71 lib/tdb/common/tdb.c static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
key                73 lib/tdb/common/tdb.c 	return memcmp(data.dptr, key.dptr, data.dsize);
key                78 lib/tdb/common/tdb.c static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
key                93 lib/tdb/common/tdb.c 		    && key.dsize==r->key_len
key                94 lib/tdb/common/tdb.c 		    && tdb_parse_data(tdb, key, rec_ptr + sizeof(*r),
key               110 lib/tdb/common/tdb.c tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
key               117 lib/tdb/common/tdb.c 	if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
key               127 lib/tdb/common/tdb.c static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
key               133 lib/tdb/common/tdb.c 	if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
key               137 lib/tdb/common/tdb.c 	if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
key               161 lib/tdb/common/tdb.c TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
key               169 lib/tdb/common/tdb.c 	hash = tdb->hash_fn(&key);
key               170 lib/tdb/common/tdb.c 	if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec)))
key               196 lib/tdb/common/tdb.c int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
key               197 lib/tdb/common/tdb.c 		     int (*parser)(TDB_DATA key, TDB_DATA data,
key               207 lib/tdb/common/tdb.c 	hash = tdb->hash_fn(&key);
key               209 lib/tdb/common/tdb.c 	if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
key               213 lib/tdb/common/tdb.c 	ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
key               227 lib/tdb/common/tdb.c static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
key               231 lib/tdb/common/tdb.c 	if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
key               237 lib/tdb/common/tdb.c int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
key               239 lib/tdb/common/tdb.c 	uint32_t hash = tdb->hash_fn(&key);
key               240 lib/tdb/common/tdb.c 	return tdb_exists_hash(tdb, key, hash);
key               340 lib/tdb/common/tdb.c static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
key               364 lib/tdb/common/tdb.c 		if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
key               376 lib/tdb/common/tdb.c 		if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
key               392 lib/tdb/common/tdb.c int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
key               394 lib/tdb/common/tdb.c 	uint32_t hash = tdb->hash_fn(&key);
key               395 lib/tdb/common/tdb.c 	return tdb_delete_hash(tdb, key, hash);
key               432 lib/tdb/common/tdb.c int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
key               446 lib/tdb/common/tdb.c 	hash = tdb->hash_fn(&key);
key               452 lib/tdb/common/tdb.c 		if (tdb_exists_hash(tdb, key, hash)) {
key               458 lib/tdb/common/tdb.c 		if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
key               475 lib/tdb/common/tdb.c 		tdb_delete_hash(tdb, key, hash);
key               480 lib/tdb/common/tdb.c 	if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
key               485 lib/tdb/common/tdb.c 	memcpy(p, key.dptr, key.dsize);
key               487 lib/tdb/common/tdb.c 		memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
key               498 lib/tdb/common/tdb.c 			key.dsize + dbuf.dsize + sizeof(tdb_off_t));
key               501 lib/tdb/common/tdb.c 			rec.key_len = key.dsize;
key               508 lib/tdb/common/tdb.c 				    p, key.dsize + dbuf.dsize) == -1) {
key               532 lib/tdb/common/tdb.c 	rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
key               544 lib/tdb/common/tdb.c 	rec.key_len = key.dsize;
key               551 lib/tdb/common/tdb.c 	    || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
key               571 lib/tdb/common/tdb.c int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
key               578 lib/tdb/common/tdb.c 	hash = tdb->hash_fn(&key);
key               582 lib/tdb/common/tdb.c 	dbuf = tdb_fetch(tdb, key);
key               603 lib/tdb/common/tdb.c 	ret = tdb_store(tdb, key, dbuf, 0);
key               817 lib/tdb/common/tdb.c static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private)
key               820 lib/tdb/common/tdb.c 	if (tdb_store(state->dest_db, key, data, TDB_INSERT) != 0) {
key               162 lib/tdb/common/tdb_private.h 	unsigned int (*hash_fn)(TDB_DATA *key);
key               201 lib/tdb/common/tdb_private.h int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
key               203 lib/tdb/common/tdb_private.h 		   int (*parser)(TDB_DATA key, TDB_DATA data,
key               206 lib/tdb/common/tdb_private.h tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
key               142 lib/tdb/common/traverse.c 	TDB_DATA key, dbuf;
key               158 lib/tdb/common/traverse.c 		key.dptr = tdb_alloc_read(tdb, tl->off + sizeof(rec), 
key               160 lib/tdb/common/traverse.c 		if (!key.dptr) {
key               168 lib/tdb/common/traverse.c 		key.dsize = rec.key_len;
key               169 lib/tdb/common/traverse.c 		dbuf.dptr = key.dptr + rec.key_len;
key               175 lib/tdb/common/traverse.c 			SAFE_FREE(key.dptr);
key               178 lib/tdb/common/traverse.c 		if (fn && fn(tdb, key, dbuf, private_data)) {
key               185 lib/tdb/common/traverse.c 			SAFE_FREE(key.dptr);
key               188 lib/tdb/common/traverse.c 		SAFE_FREE(key.dptr);
key               267 lib/tdb/common/traverse.c 	TDB_DATA key;
key               280 lib/tdb/common/traverse.c 	key.dsize = rec.key_len;
key               281 lib/tdb/common/traverse.c 	key.dptr =tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);
key               286 lib/tdb/common/traverse.c 	return key;
key               293 lib/tdb/common/traverse.c 	TDB_DATA key = tdb_null;
key               336 lib/tdb/common/traverse.c 		key.dsize = rec.key_len;
key               337 lib/tdb/common/traverse.c 		key.dptr = tdb_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
key               338 lib/tdb/common/traverse.c 					  key.dsize);
key               346 lib/tdb/common/traverse.c 	return key;
key                85 lib/tdb/include/tdb.h typedef unsigned int (*tdb_hash_func)(TDB_DATA *key);
key               105 lib/tdb/include/tdb.h TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key);
key               106 lib/tdb/include/tdb.h int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
key               107 lib/tdb/include/tdb.h 		     int (*parser)(TDB_DATA key, TDB_DATA data,
key               110 lib/tdb/include/tdb.h int tdb_delete(struct tdb_context *tdb, TDB_DATA key);
key               111 lib/tdb/include/tdb.h int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
key               112 lib/tdb/include/tdb.h int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf);
key               115 lib/tdb/include/tdb.h TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA key);
key               118 lib/tdb/include/tdb.h int tdb_exists(struct tdb_context *tdb, TDB_DATA key);
key               145 lib/tdb/include/tdb.h int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key);
key               146 lib/tdb/include/tdb.h int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key);
key               147 lib/tdb/include/tdb.h int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key);
key               148 lib/tdb/include/tdb.h int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
key               149 lib/tdb/include/tdb.h int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
key               150 lib/tdb/include/tdb.h int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key);
key               151 lib/tdb/include/tdb.h int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key);
key               177 lib/tdb/pytdb.c 	TDB_DATA key;
key               182 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               184 lib/tdb/pytdb.c 	return PyString_FromTDB_DATA(tdb_fetch(self->ctx, key));
key               189 lib/tdb/pytdb.c 	TDB_DATA key, data;
key               195 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               198 lib/tdb/pytdb.c 	ret = tdb_append(self->ctx, key, data);
key               210 lib/tdb/pytdb.c 	TDB_DATA key;
key               215 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               217 lib/tdb/pytdb.c 	return PyString_FromTDB_DATA(tdb_nextkey(self->ctx, key));
key               222 lib/tdb/pytdb.c 	TDB_DATA key;
key               228 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               229 lib/tdb/pytdb.c 	ret = tdb_delete(self->ctx, key);
key               236 lib/tdb/pytdb.c 	TDB_DATA key;
key               242 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               243 lib/tdb/pytdb.c 	ret = tdb_exists(self->ctx, key);
key               253 lib/tdb/pytdb.c 	TDB_DATA key, value;
key               261 lib/tdb/pytdb.c 	key = PyString_AsTDB_DATA(py_key);
key               264 lib/tdb/pytdb.c 	ret = tdb_store(self->ctx, key, value, flag);
key               409 lib/tdb/pytdb.c static PyObject *obj_getitem(PyTdbObject *self, PyObject *key)
key               412 lib/tdb/pytdb.c 	if (!PyString_Check(key)) {
key               417 lib/tdb/pytdb.c 	tkey.dptr = (unsigned char *)PyString_AsString(key);
key               418 lib/tdb/pytdb.c 	tkey.dsize = PyString_Size(key);
key               429 lib/tdb/pytdb.c static int obj_setitem(PyTdbObject *self, PyObject *key, PyObject *value)
key               433 lib/tdb/pytdb.c 	if (!PyString_Check(key)) {
key               438 lib/tdb/pytdb.c 	tkey = PyString_AsTDB_DATA(key);
key                69 lib/tdb/tools/tdbbackup.c static int copy_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key                73 lib/tdb/tools/tdbbackup.c 	if (tdb_store(tdb_new, key, dbuf, TDB_INSERT) != 0) {
key                82 lib/tdb/tools/tdbbackup.c static int test_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key                41 lib/tdb/tools/tdbdump.c static int traverse_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key                44 lib/tdb/tools/tdbdump.c 	printf("key(%d) = \"", (int)key.dsize);
key                45 lib/tdb/tools/tdbdump.c 	print_data(key);
key                57 lib/tdb/tools/tdbdump.c 	TDB_DATA key, value;
key                68 lib/tdb/tools/tdbdump.c 		key.dptr = discard_const_p(uint8_t,keyname);
key                69 lib/tdb/tools/tdbdump.c 		key.dsize = strlen( keyname);
key                70 lib/tdb/tools/tdbdump.c 		value = tdb_fetch(tdb, key);
key                52 lib/tdb/tools/tdbtest.c 	TDB_DATA d, key, nextkey;
key                55 lib/tdb/tools/tdbtest.c 	key = tdb_firstkey(db);
key                56 lib/tdb/tools/tdbtest.c 	while (key.dptr) {
key                57 lib/tdb/tools/tdbtest.c 		d = tdb_fetch(db, key);
key                58 lib/tdb/tools/tdbtest.c 		gkey.dptr = key.dptr;
key                59 lib/tdb/tools/tdbtest.c 		gkey.dsize = key.dsize;
key                69 lib/tdb/tools/tdbtest.c 		nextkey = tdb_nextkey(db, key);
key                70 lib/tdb/tools/tdbtest.c 		free(key.dptr);
key                73 lib/tdb/tools/tdbtest.c 		key = nextkey;
key                79 lib/tdb/tools/tdbtest.c 		key.dptr = gkey.dptr;
key                80 lib/tdb/tools/tdbtest.c 		key.dsize = gkey.dsize;
key                82 lib/tdb/tools/tdbtest.c 		d = tdb_fetch(db, key);
key               115 lib/tdb/tools/tdbtest.c 	TDB_DATA key, data;
key               123 lib/tdb/tools/tdbtest.c 	key.dptr = k;
key               124 lib/tdb/tools/tdbtest.c 	key.dsize = klen+1;
key               130 lib/tdb/tools/tdbtest.c 		tdb_delete(db, key);
key               132 lib/tdb/tools/tdbtest.c 		if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
key               136 lib/tdb/tools/tdbtest.c 		data = tdb_fetch(db, key);
key               148 lib/tdb/tools/tdbtest.c 	datum key, data;
key               156 lib/tdb/tools/tdbtest.c 	key.dptr = k;
key               157 lib/tdb/tools/tdbtest.c 	key.dsize = klen+1;
key               163 lib/tdb/tools/tdbtest.c 		gdbm_delete(gdbm, key);
key               165 lib/tdb/tools/tdbtest.c 		if (gdbm_store(gdbm, key, data, GDBM_REPLACE) != 0) {
key               169 lib/tdb/tools/tdbtest.c 		data = gdbm_fetch(gdbm, key);
key               177 lib/tdb/tools/tdbtest.c static int traverse_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key               180 lib/tdb/tools/tdbtest.c 	printf("[%s] [%s]\n", key.dptr, dbuf.dptr);
key               182 lib/tdb/tools/tdbtest.c 	tdb_delete(tdb, key);
key               191 lib/tdb/tools/tdbtest.c 	TDB_DATA key, data;
key               195 lib/tdb/tools/tdbtest.c 		key.dptr = keys[i];
key               196 lib/tdb/tools/tdbtest.c 		key.dsize = 2;
key               201 lib/tdb/tools/tdbtest.c 		if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
key               206 lib/tdb/tools/tdbtest.c 	key.dptr = keys[0];
key               207 lib/tdb/tools/tdbtest.c 	tdb_delete(db, key);
key               208 lib/tdb/tools/tdbtest.c 	key.dptr = keys[4];
key               209 lib/tdb/tools/tdbtest.c 	tdb_delete(db, key);
key               210 lib/tdb/tools/tdbtest.c 	key.dptr = keys[2];
key               211 lib/tdb/tools/tdbtest.c 	tdb_delete(db, key);
key               212 lib/tdb/tools/tdbtest.c 	key.dptr = keys[1];
key               213 lib/tdb/tools/tdbtest.c 	tdb_delete(db, key);
key               214 lib/tdb/tools/tdbtest.c 	key.dptr = keys[3];
key               215 lib/tdb/tools/tdbtest.c 	tdb_delete(db, key);
key               116 lib/tdb/tools/tdbtool.c static int print_rec(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state);
key               117 lib/tdb/tools/tdbtool.c static int print_key(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state);
key               118 lib/tdb/tools/tdbtool.c static int print_hexkey(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state);
key               219 lib/tdb/tools/tdbtool.c 	TDB_DATA key, dbuf;
key               226 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
key               227 lib/tdb/tools/tdbtool.c 	key.dsize = keylen;
key               231 lib/tdb/tools/tdbtool.c 	if (tdb_store(tdb, key, dbuf, TDB_INSERT) == -1) {
key               238 lib/tdb/tools/tdbtool.c 	TDB_DATA key, dbuf;
key               250 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
key               251 lib/tdb/tools/tdbtool.c 	key.dsize = keylen;
key               256 lib/tdb/tools/tdbtool.c 	print_rec(tdb, key, dbuf, NULL);
key               258 lib/tdb/tools/tdbtool.c 	if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1) {
key               265 lib/tdb/tools/tdbtool.c 	TDB_DATA key, dbuf;
key               272 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
key               273 lib/tdb/tools/tdbtool.c 	key.dsize = keylen;
key               275 lib/tdb/tools/tdbtool.c 	dbuf = tdb_fetch(tdb, key);
key               281 lib/tdb/tools/tdbtool.c 	print_rec(tdb, key, dbuf, NULL);
key               290 lib/tdb/tools/tdbtool.c 	TDB_DATA key;
key               297 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
key               298 lib/tdb/tools/tdbtool.c 	key.dsize = keylen;
key               300 lib/tdb/tools/tdbtool.c 	if (tdb_delete(tdb, key) != 0) {
key               307 lib/tdb/tools/tdbtool.c 	TDB_DATA key, dbuf;
key               320 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
key               321 lib/tdb/tools/tdbtool.c 	key.dsize = keylen;
key               323 lib/tdb/tools/tdbtool.c 	dbuf = tdb_fetch(tdb, key);
key               329 lib/tdb/tools/tdbtool.c 	print_rec(tdb, key, dbuf, NULL);
key               337 lib/tdb/tools/tdbtool.c 	if ( tdb_store( dst_tdb, key, dbuf, TDB_REPLACE ) == -1 ) {
key               348 lib/tdb/tools/tdbtool.c static int print_rec(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key               350 lib/tdb/tools/tdbtool.c 	printf("\nkey %d bytes\n", (int)key.dsize);
key               351 lib/tdb/tools/tdbtool.c 	print_asc((const char *)key.dptr, key.dsize);
key               357 lib/tdb/tools/tdbtool.c static int print_key(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key               359 lib/tdb/tools/tdbtool.c 	printf("key %d bytes: ", (int)key.dsize);
key               360 lib/tdb/tools/tdbtool.c 	print_asc((const char *)key.dptr, key.dsize);
key               365 lib/tdb/tools/tdbtool.c static int print_hexkey(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key               367 lib/tdb/tools/tdbtool.c 	printf("key %d bytes\n", (int)key.dsize);
key               368 lib/tdb/tools/tdbtool.c 	print_data((const char *)key.dptr, key.dsize);
key               375 lib/tdb/tools/tdbtool.c static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key               428 lib/tdb/tools/tdbtool.c static int do_delete_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf,
key               431 lib/tdb/tools/tdbtool.c     return tdb_delete(the_tdb, key);
key               458 lib/tdb/tools/tdbtool.c static int test_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
key                74 lib/tdb/tools/tdbtorture.c static int cull_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
key                79 lib/tdb/tools/tdbtorture.c 		tdb_delete(tdb, key);
key                89 lib/tdb/tools/tdbtorture.c 	TDB_DATA key, data;
key                97 lib/tdb/tools/tdbtorture.c 	key.dptr = (unsigned char *)k;
key                98 lib/tdb/tools/tdbtorture.c 	key.dsize = klen+1;
key               136 lib/tdb/tools/tdbtorture.c 		tdb_delete(db, key);
key               143 lib/tdb/tools/tdbtorture.c 		if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
key               152 lib/tdb/tools/tdbtorture.c 		if (tdb_append(db, key, data) != 0) {
key               161 lib/tdb/tools/tdbtorture.c 		tdb_chainlock(db, key);
key               162 lib/tdb/tools/tdbtorture.c 		data = tdb_fetch(db, key);
key               163 lib/tdb/tools/tdbtorture.c 		if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
key               167 lib/tdb/tools/tdbtorture.c 		tdb_chainunlock(db, key);
key               186 lib/tdb/tools/tdbtorture.c 	data = tdb_fetch(db, key);
key               194 lib/tdb/tools/tdbtorture.c static int traverse_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
key               197 lib/tdb/tools/tdbtorture.c 	tdb_delete(tdb, key);
key                57 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key                59 lib/util/util_tdb.c 	return tdb_chainlock(tdb, key);
key                68 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key                70 lib/util/util_tdb.c 	tdb_chainunlock(tdb, key);
key                79 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key                81 lib/util/util_tdb.c 	return tdb_chainlock_read(tdb, key);
key                90 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key                92 lib/util/util_tdb.c 	tdb_chainunlock_read(tdb, key);
key               101 lib/util/util_tdb.c int32_t tdb_fetch_int32_byblob(struct tdb_context *tdb, TDB_DATA key)
key               106 lib/util/util_tdb.c 	data = tdb_fetch(tdb, key);
key               132 lib/util/util_tdb.c int tdb_store_int32_byblob(struct tdb_context *tdb, TDB_DATA key, int32_t v)
key               141 lib/util/util_tdb.c 	return tdb_store(tdb, key, data, TDB_REPLACE);
key               159 lib/util/util_tdb.c bool tdb_fetch_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t *value)
key               163 lib/util/util_tdb.c 	data = tdb_fetch(tdb, key);
key               189 lib/util/util_tdb.c bool tdb_store_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t value)
key               199 lib/util/util_tdb.c 	if (tdb_store(tdb, key, data, TDB_REPLACE) == -1)
key               221 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keystr);
key               223 lib/util/util_tdb.c 	return tdb_store(tdb, key, data, flags);
key               233 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keystr);
key               235 lib/util/util_tdb.c 	return tdb_fetch(tdb, key);
key               244 lib/util/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keystr);
key               246 lib/util/util_tdb.c 	return tdb_delete(tdb, key);
key               336 lib/util/util_tdb.c int tdb_traverse_delete_fn(struct tdb_context *the_tdb, TDB_DATA key, TDB_DATA dbuf,
key               339 lib/util/util_tdb.c     return tdb_delete(the_tdb, key);
key                36 lib/util/util_tdb.h int32_t tdb_fetch_int32_byblob(struct tdb_context *tdb, TDB_DATA key);
key                48 lib/util/util_tdb.h int tdb_store_int32_byblob(struct tdb_context *tdb, TDB_DATA key, int32_t v);
key                60 lib/util/util_tdb.h bool tdb_fetch_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t *value);
key                72 lib/util/util_tdb.h bool tdb_store_uint32_byblob(struct tdb_context *tdb, TDB_DATA key, uint32_t value);
key               110 lib/util/util_tdb.h int tdb_traverse_delete_fn(struct tdb_context *the_tdb, TDB_DATA key, TDB_DATA dbuf,
key               351 librpc/gen_ndr/cli_winreg.c 				 struct winreg_String key /* [in]  */,
key               359 librpc/gen_ndr/cli_winreg.c 	r.in.key = key;
key                52 librpc/gen_ndr/cli_winreg.h 				 struct winreg_String key /* [in]  */,
key               987 librpc/gen_ndr/ndr_netlogon.c 			NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->key, 16));
key              1003 librpc/gen_ndr/ndr_netlogon.c 			NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->key, 16));
key              1019 librpc/gen_ndr/ndr_netlogon.c 		ndr_print_array_uint8(ndr, "key", r->key, 16);
key              1032 librpc/gen_ndr/ndr_netlogon.c 			NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->key, 8));
key              1048 librpc/gen_ndr/ndr_netlogon.c 			NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->key, 8));
key              1064 librpc/gen_ndr/ndr_netlogon.c 		ndr_print_array_uint8(ndr, "key", r->key, 8);
key              1125 librpc/gen_ndr/ndr_netlogon.c 		NDR_CHECK(ndr_push_netr_UserSessionKey(ndr, NDR_SCALARS, &r->key));
key              1177 librpc/gen_ndr/ndr_netlogon.c 		NDR_CHECK(ndr_pull_netr_UserSessionKey(ndr, NDR_SCALARS, &r->key));
key              1235 librpc/gen_ndr/ndr_netlogon.c 	ndr_print_netr_UserSessionKey(ndr, "key", &r->key);
key              1221 librpc/gen_ndr/ndr_winreg.c 		NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
key              1240 librpc/gen_ndr/ndr_winreg.c 		NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
key              1262 librpc/gen_ndr/ndr_winreg.c 		ndr_print_winreg_String(ndr, "key", &r->in.key);
key               125 librpc/gen_ndr/netlogon.h 	uint8_t key[16];
key               129 librpc/gen_ndr/netlogon.h 	uint8_t key[8];
key               164 librpc/gen_ndr/netlogon.h 	struct netr_UserSessionKey key;
key               230 librpc/gen_ndr/winreg.h 		struct winreg_String key;
key                45 librpc/ndr/libndr.h 	const void *key;
key               420 librpc/ndr/libndr.h 			 const void *key, 
key               422 librpc/ndr/libndr.h enum ndr_err_code ndr_token_retrieve_cmp_fn(struct ndr_token_list **list, const void *key, uint32_t *v, comparison_fn_t _cmp_fn, bool _remove_tok);
key               423 librpc/ndr/libndr.h enum ndr_err_code ndr_token_retrieve(struct ndr_token_list **list, const void *key, uint32_t *v);
key               424 librpc/ndr/libndr.h uint32_t ndr_token_peek(struct ndr_token_list **list, const void *key);
key               660 librpc/ndr/ndr.c 			 const void *key, 
key               666 librpc/ndr/ndr.c 	tok->key = key;
key               675 librpc/ndr/ndr.c _PUBLIC_ enum ndr_err_code ndr_token_retrieve_cmp_fn(struct ndr_token_list **list, const void *key, uint32_t *v,
key               680 librpc/ndr/ndr.c 		if (_cmp_fn && _cmp_fn(tok->key,key)==0) goto found;
key               681 librpc/ndr/ndr.c 		else if (!_cmp_fn && tok->key == key) goto found;
key               696 librpc/ndr/ndr.c _PUBLIC_ enum ndr_err_code ndr_token_retrieve(struct ndr_token_list **list, const void *key, uint32_t *v)
key               698 librpc/ndr/ndr.c 	return ndr_token_retrieve_cmp_fn(list, key, v, NULL, true);
key               704 librpc/ndr/ndr.c _PUBLIC_ uint32_t ndr_token_peek(struct ndr_token_list **list, const void *key)
key               709 librpc/ndr/ndr.c 	status = ndr_token_retrieve_cmp_fn(list, key, &v, NULL, false);
key               305 nsswitch/pam_winbind.c 				 const char *key,
key               312 nsswitch/pam_winbind.c 		pam_get_data(ctx->pamh, key, &data);
key               319 nsswitch/pam_winbind.c 				       ctx->pamh, type, key, (const char *)data,
key               324 nsswitch/pam_winbind.c 				       ctx->pamh, type, key, data);
key              2282 nsswitch/pam_winbind.c 		char *key = NULL;
key              2284 nsswitch/pam_winbind.c 		key = talloc_asprintf(ctx, "global:%s", item);
key              2285 nsswitch/pam_winbind.c 		if (!key) {
key              2289 nsswitch/pam_winbind.c 		parm_opt = iniparser_getstr(ctx->dict, key);
key              2290 nsswitch/pam_winbind.c 		TALLOC_FREE(key);
key              2330 nsswitch/pam_winbind.c 		char *key = NULL;
key              2332 nsswitch/pam_winbind.c 		key = talloc_asprintf(ctx, "global:%s", item);
key              2333 nsswitch/pam_winbind.c 		if (!key) {
key              2337 nsswitch/pam_winbind.c 		parm_opt = iniparser_getint(ctx->dict, key, -1);
key              2338 nsswitch/pam_winbind.c 		TALLOC_FREE(key);
key               616 nsswitch/winbind_nss_aix.c static int wb_aix_user_attrib(const char *key, char *attributes[],
key               622 nsswitch/winbind_nss_aix.c 	pwd = wb_aix_getpwnam(key);
key               664 nsswitch/winbind_nss_aix.c static int wb_aix_group_attrib(const char *key, char *attributes[],
key               670 nsswitch/winbind_nss_aix.c 	grp = wb_aix_getgrnam(key);
key               698 nsswitch/winbind_nss_aix.c static int wb_aix_getentry(char *key, char *table, char *attributes[],
key               702 nsswitch/winbind_nss_aix.c 	      key, table, size, attributes[0]);
key               704 nsswitch/winbind_nss_aix.c 	if (strcmp(key, "ALL") == 0 &&
key               709 nsswitch/winbind_nss_aix.c 	if (strcmp(key, "ALL") == 0 &&
key               715 nsswitch/winbind_nss_aix.c 		return wb_aix_user_attrib(key, attributes, results, size);
key               719 nsswitch/winbind_nss_aix.c 		return wb_aix_group_attrib(key, attributes, results, size);
key               722 nsswitch/winbind_nss_aix.c 	logit("Unknown getentry operation key='%s' table='%s'\n", key, table);
key               986 nsswitch/winbind_nss_aix.c static int wb_aix_putentry(char *key, char *table, char *attributes[],
key               990 nsswitch/winbind_nss_aix.c 	      key, table, size>=1?attributes[0]:"<null>");
key               995 nsswitch/winbind_nss_aix.c static int wb_aix_commit(char *key, char *table)
key               129 nsswitch/winbind_nss_hpux.h 	union nss_XbyY_key key;
key               487 nsswitch/winbind_nss_irix.c 	char *key;
key               495 nsswitch/winbind_nss_irix.c 	key = nsd_attr_fetch_string(rq->f_attrs, "key", (char*)0);
key               496 nsswitch/winbind_nss_irix.c 	if (! map || ! key) {
key               512 nsswitch/winbind_nss_irix.c 	    request->data.uid = atoi(key);
key               515 nsswitch/winbind_nss_irix.c 	    strncpy(request->data.username, key,
key               520 nsswitch/winbind_nss_irix.c 	    strncpy(request->data.groupname, key,
key               525 nsswitch/winbind_nss_irix.c 	    request->data.gid = atoi(key);
key               528 nsswitch/winbind_nss_irix.c 	    strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
key               532 nsswitch/winbind_nss_irix.c 	    strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
key               134 nsswitch/winbind_nss_solaris.c 	ret = _nss_winbind_getpwnam_r (NSS_ARGS(args)->key.name,
key               152 nsswitch/winbind_nss_solaris.c 	ret = _nss_winbind_getpwuid_r (NSS_ARGS(args)->key.uid,
key               248 nsswitch/winbind_nss_solaris.c 	ret = _nss_winbind_getgrnam_r(NSS_ARGS(args)->key.name,
key               267 nsswitch/winbind_nss_solaris.c 	ret = _nss_winbind_getgrgid_r (NSS_ARGS(args)->key.gid,
key               499 nsswitch/winbind_nss_solaris.c 	af = argp->key.ipnode.af_family;
key               500 nsswitch/winbind_nss_solaris.c 	if(af == AF_INET6 && argp->key.ipnode.flags == 0) {
key               510 nsswitch/winbind_nss_solaris.c 	strncpy(request.data.winsreq, argp->key.name, sizeof(request.data.winsreq) - 1);
key               533 nsswitch/winbind_nss_solaris.c 	strncpy(request.data.winsreq, argp->key.name, sizeof(request.data.winsreq) - 1);
key               559 nsswitch/winbind_nss_solaris.c 	if(argp->key.hostaddr.type == AF_INET6) {
key               564 nsswitch/winbind_nss_solaris.c 	p = inet_ntop(argp->key.hostaddr.type, argp->key.hostaddr.addr,
key               569 nsswitch/winbind_nss_solaris.c                 ((unsigned char *)argp->key.hostaddr.addr)[0],
key               570 nsswitch/winbind_nss_solaris.c                 ((unsigned char *)argp->key.hostaddr.addr)[1],
key               571 nsswitch/winbind_nss_solaris.c                 ((unsigned char *)argp->key.hostaddr.addr)[2],
key               572 nsswitch/winbind_nss_solaris.c                 ((unsigned char *)argp->key.hostaddr.addr)[3]);
key               578 nsswitch/winbind_nss_solaris.c 	  parse_response(argp->key.hostaddr.type, argp, &response);
key               201 nsswitch/wins.c 	char *key;
key               219 nsswitch/wins.c 	key = nsd_attr_fetch_string(rq->f_attrs, "key", (char*)0);
key               220 nsswitch/wins.c 	if (! key || ! *key) {
key               233 nsswitch/wins.c 		if ( status = lookup_byaddr_backend(key, &count)) {
key               234 nsswitch/wins.c 		    size = strlen(key) + 1;
key               240 nsswitch/wins.c 		    strncat(response,key,size);
key               261 nsswitch/wins.c 	    if (ip_list = lookup_byname_backend(key, &count)) {
key               275 nsswitch/wins.c 		size = strlen(key) + 1;
key               280 nsswitch/wins.c 		strncat(response,key,size);
key               304 source3/auth/auth_util.c 	unsigned char key[16];
key               306 source3/auth/auth_util.c 	memcpy(key, dc_sess_key, 16);
key               316 source3/auth/auth_util.c 	dump_data(100, key, sizeof(key));
key               326 source3/auth/auth_util.c 		SamOEMhash(lm_pwd, key, sizeof(lm_pwd));
key               329 source3/auth/auth_util.c 		SamOEMhash(nt_pwd, key, sizeof(nt_pwd));
key               348 source3/auth/auth_util.c 	ZERO_STRUCT(key);
key              1840 source3/auth/auth_util.c 	if (memcmp(info3->base.key.key, zeros, sizeof(zeros)) == 0) {
key              1844 source3/auth/auth_util.c 			result, info3->base.key.key,
key              1845 source3/auth/auth_util.c 			sizeof(info3->base.key.key));
key              1848 source3/auth/auth_util.c 	if (memcmp(info3->base.LMSessKey.key, zeros, 8) == 0) {
key              1852 source3/auth/auth_util.c 			result, info3->base.LMSessKey.key,
key              1853 source3/auth/auth_util.c 			sizeof(info3->base.LMSessKey.key));
key               205 source3/auth/pass_check.c 		sec_passwd_rec_t *key;
key               230 source3/auth/pass_check.c 				     (void **)&key, &err);
key               240 source3/auth/pass_check.c 		sec_login_valid_and_cert_ident(my_dce_sec_context, key,
key               251 source3/auth/pass_check.c 		sec_key_mgmt_free_key(key, &err);
key               323 source3/auth/pass_check.c 	passwd_rec.key.key_type = sec_passwd_plain;
key               324 source3/auth/pass_check.c 	passwd_rec.key.tagged_union.plain = (idl_char *) password;
key               342 source3/client/cifs.upcall.c cifs_resolver(const key_serial_t key, const char *key_descr)
key               381 source3/client/cifs.upcall.c 	c = keyctl_instantiate(key, ip, strlen(ip)+1, 0);
key               465 source3/client/cifs.upcall.c 	key_serial_t key = 0;
key               504 source3/client/cifs.upcall.c 	key = strtol(argv[optind], NULL, 10);
key               506 source3/client/cifs.upcall.c 		key = 0;
key               511 source3/client/cifs.upcall.c 	rc = keyctl_describe_alloc(key, &buf);
key               523 source3/client/cifs.upcall.c 		rc = cifs_resolver(key, buf);
key               627 source3/client/cifs.upcall.c 	rc = keyctl_instantiate(key, keydata, datalen, 0);
key               642 source3/client/cifs.upcall.c 	if (rc != 0  && key == 0)
key               643 source3/client/cifs.upcall.c 		keyctl_negate(key, 1, KEY_REQKEY_DEFL_DEFAULT);
key               546 source3/groupdb/mapping_ldb.c static int upgrade_map_record(TDB_CONTEXT *tdb_ctx, TDB_DATA key, 
key               552 source3/groupdb/mapping_ldb.c 	if (strncmp((char *)key.dptr, GROUP_PREFIX, 
key               553 source3/groupdb/mapping_ldb.c 		    MIN(key.dsize, strlen(GROUP_PREFIX))) != 0) {
key               557 source3/groupdb/mapping_ldb.c 	if (!string_to_sid(&map.sid, strlen(GROUP_PREFIX) + (const char *)key.dptr)) {
key               558 source3/groupdb/mapping_ldb.c 		DEBUG(0,("Bad sid key '%s' during upgrade\n", (const char *)key.dptr));
key               590 source3/groupdb/mapping_ldb.c static int upgrade_alias_record(TDB_CONTEXT *tdb_ctx, TDB_DATA key, 
key               598 source3/groupdb/mapping_ldb.c 	if (strncmp((char *)key.dptr, MEMBEROF_PREFIX, 
key               599 source3/groupdb/mapping_ldb.c 		    MIN(key.dsize, strlen(MEMBEROF_PREFIX))) != 0) {
key               603 source3/groupdb/mapping_ldb.c 	if (!string_to_sid(&member, strlen(MEMBEROF_PREFIX) + (const char *)key.dptr)) {
key               605 source3/groupdb/mapping_ldb.c 			 (const char *)key.dptr));
key               124 source3/groupdb/mapping_tdb.c 	char *key, *buf;
key               128 source3/groupdb/mapping_tdb.c 	key = group_mapping_key(talloc_tos(), &map->sid);
key               129 source3/groupdb/mapping_tdb.c 	if (key == NULL) {
key               136 source3/groupdb/mapping_tdb.c 	buf = TALLOC_ARRAY(key, char, len);
key               138 source3/groupdb/mapping_tdb.c 		TALLOC_FREE(key);
key               145 source3/groupdb/mapping_tdb.c 		db, string_term_tdb_data(key),
key               148 source3/groupdb/mapping_tdb.c 	TALLOC_FREE(key);
key               161 source3/groupdb/mapping_tdb.c 	char *key;
key               166 source3/groupdb/mapping_tdb.c 	key = group_mapping_key(talloc_tos(), &sid);
key               167 source3/groupdb/mapping_tdb.c 	if (key == NULL) {
key               171 source3/groupdb/mapping_tdb.c 	dbuf = dbwrap_fetch_bystring(db, key, key);
key               173 source3/groupdb/mapping_tdb.c 		TALLOC_FREE(key);
key               181 source3/groupdb/mapping_tdb.c 	TALLOC_FREE(key);
key               195 source3/groupdb/mapping_tdb.c 	if ((rec->key.dsize < strlen(GROUP_PREFIX))
key               196 source3/groupdb/mapping_tdb.c 	    || (strncmp((char *)rec->key.dptr, GROUP_PREFIX,
key               201 source3/groupdb/mapping_tdb.c 	if (!string_to_sid(&map->sid, (const char *)rec->key.dptr
key               284 source3/groupdb/mapping_tdb.c 	char *key;
key               287 source3/groupdb/mapping_tdb.c 	key = group_mapping_key(talloc_tos(), sid);
key               288 source3/groupdb/mapping_tdb.c 	if (key == NULL) {
key               292 source3/groupdb/mapping_tdb.c 	status = dbwrap_trans_delete(db, string_term_tdb_data(key));
key               294 source3/groupdb/mapping_tdb.c 	TALLOC_FREE(key);
key               384 source3/groupdb/mapping_tdb.c 	fstring key;
key               391 source3/groupdb/mapping_tdb.c 	slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX,
key               394 source3/groupdb/mapping_tdb.c 	dbuf = dbwrap_fetch_bystring(db, frame, key);
key               459 source3/groupdb/mapping_tdb.c 	char *key;
key               477 source3/groupdb/mapping_tdb.c 	key = talloc_asprintf(talloc_tos(), "%s%s", MEMBEROF_PREFIX,
key               479 source3/groupdb/mapping_tdb.c 	if (key == NULL) {
key               488 source3/groupdb/mapping_tdb.c 	rec = db->fetch_locked(db, key, string_term_tdb_data(key));
key               492 source3/groupdb/mapping_tdb.c 		TALLOC_FREE(key);
key               501 source3/groupdb/mapping_tdb.c 			key, "%s %s", (char *)(rec->value.dptr), string_sid);
key               503 source3/groupdb/mapping_tdb.c 		new_memberstring = talloc_strdup(key, string_sid);
key               507 source3/groupdb/mapping_tdb.c 		TALLOC_FREE(key);
key               514 source3/groupdb/mapping_tdb.c 	TALLOC_FREE(key);
key               550 source3/groupdb/mapping_tdb.c 	if (strncmp((const char *)rec->key.dptr, MEMBEROF_PREFIX,
key               572 source3/groupdb/mapping_tdb.c 		member_string = strchr((const char *)rec->key.dptr, '/');
key               626 source3/groupdb/mapping_tdb.c 	char *key;
key               660 source3/groupdb/mapping_tdb.c 	key = talloc_asprintf(sids, "%s%s", MEMBEROF_PREFIX, sid_string);
key               661 source3/groupdb/mapping_tdb.c 	if (key == NULL) {
key               668 source3/groupdb/mapping_tdb.c 		status = dbwrap_delete_bystring(db, key);
key               694 source3/groupdb/mapping_tdb.c 		db, key, string_term_tdb_data(member_string), 0);
key               389 source3/include/ads.h #define KRB5_KT_KEY(k)		(&(k)->key)
key                29 source3/include/adt_tree.h 	char			*key;
key                54 source3/include/adt_tree.h void*         pathtree_find( SORTED_TREE *tree, char *key );
key                49 source3/include/ctdbd_conn.h 		       TDB_DATA key);
key                52 source3/include/ctdbd_conn.h 		     TDB_DATA key, TALLOC_CTX *mem_ctx, TDB_DATA *data);
key                55 source3/include/ctdbd_conn.h 			void (*fn)(TDB_DATA key, TDB_DATA data,
key                68 source3/include/ctdbd_conn.h NTSTATUS ctdbd_persistent_store(struct ctdbd_connection *conn, uint32_t db_id, TDB_DATA key, TDB_DATA data);
key                69 source3/include/ctdbd_conn.h NTSTATUS ctdbd_start_persistent_update(struct ctdbd_connection *conn, uint32_t db_id, TDB_DATA key, TDB_DATA data);
key                70 source3/include/ctdbd_conn.h NTSTATUS ctdbd_cancel_persistent_update(struct ctdbd_connection *conn, uint32_t db_id, TDB_DATA key, TDB_DATA data);
key                24 source3/include/dbwrap.h 	TDB_DATA key, value;
key                33 source3/include/dbwrap.h 					  TDB_DATA key);
key                35 source3/include/dbwrap.h 		     TDB_DATA key, TDB_DATA *data);
key                49 source3/include/dbwrap.h 	int (*parse_record)(struct db_context *db, TDB_DATA key,
key                50 source3/include/dbwrap.h 			    int (*parser)(TDB_DATA key, TDB_DATA data,
key                92 source3/include/dbwrap.h NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key);
key                93 source3/include/dbwrap.h NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
key                96 source3/include/dbwrap.h 		      TDB_DATA key);
key                97 source3/include/dbwrap.h NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key);
key                98 source3/include/dbwrap.h NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
key               101 source3/include/dbwrap.h 			       const char *key);
key               126 source3/include/gpo.h 	const char *key;
key               138 source3/include/gpo.h 	const char *key;
key               938 source3/include/includes.h int create_kerberos_key_from_string(krb5_context context, krb5_principal host_princ, krb5_data *password, krb5_keyblock *key, krb5_enctype enctype, bool no_salt);
key                60 source3/include/locking.h 	struct file_id key;
key                70 source3/include/memcache.h 		  DATA_BLOB key, DATA_BLOB value);
key                84 source3/include/memcache.h 			 DATA_BLOB key, void *ptr);
key                91 source3/include/memcache.h 		     DATA_BLOB key);
key                99 source3/include/memcache.h 		     DATA_BLOB key, DATA_BLOB *value);
key               107 source3/include/memcache.h 			     DATA_BLOB key);
key               426 source3/include/proto.h 					   TDB_DATA key);
key               434 source3/include/proto.h 				 const struct connections_key *key,
key               451 source3/include/proto.h NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
key               453 source3/include/proto.h NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key);
key               458 source3/include/proto.h NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
key               460 source3/include/proto.h NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key);
key               528 source3/include/proto.h void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
key               530 source3/include/proto.h int gencache_lock_entry( const char *key );
key               531 source3/include/proto.h void gencache_unlock_entry( const char *key );
key              2109 source3/include/proto.h 			  struct registry_key **key);
key              2111 source3/include/proto.h 			   struct registry_key *key,
key              2115 source3/include/proto.h 			  struct registry_key *key,
key              2129 source3/include/proto.h 		     struct registry_key *key,
key              2132 source3/include/proto.h 		  const char *key, const char *subkey,
key              3210 source3/include/proto.h void des_crypt56(unsigned char *out, const unsigned char *in, const unsigned char *key, int forw);
key              3215 source3/include/proto.h void des_crypt128(unsigned char out[8], const unsigned char in[8], const unsigned char key[16]);
key              3216 source3/include/proto.h void des_crypt64(unsigned char out[8], const unsigned char in[8], const unsigned char key[8]);
key              3217 source3/include/proto.h void des_crypt112(unsigned char out[8], const unsigned char in[8], const unsigned char key[14], int forw);
key              3218 source3/include/proto.h void cred_hash3(unsigned char *out, const unsigned char *in, const unsigned char *key, int forw);
key              3219 source3/include/proto.h void des_crypt112_16(unsigned char out[16], unsigned char in[16], const unsigned char key[14], int forw);
key              3220 source3/include/proto.h void SamOEMhash( unsigned char *data, const unsigned char key[16], size_t len);
key              3221 source3/include/proto.h void SamOEMhashBlob( unsigned char *data, size_t len, DATA_BLOB *key);
key              4673 source3/include/proto.h void *secrets_fetch(const char *key, size_t *size);
key              4674 source3/include/proto.h bool secrets_store(const char *key, const void *data, size_t size);
key              4675 source3/include/proto.h bool secrets_delete(const char *key);
key              4714 source3/include/proto.h bool secrets_store_generic(const char *owner, const char *key, const char *secret);
key              4715 source3/include/proto.h char *secrets_fetch_generic(const char *owner, const char *key);
key              4813 source3/include/proto.h int get_printer_subkeys( NT_PRINTER_DATA *data, const char* key, fstring **subkeys );
key              4822 source3/include/proto.h WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key );
key              4823 source3/include/proto.h WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
key              4824 source3/include/proto.h WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value, 
key              4826 source3/include/proto.h REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
key              4956 source3/include/proto.h WERROR reg_enumkey(TALLOC_CTX *mem_ctx, struct registry_key *key,
key              4958 source3/include/proto.h WERROR reg_enumvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
key              4960 source3/include/proto.h WERROR reg_queryvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
key              4962 source3/include/proto.h WERROR reg_queryinfokey(struct registry_key *key, uint32_t *num_subkeys,
key              4972 source3/include/proto.h WERROR reg_setvalue(struct registry_key *key, const char *name,
key              4974 source3/include/proto.h WERROR reg_deletevalue(struct registry_key *key, const char *name);
key              4975 source3/include/proto.h WERROR reg_getkeysecurity(TALLOC_CTX *mem_ctx, struct registry_key *key,
key              4977 source3/include/proto.h WERROR reg_setkeysecurity(struct registry_key *key,
key              4980 source3/include/proto.h WERROR reg_restorekey(struct registry_key *key, const char *fname);
key              4981 source3/include/proto.h WERROR reg_savekey(struct registry_key *key, const char *fname);
key              4982 source3/include/proto.h WERROR reg_deleteallvalues(struct registry_key *key);
key              5014 source3/include/proto.h bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr);
key              5015 source3/include/proto.h int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr);
key              5016 source3/include/proto.h int regdb_fetch_values( const char* key, REGVAL_CTR *values );
key              5017 source3/include/proto.h bool regdb_store_values( const char *key, REGVAL_CTR *values );
key              5054 source3/include/proto.h bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys );
key              5055 source3/include/proto.h bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val );
key              5056 source3/include/proto.h WERROR create_reg_subkey(REGISTRY_KEY *key, const char *subkey);
key              5057 source3/include/proto.h WERROR delete_reg_subkey(REGISTRY_KEY *key, const char *subkey);
key              5058 source3/include/proto.h int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr );
key              5059 source3/include/proto.h int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val );
key              5060 source3/include/proto.h bool regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted,
key              5062 source3/include/proto.h WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, REGISTRY_KEY *key,
key              5064 source3/include/proto.h WERROR regkey_set_secdesc(REGISTRY_KEY *key,
key              5066 source3/include/proto.h bool reg_subkeys_need_update(REGISTRY_KEY *key, struct regsubkey_ctr *subkeys);
key              5067 source3/include/proto.h bool reg_values_need_update(REGISTRY_KEY *key, REGVAL_CTR *values);
key              5127 source3/include/proto.h bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data);
key              5146 source3/include/proto.h bool reg_split_key(char *path, char **base, char **key);
key              5148 source3/include/proto.h void normalize_dbkey(char *key);
key              5149 source3/include/proto.h char *reg_remaining_path(TALLOC_CTX *ctx, const char *key);
key              5619 source3/include/proto.h 			   struct netr_UserSessionKey key,
key              5644 source3/include/proto.h 			struct netr_UserSessionKey key,
key              5979 source3/include/proto.h 			  const char *key, const char *value,
key              6250 source3/include/proto.h char *dptr_path(int key);
key              6251 source3/include/proto.h char *dptr_wcard(int key);
key              6252 source3/include/proto.h uint16 dptr_attr(int key);
key              6253 source3/include/proto.h void dptr_close(int *key);
key              6271 source3/include/proto.h bool dptr_fill(char *buf1,unsigned int key);
key              7042 source3/include/proto.h unsigned int fast_string_hash(TDB_DATA *key);
key               131 source3/include/reg_objects.h 	int 	(*fetch_subkeys)( const char *key, struct regsubkey_ctr *subkeys);
key               132 source3/include/reg_objects.h 	int 	(*fetch_values) ( const char *key, REGVAL_CTR *val );
key               133 source3/include/reg_objects.h 	bool 	(*store_subkeys)( const char *key, struct regsubkey_ctr *subkeys );
key               134 source3/include/reg_objects.h 	WERROR	(*create_subkey)(const char *key, const char *subkey);
key               135 source3/include/reg_objects.h 	WERROR	(*delete_subkey)(const char *key, const char *subkey);
key               136 source3/include/reg_objects.h 	bool 	(*store_values)( const char *key, REGVAL_CTR *val );
key               140 source3/include/reg_objects.h 	WERROR (*get_secdesc)(TALLOC_CTX *mem_ctx, const char *key,
key               142 source3/include/reg_objects.h 	WERROR (*set_secdesc)(const char *key,
key               164 source3/include/reg_objects.h 	REGISTRY_KEY *key;
key                92 source3/include/secrets.h 	char key[8];
key               137 source3/include/smbldap.h const char* get_attr_key2string( ATTRIB_MAP_ENTRY table[], int key );
key                35 source3/include/util_tdb.h int tdb_chainlock_with_timeout( struct tdb_context *tdb, TDB_DATA key,
key                44 source3/include/util_tdb.h int tdb_trans_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
key                46 source3/include/util_tdb.h int tdb_trans_delete(struct tdb_context *tdb, TDB_DATA key);
key                79 source3/iniparser/src/dictionary.c unsigned dictionary_hash(char * key)
key                85 source3/iniparser/src/dictionary.c 	len = strlen(key);
key                87 source3/iniparser/src/dictionary.c 		hash += (unsigned)key[i] ;
key               122 source3/iniparser/src/dictionary.c 	d->key  = (char **)calloc(size, sizeof(char*));
key               144 source3/iniparser/src/dictionary.c 		if (d->key[i]!=NULL)
key               145 source3/iniparser/src/dictionary.c 			free(d->key[i]);
key               150 source3/iniparser/src/dictionary.c 	free(d->key);
key               172 source3/iniparser/src/dictionary.c char * dictionary_get(dictionary * d, char * key, char * def)
key               177 source3/iniparser/src/dictionary.c 	hash = dictionary_hash(key);
key               179 source3/iniparser/src/dictionary.c         if (d->key==NULL)
key               184 source3/iniparser/src/dictionary.c             if (!strcmp(key, d->key[i])) {
key               204 source3/iniparser/src/dictionary.c char dictionary_getchar(dictionary * d, char * key, char def)
key               208 source3/iniparser/src/dictionary.c 	if ((v=dictionary_get(d,key,DICT_INVALID_KEY))==DICT_INVALID_KEY) {
key               229 source3/iniparser/src/dictionary.c int dictionary_getint(dictionary * d, char * key, int def)
key               233 source3/iniparser/src/dictionary.c 	if ((v=dictionary_get(d,key,DICT_INVALID_KEY))==DICT_INVALID_KEY) {
key               253 source3/iniparser/src/dictionary.c double dictionary_getdouble(dictionary * d, char * key, double def)
key               257 source3/iniparser/src/dictionary.c 	if ((v=dictionary_get(d,key,DICT_INVALID_KEY))==DICT_INVALID_KEY) {
key               290 source3/iniparser/src/dictionary.c void dictionary_set(dictionary * d, char * key, char * val)
key               295 source3/iniparser/src/dictionary.c 	if (d==NULL || key==NULL) return ;
key               298 source3/iniparser/src/dictionary.c 	hash = dictionary_hash(key) ;
key               302 source3/iniparser/src/dictionary.c             if (d->key[i]==NULL)
key               305 source3/iniparser/src/dictionary.c 				if (!strcmp(key, d->key[i])) {	 /* Same key */
key               322 source3/iniparser/src/dictionary.c 		d->key  = (char **)mem_double(d->key,  d->size * sizeof(char*)) ;
key               331 source3/iniparser/src/dictionary.c         if (d->key[i]==NULL) {
key               337 source3/iniparser/src/dictionary.c 	d->key[i]  = strdup(key);
key               355 source3/iniparser/src/dictionary.c void dictionary_unset(dictionary * d, char * key)
key               360 source3/iniparser/src/dictionary.c 	if (key == NULL) {
key               364 source3/iniparser/src/dictionary.c 	hash = dictionary_hash(key);
key               366 source3/iniparser/src/dictionary.c         if (d->key[i]==NULL)
key               371 source3/iniparser/src/dictionary.c             if (!strcmp(key, d->key[i])) {
key               381 source3/iniparser/src/dictionary.c     free(d->key[i]);
key               382 source3/iniparser/src/dictionary.c     d->key[i] = NULL ;
key               407 source3/iniparser/src/dictionary.c void dictionary_setint(dictionary * d, char * key, int val)
key               411 source3/iniparser/src/dictionary.c 	dictionary_set(d, key, sval);
key               429 source3/iniparser/src/dictionary.c void dictionary_setdouble(dictionary * d, char * key, double val)
key               433 source3/iniparser/src/dictionary.c 	dictionary_set(d, key, sval);
key               461 source3/iniparser/src/dictionary.c         if (d->key[i]) {
key               463 source3/iniparser/src/dictionary.c                     d->key[i],
key                54 source3/iniparser/src/dictionary.h 	char 		**  key ;	/** List of string keys */
key                75 source3/iniparser/src/dictionary.h unsigned dictionary_hash(char * key);
key               115 source3/iniparser/src/dictionary.h char * dictionary_get(dictionary * d, char * key, char * def);
key               130 source3/iniparser/src/dictionary.h char dictionary_getchar(dictionary * d, char * key, char def) ;
key               145 source3/iniparser/src/dictionary.h int dictionary_getint(dictionary * d, char * key, int def);
key               160 source3/iniparser/src/dictionary.h double dictionary_getdouble(dictionary * d, char * key, double def);
key               186 source3/iniparser/src/dictionary.h void dictionary_set(dictionary * vd, char * key, char * val);
key               199 source3/iniparser/src/dictionary.h void dictionary_unset(dictionary * d, char * key);
key               214 source3/iniparser/src/dictionary.h void dictionary_setint(dictionary * d, char * key, int val);
key               228 source3/iniparser/src/dictionary.h void dictionary_setdouble(dictionary * d, char * key, double val);
key                37 source3/iniparser/src/iniparser.c     char * key,
key                43 source3/iniparser/src/iniparser.c     if (key!=NULL) {
key                44 source3/iniparser/src/iniparser.c         sprintf(longkey, "%s:%s", sec, key);
key                82 source3/iniparser/src/iniparser.c         if (d->key[i]==NULL)
key                84 source3/iniparser/src/iniparser.c         if (strchr(d->key[i], ':')==NULL) {
key               115 source3/iniparser/src/iniparser.c         if (d->key[i]==NULL)
key               117 source3/iniparser/src/iniparser.c         if (strchr(d->key[i], ':')==NULL) {
key               126 source3/iniparser/src/iniparser.c     return d->key[i] ;
key               149 source3/iniparser/src/iniparser.c         if (d->key[i]==NULL)
key               152 source3/iniparser/src/iniparser.c             fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]);
key               154 source3/iniparser/src/iniparser.c             fprintf(f, "[%s]=UNDEF\n", d->key[i]);
key               186 source3/iniparser/src/iniparser.c             if (d->key[i]==NULL)
key               188 source3/iniparser/src/iniparser.c             fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
key               198 source3/iniparser/src/iniparser.c             if (d->key[j]==NULL)
key               200 source3/iniparser/src/iniparser.c             if (!strncmp(d->key[j], keym, seclen+1)) {
key               203 source3/iniparser/src/iniparser.c                         d->key[j]+seclen+1,
key               233 source3/iniparser/src/iniparser.c char * iniparser_getstr(dictionary * d, const char * key)
key               235 source3/iniparser/src/iniparser.c     return iniparser_getstring(d, key, NULL);
key               254 source3/iniparser/src/iniparser.c char * iniparser_getstring(dictionary * d, const char * key, char * def)
key               259 source3/iniparser/src/iniparser.c     if (d==NULL || key==NULL)
key               262 source3/iniparser/src/iniparser.c     if (!(lc_key = strdup(strlwc(key)))) {
key               299 source3/iniparser/src/iniparser.c int iniparser_getint(dictionary * d, const char * key, int notfound)
key               303 source3/iniparser/src/iniparser.c     str = iniparser_getstring(d, key, INI_INVALID_KEY);
key               322 source3/iniparser/src/iniparser.c double iniparser_getdouble(dictionary * d, char * key, double notfound)
key               326 source3/iniparser/src/iniparser.c     str = iniparser_getstring(d, key, INI_INVALID_KEY);
key               365 source3/iniparser/src/iniparser.c int iniparser_getboolean(dictionary * d, const char * key, int notfound)
key               370 source3/iniparser/src/iniparser.c     c = iniparser_getstring(d, key, INI_INVALID_KEY);
key               466 source3/iniparser/src/iniparser.c     char        key[ASCIILINESZ+1];
key               496 source3/iniparser/src/iniparser.c             } else if (sscanf (where, "%[^=] = \"%[^\"]\"", key, val) == 2
key               497 source3/iniparser/src/iniparser.c                    ||  sscanf (where, "%[^=] = '%[^\']'",   key, val) == 2
key               498 source3/iniparser/src/iniparser.c                    ||  sscanf (where, "%[^=] = %[^;#]",     key, val) == 2) {
key               499 source3/iniparser/src/iniparser.c                 strcpy(key, strlwc(strcrop(key)));
key               509 source3/iniparser/src/iniparser.c                 iniparser_add_entry(d, sec, key, val);
key               126 source3/iniparser/src/iniparser.h char * iniparser_getstr(dictionary * d, const char * key);
key               144 source3/iniparser/src/iniparser.h char * iniparser_getstring(dictionary * d, const char * key, char * def);
key               173 source3/iniparser/src/iniparser.h int iniparser_getint(dictionary * d, const char * key, int notfound);
key               188 source3/iniparser/src/iniparser.h double iniparser_getdouble(dictionary * d, char * key, double notfound);
key               222 source3/iniparser/src/iniparser.h int iniparser_getboolean(dictionary * d, const char * key, int notfound);
key                78 source3/lib/adt_tree.c static TREE_NODE* pathtree_birth_child( TREE_NODE *node, char* key )
key                87 source3/lib/adt_tree.c 	infant->key = talloc_strdup( infant, key );
key               101 source3/lib/adt_tree.c 			node->key ? node->key : "NULL", infant->key ));
key               118 source3/lib/adt_tree.c 				infant->key, node->children[i-1]->key));
key               123 source3/lib/adt_tree.c 			if ( StrCaseCmp( infant->key, node->children[i-1]->key ) > 0 ) {
key               151 source3/lib/adt_tree.c static TREE_NODE* pathtree_find_child( TREE_NODE *node, char* key )
key               161 source3/lib/adt_tree.c 	if ( !key ) {
key               169 source3/lib/adt_tree.c 			node->children[i]->key));
key               171 source3/lib/adt_tree.c 		result = StrCaseCmp( node->children[i]->key, key );
key               185 source3/lib/adt_tree.c 		next ? "Found" : "Did not find", key ));	
key               293 source3/lib/adt_tree.c 	if ( node->key )
key               294 source3/lib/adt_tree.c 		DEBUG(debug,("%s: [%s] (%s)\n", path ? path : "NULL", node->key,
key               307 source3/lib/adt_tree.c 			node->key ? node->key : "NULL");
key               327 source3/lib/adt_tree.c 	if ( tree->root->key )
key               328 source3/lib/adt_tree.c 		DEBUG(debug,("ROOT/: [%s] (%s)\n", tree->root->key,
key               334 source3/lib/adt_tree.c 			tree->root->key ? tree->root->key : "ROOT/" );
key               346 source3/lib/adt_tree.c  void* pathtree_find( SORTED_TREE *tree, char *key )
key               352 source3/lib/adt_tree.c 	DEBUG(10,("pathtree_find: Enter [%s]\n", key ? key : "NULL" ));
key               356 source3/lib/adt_tree.c 	if ( !key ) {
key               363 source3/lib/adt_tree.c 			key ? key : "NULL" ));
key               372 source3/lib/adt_tree.c 	if ( *key == '/' )
key               373 source3/lib/adt_tree.c 		keystr = SMB_STRDUP( key+1 );
key               375 source3/lib/adt_tree.c 		keystr = SMB_STRDUP( key );
key               378 source3/lib/adt_tree.c 		DEBUG(0,("pathtree_find: strdup() failed on string [%s]!?!?!\n", key));
key                48 source3/lib/afs.c 	DATA_BLOB key = data_blob(ct->HandShakeKey, 8);
key                60 source3/lib/afs.c 	base64_key = base64_encode_data_blob(mem_ctx, key);
key                87 source3/lib/afs.c 	struct afs_key key;
key                93 source3/lib/afs.c 	if (!secrets_fetch_afs_key(cell, &key)) {
key                98 source3/lib/afs.c 	ct->AuthHandle = key.kvno;
key               173 source3/lib/afs.c 	des_key_sched((const_des_cblock *)key.key, key_schedule);
key               175 source3/lib/afs.c 			 len, key_schedule, (C_Block *)key.key, 1);
key               177 source3/lib/afs.c 	ZERO_STRUCT(key);
key                44 source3/lib/conn_tdb.c 					   TDB_DATA key)
key                52 source3/lib/conn_tdb.c 	return ctx->fetch_locked(ctx, mem_ctx, key);
key                60 source3/lib/conn_tdb.c 	TDB_DATA key;
key                67 source3/lib/conn_tdb.c 	key.dsize = sizeof(ckey);
key                68 source3/lib/conn_tdb.c 	key.dptr = (uint8 *)&ckey;
key                70 source3/lib/conn_tdb.c 	return connections_fetch_record(mem_ctx, key);
key                75 source3/lib/conn_tdb.c 		  const struct connections_key *key,
key                86 source3/lib/conn_tdb.c 	if ((rec->key.dsize != sizeof(struct connections_key))
key                91 source3/lib/conn_tdb.c 	return state->fn(rec, (const struct connections_key *)rec->key.dptr,
key               110 source3/lib/conn_tdb.c 				 const struct connections_key *key,
key               891 source3/lib/ctdbd_conn.c 		       TDB_DATA key)
key               899 source3/lib/ctdbd_conn.c 	req.hdr.length = offsetof(struct ctdb_req_call, data) + key.dsize;
key               907 source3/lib/ctdbd_conn.c 	req.keylen           = key.dsize;
key               915 source3/lib/ctdbd_conn.c 		data_blob_const(key.dptr, key.dsize));
key               953 source3/lib/ctdbd_conn.c 		     TDB_DATA key, TALLOC_CTX *mem_ctx, TDB_DATA *data)
key               961 source3/lib/ctdbd_conn.c 	req.hdr.length = offsetof(struct ctdb_req_call, data) + key.dsize;
key               969 source3/lib/ctdbd_conn.c 	req.keylen           = key.dsize;
key               974 source3/lib/ctdbd_conn.c 		data_blob_const(key.dptr, key.dsize));
key              1023 source3/lib/ctdbd_conn.c 	void (*fn)(TDB_DATA key, TDB_DATA data, void *private_data);
key              1039 source3/lib/ctdbd_conn.c 	TDB_DATA key, data;
key              1057 source3/lib/ctdbd_conn.c 	key.dsize = d->keylen;
key              1058 source3/lib/ctdbd_conn.c 	key.dptr  = &d->data[0];
key              1062 source3/lib/ctdbd_conn.c 	if (key.dsize == 0 && data.dsize == 0) {
key              1077 source3/lib/ctdbd_conn.c 		state->fn(key, data, state->private_data);
key              1091 source3/lib/ctdbd_conn.c 			void (*fn)(TDB_DATA key, TDB_DATA data,
key                31 source3/lib/dbwrap.c 				 TDB_DATA key, TDB_DATA *data)
key                35 source3/lib/dbwrap.c 	if (!(rec = db->fetch_locked(db, mem_ctx, key))) {
key                49 source3/lib/dbwrap.c static int dbwrap_fallback_parse_record(struct db_context *db, TDB_DATA key,
key                50 source3/lib/dbwrap.c 					int (*parser)(TDB_DATA key,
key                58 source3/lib/dbwrap.c 	res = db->fetch(db, talloc_tos(), key, &data);
key                63 source3/lib/dbwrap.c 	res = parser(key, data, private_data);
key               161 source3/lib/dbwrap.c NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
key               166 source3/lib/dbwrap.c 	rec = db->fetch_locked(db, talloc_tos(), key);
key               175 source3/lib/dbwrap.c NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
key               181 source3/lib/dbwrap.c 	rec = db->fetch_locked(db, talloc_tos(), key);
key               192 source3/lib/dbwrap.c 		      TDB_DATA key)
key               196 source3/lib/dbwrap.c 	if (db->fetch(db, mem_ctx, key, &result) == -1) {
key               203 source3/lib/dbwrap.c NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
key               205 source3/lib/dbwrap.c 	return dbwrap_delete(db, string_term_tdb_data(key));
key               208 source3/lib/dbwrap.c NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
key               211 source3/lib/dbwrap.c 	return dbwrap_store(db, string_term_tdb_data(key), data, flags);
key               215 source3/lib/dbwrap.c 			       const char *key)
key               217 source3/lib/dbwrap.c 	return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key));
key                52 source3/lib/dbwrap_ctdb.c 					       TDB_DATA key,
key                84 source3/lib/dbwrap_ctdb.c 						  TDB_DATA key, 
key                91 source3/lib/dbwrap_ctdb.c 	length = offsetof(struct ctdb_rec_data, data) + key.dsize + 
key                99 source3/lib/dbwrap_ctdb.c 	d->keylen = key.dsize;
key               100 source3/lib/dbwrap_ctdb.c 	memcpy(&d->data[0], key.dptr, key.dsize);
key               103 source3/lib/dbwrap_ctdb.c 		memcpy(&d->data[key.dsize], header, sizeof(*header));
key               104 source3/lib/dbwrap_ctdb.c 		memcpy(&d->data[key.dsize+sizeof(*header)], data.dptr, data.dsize);
key               107 source3/lib/dbwrap_ctdb.c 		memcpy(&d->data[key.dsize], data.dptr, data.dsize);
key               118 source3/lib/dbwrap_ctdb.c 					       TDB_DATA key,
key               126 source3/lib/dbwrap_ctdb.c 	r = db_ctdb_marshall_record(talloc_tos(), reqid, key, header, data);
key               178 source3/lib/dbwrap_ctdb.c 						     TDB_DATA *key, TDB_DATA *data)
key               190 source3/lib/dbwrap_ctdb.c 	if (key != NULL) {
key               191 source3/lib/dbwrap_ctdb.c 		key->dptr   = &r->data[0];
key               192 source3/lib/dbwrap_ctdb.c 		key->dsize  = r->keylen;
key               226 source3/lib/dbwrap_ctdb.c 	TDB_DATA key;
key               233 source3/lib/dbwrap_ctdb.c 	key.dptr = (uint8_t *)discard_const(keyname);
key               234 source3/lib/dbwrap_ctdb.c 	key.dsize = strlen(keyname);
key               239 source3/lib/dbwrap_ctdb.c 	rh = fetch_locked_internal(ctx, tmp_ctx, key, true);
key               254 source3/lib/dbwrap_ctdb.c 	data = tdb_fetch(ctx->wtdb->tdb, key);
key               320 source3/lib/dbwrap_ctdb.c 				     TDB_DATA key, TDB_DATA *data)
key               324 source3/lib/dbwrap_ctdb.c 	*data = tdb_fetch(h->ctx->wtdb->tdb, key);
key               344 source3/lib/dbwrap_ctdb.c 		h->m_all = db_ctdb_marshall_add(h, h->m_all, h->ctx->db_id, 1, key, NULL, *data);
key               362 source3/lib/dbwrap_ctdb.c 							  TDB_DATA key)
key               374 source3/lib/dbwrap_ctdb.c 	result->key.dsize = key.dsize;
key               375 source3/lib/dbwrap_ctdb.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
key               376 source3/lib/dbwrap_ctdb.c 	if (result->key.dptr == NULL) {
key               385 source3/lib/dbwrap_ctdb.c 	ctdb_data = tdb_fetch(ctx->wtdb->tdb, key);
key               425 source3/lib/dbwrap_ctdb.c 							 TDB_DATA key)
key               435 source3/lib/dbwrap_ctdb.c 	rec = db_ctdb_fetch_locked_transaction(ctx, mem_ctx, key);
key               458 source3/lib/dbwrap_ctdb.c 				     TDB_DATA key, TDB_DATA data)
key               466 source3/lib/dbwrap_ctdb.c 	rec = tdb_fetch(h->ctx->wtdb->tdb, key);
key               489 source3/lib/dbwrap_ctdb.c 		h->m_all = db_ctdb_marshall_add(h, h->m_all, h->ctx->db_id, 0, key, NULL, data);
key               497 source3/lib/dbwrap_ctdb.c 	h->m_write = db_ctdb_marshall_add(h, h->m_write, h->ctx->db_id, 0, key, &header, data);
key               514 source3/lib/dbwrap_ctdb.c 	ret = tdb_store(h->ctx->wtdb->tdb, key, rec, TDB_REPLACE);
key               531 source3/lib/dbwrap_ctdb.c 	ret = db_ctdb_transaction_store(h, rec->key, data);
key               547 source3/lib/dbwrap_ctdb.c 	ret = db_ctdb_transaction_store(h, rec->key, tdb_null);
key               573 source3/lib/dbwrap_ctdb.c 		TDB_DATA key, data;
key               575 source3/lib/dbwrap_ctdb.c 		rec = db_ctdb_marshall_loop_next(h->m_all, rec, NULL, NULL, &key, &data);
key               583 source3/lib/dbwrap_ctdb.c 			if (db_ctdb_transaction_store(h, key, data) != 0) {
key               590 source3/lib/dbwrap_ctdb.c 			if (db_ctdb_transaction_fetch(h->ctx, tmp_ctx, key, &data2) != 0) {
key               790 source3/lib/dbwrap_ctdb.c 	ret = tdb_store(crec->ctdb_ctx->wtdb->tdb, rec->key, cdata, TDB_REPLACE);
key               824 source3/lib/dbwrap_ctdb.c 		   hex_encode_talloc(data, (unsigned char *)data->key.dptr,
key               825 source3/lib/dbwrap_ctdb.c 			      data->key.dsize)));
key               827 source3/lib/dbwrap_ctdb.c 	if (tdb_chainunlock(crec->ctdb_ctx->wtdb->tdb, data->key) != 0) {
key               837 source3/lib/dbwrap_ctdb.c 					       TDB_DATA key,
key               860 source3/lib/dbwrap_ctdb.c 	result->key.dsize = key.dsize;
key               861 source3/lib/dbwrap_ctdb.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
key               862 source3/lib/dbwrap_ctdb.c 	if (result->key.dptr == NULL) {
key               874 source3/lib/dbwrap_ctdb.c 		char *keystr = hex_encode_talloc(result, key.dptr, key.dsize);
key               882 source3/lib/dbwrap_ctdb.c 	if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
key               892 source3/lib/dbwrap_ctdb.c 	ctdb_data = tdb_fetch(ctx->wtdb->tdb, key);
key               907 source3/lib/dbwrap_ctdb.c 		tdb_chainunlock(ctx->wtdb->tdb, key);
key               917 source3/lib/dbwrap_ctdb.c 		status = ctdbd_migrate(messaging_ctdbd_connection(),ctx->db_id, key);
key               953 source3/lib/dbwrap_ctdb.c 					      TDB_DATA key)
key               959 source3/lib/dbwrap_ctdb.c 		return db_ctdb_fetch_locked_transaction(ctx, mem_ctx, key);
key               963 source3/lib/dbwrap_ctdb.c 		return db_ctdb_fetch_locked_persistent(ctx, mem_ctx, key);
key               966 source3/lib/dbwrap_ctdb.c 	return fetch_locked_internal(ctx, mem_ctx, key, db->persistent);
key               973 source3/lib/dbwrap_ctdb.c 			 TDB_DATA key, TDB_DATA *data)
key               981 source3/lib/dbwrap_ctdb.c 		return db_ctdb_transaction_fetch(ctx, mem_ctx, key, data);
key               985 source3/lib/dbwrap_ctdb.c 	ctdb_data = tdb_fetch(ctx->wtdb->tdb, key);
key              1020 source3/lib/dbwrap_ctdb.c 	status = ctdbd_fetch(messaging_ctdbd_connection(),ctx->db_id, key, mem_ctx, data);
key              1035 source3/lib/dbwrap_ctdb.c static void traverse_callback(TDB_DATA key, TDB_DATA data, void *private_data)
key              1041 source3/lib/dbwrap_ctdb.c 	rec = db_ctdb_fetch_locked(state->db, tmp_ctx, key);
key              1098 source3/lib/dbwrap_ctdb.c static void traverse_read_callback(TDB_DATA key, TDB_DATA data, void *private_data)
key              1102 source3/lib/dbwrap_ctdb.c 	rec.key = key;
key              1115 source3/lib/dbwrap_ctdb.c 	rec.key = kbuf;
key                69 source3/lib/dbwrap_file.c 					      TDB_DATA key)
key                98 source3/lib/dbwrap_file.c 	result->key.dsize = key.dsize;
key                99 source3/lib/dbwrap_file.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
key               100 source3/lib/dbwrap_file.c 	if (result->key.dptr == NULL) {
key               107 source3/lib/dbwrap_file.c 	file->hash = fsh(key.dptr, key.dsize);
key               108 source3/lib/dbwrap_file.c 	file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize);
key               282 source3/lib/dbwrap_file.c 			TDB_DATA key;
key               298 source3/lib/dbwrap_file.c 			key.dptr = keyblob.data;
key               299 source3/lib/dbwrap_file.c 			key.dsize = keyblob.length;
key               302 source3/lib/dbwrap_file.c 			    (key.dsize == ctx->locked_record->key.dsize) &&
key               303 source3/lib/dbwrap_file.c 			    (memcmp(key.dptr, ctx->locked_record->key.dptr,
key               304 source3/lib/dbwrap_file.c 				    key.dsize) == 0)) {
key               314 source3/lib/dbwrap_file.c 			rec = db_file_fetch_locked(db, mem_ctx, key);
key                82 source3/lib/dbwrap_rbt.c 			      TDB_DATA *key, TDB_DATA *value)
key                84 source3/lib/dbwrap_rbt.c 	key->dptr = ((uint8 *)node) + offsetof(struct db_rbt_node, data);
key                85 source3/lib/dbwrap_rbt.c 	key->dsize = node->keysize;
key                86 source3/lib/dbwrap_rbt.c 	value->dptr = key->dptr + node->keysize;
key               108 source3/lib/dbwrap_rbt.c 		SMB_ASSERT(this_key.dsize == rec->key.dsize);
key               109 source3/lib/dbwrap_rbt.c 		SMB_ASSERT(memcmp(this_key.dptr, rec->key.dptr,
key               135 source3/lib/dbwrap_rbt.c 		offsetof(struct db_rbt_node, data) + rec->key.dsize
key               145 source3/lib/dbwrap_rbt.c 	node->keysize = rec->key.dsize;
key               150 source3/lib/dbwrap_rbt.c 	memcpy(this_key.dptr, rec->key.dptr, node->keysize);
key               204 source3/lib/dbwrap_rbt.c 					     TDB_DATA key)
key               226 source3/lib/dbwrap_rbt.c 		res = db_rbt_compare(key, search_key);
key               253 source3/lib/dbwrap_rbt.c 		size += key.dsize;
key               271 source3/lib/dbwrap_rbt.c 		result->key = search_key;
key               276 source3/lib/dbwrap_rbt.c 		result->key.dptr = (uint8 *)
key               278 source3/lib/dbwrap_rbt.c 		result->key.dsize = key.dsize;
key               279 source3/lib/dbwrap_rbt.c 		memcpy(result->key.dptr, key.dptr, key.dsize);
key               288 source3/lib/dbwrap_rbt.c 			TDB_DATA key, TDB_DATA *data)
key               308 source3/lib/dbwrap_rbt.c 		res = db_rbt_compare(key, search_key);
key                41 source3/lib/dbwrap_tdb.c 		   hex_encode_talloc(data, (unsigned char *)data->key.dptr,
key                42 source3/lib/dbwrap_tdb.c 			      data->key.dsize)));
key                44 source3/lib/dbwrap_tdb.c 	if (tdb_chainunlock(ctx->wtdb->tdb, data->key) != 0) {
key                56 source3/lib/dbwrap_tdb.c static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,
key                64 source3/lib/dbwrap_tdb.c 		sizeof(struct db_record) + key.dsize + data.dsize);
key                70 source3/lib/dbwrap_tdb.c 	state->result->key.dsize = key.dsize;
key                71 source3/lib/dbwrap_tdb.c 	state->result->key.dptr = ((uint8 *)state->result)
key                73 source3/lib/dbwrap_tdb.c 	memcpy(state->result->key.dptr, key.dptr, key.dsize);
key                78 source3/lib/dbwrap_tdb.c 		state->result->value.dptr = state->result->key.dptr+key.dsize;
key                89 source3/lib/dbwrap_tdb.c 				     TALLOC_CTX *mem_ctx, TDB_DATA key)
key                97 source3/lib/dbwrap_tdb.c 		char *keystr = hex_encode_talloc(NULL, (unsigned char*)key.dptr, key.dsize);
key               104 source3/lib/dbwrap_tdb.c 	if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
key               112 source3/lib/dbwrap_tdb.c 	tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse, &state);
key               115 source3/lib/dbwrap_tdb.c 		db_tdb_fetchlock_parse(key, tdb_null, &state);
key               119 source3/lib/dbwrap_tdb.c 		tdb_chainunlock(ctx->wtdb->tdb, key);
key               140 source3/lib/dbwrap_tdb.c static int db_tdb_fetch_parse(TDB_DATA key, TDB_DATA data,
key               158 source3/lib/dbwrap_tdb.c 			TDB_DATA key, TDB_DATA *pdata)
key               169 source3/lib/dbwrap_tdb.c 	tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetch_parse, &state);
key               179 source3/lib/dbwrap_tdb.c static int db_tdb_parse(struct db_context *db, TDB_DATA key,
key               180 source3/lib/dbwrap_tdb.c 			int (*parser)(TDB_DATA key, TDB_DATA data,
key               187 source3/lib/dbwrap_tdb.c 	return tdb_parse_record(ctx->wtdb->tdb, key, parser, private_data);
key               201 source3/lib/dbwrap_tdb.c 	return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ?
key               210 source3/lib/dbwrap_tdb.c 	if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {
key               234 source3/lib/dbwrap_tdb.c 	rec.key = kbuf;
key               274 source3/lib/dbwrap_tdb.c 	rec.key = kbuf;
key               181 source3/lib/dbwrap_util.c NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
key               194 source3/lib/dbwrap_util.c 	rec = db->fetch_locked(db, talloc_tos(), key);
key               228 source3/lib/dbwrap_util.c NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
key               240 source3/lib/dbwrap_util.c 	rec = db->fetch_locked(db, talloc_tos(), key);
key               300 source3/lib/dbwrap_util.c NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
key               303 source3/lib/dbwrap_util.c 	return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);
key               306 source3/lib/dbwrap_util.c NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
key               308 source3/lib/dbwrap_util.c 	return dbwrap_trans_delete(db, string_term_tdb_data(key));
key                89 source3/lib/eventlog/eventlog.c static int eventlog_tdb_size_fn( TDB_CONTEXT * tdb, TDB_DATA key, TDB_DATA data,
key               151 source3/lib/eventlog/eventlog.c 	TDB_DATA key, ret;
key               186 source3/lib/eventlog/eventlog.c 		key.dsize = sizeof(int32_t);
key               187 source3/lib/eventlog/eventlog.c 		key.dptr = (unsigned char *)&i;
key               188 source3/lib/eventlog/eventlog.c 		ret = tdb_fetch( the_tdb, key );
key               232 source3/lib/eventlog/eventlog.c 			key.dsize = sizeof(int32_t);
key               233 source3/lib/eventlog/eventlog.c 			key.dptr = (unsigned char *)&i;
key               234 source3/lib/eventlog/eventlog.c 			tdb_delete( the_tdb, key );
key               654 source3/lib/eventlog/eventlog.c 	TDB_DATA data, key;
key               661 source3/lib/eventlog/eventlog.c 	key.dptr = (unsigned char *)&srecno;
key               662 source3/lib/eventlog/eventlog.c 	key.dsize = sizeof(int32_t);
key               664 source3/lib/eventlog/eventlog.c 	data = tdb_fetch(tdb, key);
key               400 source3/lib/gencache.c 	void (*fn)(const char *key, const char *value, time_t timeout,
key               406 source3/lib/gencache.c static int gencache_iterate_fn(struct tdb_context *tdb, TDB_DATA key,
key               419 source3/lib/gencache.c 	if (key.dptr[key.dsize-1] == '\0') {
key               420 source3/lib/gencache.c 		keystr = (char *)key.dptr;
key               423 source3/lib/gencache.c 		keystr = SMB_STRNDUP((char *)key.dptr, key.dsize);
key               463 source3/lib/gencache.c void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
key               485 source3/lib/gencache.c int gencache_lock_entry( const char *key )
key               490 source3/lib/gencache.c 	return tdb_lock_bystring(cache, key);
key               497 source3/lib/gencache.c void gencache_unlock_entry( const char *key )
key               502 source3/lib/gencache.c 	tdb_unlock_bystring(cache, key);
key                36 source3/lib/idmap_cache.c 	char *key;
key                43 source3/lib/idmap_cache.c 	key = talloc_asprintf(talloc_tos(), "IDMAP/SID2UID/%s",
key                45 source3/lib/idmap_cache.c 	if (key == NULL) {
key                48 source3/lib/idmap_cache.c 	ret = gencache_get(key, &value, &timeout);
key                49 source3/lib/idmap_cache.c 	TALLOC_FREE(key);
key                75 source3/lib/idmap_cache.c 	char *key;
key                80 source3/lib/idmap_cache.c 	key = talloc_asprintf(talloc_tos(), "IDMAP/UID2SID/%d", (int)uid);
key                81 source3/lib/idmap_cache.c 	if (key == NULL) {
key                84 source3/lib/idmap_cache.c 	ret = gencache_get(key, &value, &timeout);
key                85 source3/lib/idmap_cache.c 	TALLOC_FREE(key);
key               116 source3/lib/idmap_cache.c 	fstring sidstr, key, value;
key               119 source3/lib/idmap_cache.c 		fstr_sprintf(key, "IDMAP/SID2UID/%s",
key               125 source3/lib/idmap_cache.c 		gencache_set(key, value, now + timeout);
key               128 source3/lib/idmap_cache.c 		fstr_sprintf(key, "IDMAP/UID2SID/%d", (int)uid);
key               138 source3/lib/idmap_cache.c 		gencache_set(key, value, now + timeout);
key               156 source3/lib/idmap_cache.c 	char *key;
key               163 source3/lib/idmap_cache.c 	key = talloc_asprintf(talloc_tos(), "IDMAP/SID2GID/%s",
key               165 source3/lib/idmap_cache.c 	if (key == NULL) {
key               168 source3/lib/idmap_cache.c 	ret = gencache_get(key, &value, &timeout);
key               169 source3/lib/idmap_cache.c 	TALLOC_FREE(key);
key               195 source3/lib/idmap_cache.c 	char *key;
key               200 source3/lib/idmap_cache.c 	key = talloc_asprintf(talloc_tos(), "IDMAP/GID2SID/%d", (int)gid);
key               201 source3/lib/idmap_cache.c 	if (key == NULL) {
key               204 source3/lib/idmap_cache.c 	ret = gencache_get(key, &value, &timeout);
key               205 source3/lib/idmap_cache.c 	TALLOC_FREE(key);
key               236 source3/lib/idmap_cache.c 	fstring sidstr, key, value;
key               239 source3/lib/idmap_cache.c 		fstr_sprintf(key, "IDMAP/SID2GID/%s",
key               245 source3/lib/idmap_cache.c 		gencache_set(key, value, now + timeout);
key               248 source3/lib/idmap_cache.c 		fstr_sprintf(key, "IDMAP/GID2SID/%d", (int)gid);
key               258 source3/lib/idmap_cache.c 		gencache_set(key, value, now + timeout);
key               158 source3/lib/ldb/ldb_tdb/ldb_index.c 			    unsigned int *v_idx, const char *key)
key               162 source3/lib/ldb/ldb_tdb/ldb_index.c 		if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
key              1084 source3/lib/ldb/ldb_tdb/ldb_index.c static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key              1087 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
key              1088 source3/lib/ldb/ldb_tdb/ldb_index.c 		return tdb_delete(tdb, key);
key              1096 source3/lib/ldb/ldb_tdb/ldb_index.c static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key              1104 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, "DN=@", 4) == 0 ||
key              1105 source3/lib/ldb/ldb_tdb/ldb_index.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
key              1130 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strcmp((char *)key2.dptr, (char *)key.dptr) != 0) {
key              1131 source3/lib/ldb/ldb_tdb/ldb_index.c 		tdb_delete(tdb, key);
key              1137 source3/lib/ldb/ldb_tdb/ldb_index.c 		dn = (char *)key.dptr + 3;
key               364 source3/lib/ldb/ldb_tdb/ldb_search.c static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key               371 source3/lib/ldb/ldb_tdb/ldb_search.c 	if (key.dsize < 4 || 
key               372 source3/lib/ldb/ldb_tdb/ldb_search.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
key               399 source3/lib/ldb/ldb_tdb/ldb_search.c 		ares->message->dn = ldb_dn_explode(ares->message, (char *)key.dptr + 3);
key               124 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	TDB_DATA key;
key               153 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = (uint8_t *)key_str;
key               154 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dsize = strlen(key_str) + 1;
key               156 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	return key;
key               160 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = NULL;
key               161 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dsize = 0;
key               162 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	return key;
key                41 source3/lib/memcache.c 				   DATA_BLOB *key, DATA_BLOB *value);
key                97 source3/lib/memcache.c 				   DATA_BLOB *key, DATA_BLOB *value)
key                99 source3/lib/memcache.c 	key->data = ((uint8 *)e) + offsetof(struct memcache_element, data);
key               100 source3/lib/memcache.c 	key->length = e->keylength;
key               101 source3/lib/memcache.c 	value->data = key->data + e->keylength;
key               111 source3/lib/memcache.c 			    DATA_BLOB key)
key               118 source3/lib/memcache.c 	if (e->keylength < key.length) return 1;
key               119 source3/lib/memcache.c 	if (e->keylength > key.length) return -1;
key               122 source3/lib/memcache.c 	return memcmp(this_key.data, key.data, key.length);
key               126 source3/lib/memcache.c 	struct memcache *cache, enum memcache_number n, DATA_BLOB key)
key               136 source3/lib/memcache.c 		cmp = memcache_compare(elem, n, key);
key               147 source3/lib/memcache.c 		     DATA_BLOB key, DATA_BLOB *value)
key               158 source3/lib/memcache.c 	e = memcache_find(cache, n, key);
key               176 source3/lib/memcache.c 	memcache_element_parse(e, &key, value);
key               181 source3/lib/memcache.c 			     DATA_BLOB key)
key               186 source3/lib/memcache.c 	if (!memcache_lookup(cache, n, key, &value)) {
key               236 source3/lib/memcache.c 		     DATA_BLOB key)
key               247 source3/lib/memcache.c 	e = memcache_find(cache, n, key);
key               256 source3/lib/memcache.c 		  DATA_BLOB key, DATA_BLOB value)
key               271 source3/lib/memcache.c 	if (key.length == 0) {
key               275 source3/lib/memcache.c 	e = memcache_find(cache, n, key);
key               298 source3/lib/memcache.c 	element_size = memcache_element_size(key.length, value.length);
key               309 source3/lib/memcache.c 	e->keylength = key.length;
key               313 source3/lib/memcache.c 	memcpy(cache_key.data, key.data, key.length);
key               325 source3/lib/memcache.c 		cmp = memcache_compare(elem, n, key);
key               343 source3/lib/memcache.c 			 DATA_BLOB key, void *pptr)
key               356 source3/lib/memcache.c 	memcache_add(cache, n, key, data_blob_const(&p, sizeof(p)));
key               145 source3/lib/messages_local.c 	char *key;
key               148 source3/lib/messages_local.c 	key = talloc_asprintf(talloc_tos(), "PID/%s", procid_str_static(&pid));
key               150 source3/lib/messages_local.c 	SMB_ASSERT(key != NULL);
key               152 source3/lib/messages_local.c 	kbuf.dptr = (uint8 *)key;
key               153 source3/lib/messages_local.c 	kbuf.dsize = strlen(key)+1;
key               162 source3/lib/messages_local.c 				    TDB_DATA key,
key               175 source3/lib/messages_local.c 	data = tdb_fetch(msg_tdb, key);
key               209 source3/lib/messages_local.c 				    TDB_DATA key,
key               219 source3/lib/messages_local.c 		tdb_delete(msg_tdb, key);
key               244 source3/lib/messages_local.c 	ret = tdb_store(msg_tdb, key, data, TDB_REPLACE);
key               319 source3/lib/messages_local.c 	TDB_DATA key;
key               335 source3/lib/messages_local.c 	key = message_key_pid(frame, pid);
key               337 source3/lib/messages_local.c 	if (tdb_chainlock(tdb->tdb, key) == -1) {
key               342 source3/lib/messages_local.c 	status = messaging_tdb_fetch(tdb->tdb, key, talloc_tos(), &msg_array);
key               372 source3/lib/messages_local.c 	status = messaging_tdb_store(tdb->tdb, key, msg_array);
key               387 source3/lib/messages_local.c 	tdb_chainunlock(tdb->tdb, key);
key               401 source3/lib/messages_local.c 	TDB_DATA key = message_key_pid(mem_ctx, procid_self());
key               404 source3/lib/messages_local.c 	if (tdb_chainlock(msg_tdb, key) == -1) {
key               405 source3/lib/messages_local.c 		TALLOC_FREE(key.dptr);
key               409 source3/lib/messages_local.c 	status = messaging_tdb_fetch(msg_tdb, key, mem_ctx, &result);
key               414 source3/lib/messages_local.c 	tdb_delete(msg_tdb, key);
key               415 source3/lib/messages_local.c 	tdb_chainunlock(msg_tdb, key);
key               421 source3/lib/messages_local.c 	TALLOC_FREE(key.dptr);
key               157 source3/lib/privileges.c 	if ( strncmp((char *)rec->key.dptr, PRIVPREFIX, prefixlen) != 0)
key               174 source3/lib/privileges.c 	fstrcpy( sid_string, (char *)&(rec->key.dptr[strlen(PRIVPREFIX)]) );
key               159 source3/lib/sharesec.c 	char *key;
key               168 source3/lib/sharesec.c 	if (!(key = talloc_asprintf(ctx, "SECDESC/%s", servicename))) {
key               173 source3/lib/sharesec.c 	data = dbwrap_fetch_bystring(share_db, talloc_tos(), key);
key               175 source3/lib/sharesec.c 	TALLOC_FREE(key);
key               205 source3/lib/sharesec.c 	char *key;
key               224 source3/lib/sharesec.c 	if (!(key = talloc_asprintf(frame, "SECDESC/%s", share_name))) {
key               229 source3/lib/sharesec.c 	status = dbwrap_trans_store(share_db, string_term_tdb_data(key), blob,
key               252 source3/lib/sharesec.c 	char *key;
key               259 source3/lib/sharesec.c 	if (!(key = talloc_asprintf(talloc_tos(), "SECDESC/%s",
key               263 source3/lib/sharesec.c 	kbuf = string_term_tdb_data(key);
key                81 source3/lib/smbconf/smbconf_reg.c 					   struct registry_key **key)
key                86 source3/lib/smbconf/smbconf_reg.c 		*key = rpd(ctx)->base_key;
key                90 source3/lib/smbconf/smbconf_reg.c 			   desired_access, key);
key               102 source3/lib/smbconf/smbconf_reg.c static bool smbconf_value_exists(struct registry_key *key, const char *param)
key               109 source3/lib/smbconf/smbconf_reg.c 	werr = reg_queryvalue(ctx, key, param, &value);
key               153 source3/lib/smbconf/smbconf_reg.c static WERROR smbconf_reg_set_value(struct registry_key *key,
key               185 source3/lib/smbconf/smbconf_reg.c 	subkeyname = strrchr_m(key->key->name, '\\');
key               188 source3/lib/smbconf/smbconf_reg.c 			  "smbconf section.\n", key->key->name));
key               209 source3/lib/smbconf/smbconf_reg.c 	werr = reg_setvalue(key, canon_valname, &val);
key               213 source3/lib/smbconf/smbconf_reg.c 			  canon_valname, key->key->name, win_errstr(werr)));
key               220 source3/lib/smbconf/smbconf_reg.c static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
key               254 source3/lib/smbconf/smbconf_reg.c 	werr = reg_setvalue(key, valname, value);
key               257 source3/lib/smbconf/smbconf_reg.c 			  valname, key->key->name, win_errstr(werr)));
key               314 source3/lib/smbconf/smbconf_reg.c 						struct registry_key *key,
key               324 source3/lib/smbconf/smbconf_reg.c 	if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
key               332 source3/lib/smbconf/smbconf_reg.c 	werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
key               375 source3/lib/smbconf/smbconf_reg.c 				     struct registry_key *key,
key               401 source3/lib/smbconf/smbconf_reg.c 	     werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
key               431 source3/lib/smbconf/smbconf_reg.c 	werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
key               467 source3/lib/smbconf/smbconf_reg.c static bool smbconf_reg_key_has_values(struct registry_key *key)
key               479 source3/lib/smbconf/smbconf_reg.c 	werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
key               493 source3/lib/smbconf/smbconf_reg.c static WERROR smbconf_reg_delete_values(struct registry_key *key)
key               502 source3/lib/smbconf/smbconf_reg.c 	     werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
key               506 source3/lib/smbconf/smbconf_reg.c 		werr = reg_deletevalue(key, valname);
key               514 source3/lib/smbconf/smbconf_reg.c 			  key->key->name,
key               791 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               794 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_READ, &key);
key               810 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               817 source3/lib/smbconf/smbconf_reg.c 					      servicename, &key);
key               819 source3/lib/smbconf/smbconf_reg.c 	talloc_free(key);
key               832 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               837 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_READ, &key);
key               856 source3/lib/smbconf/smbconf_reg.c 	werr = smbconf_reg_get_values(tmp_service, key,
key               899 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               903 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_WRITE, &key);
key               908 source3/lib/smbconf/smbconf_reg.c 	werr = smbconf_reg_set_value(key, param, valstr);
key               925 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               929 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_READ, &key);
key               939 source3/lib/smbconf/smbconf_reg.c 	if (!smbconf_value_exists(key, param)) {
key               944 source3/lib/smbconf/smbconf_reg.c 	werr = reg_queryvalue(mem_ctx, key, param, &value);
key               956 source3/lib/smbconf/smbconf_reg.c 	talloc_free(key);
key               968 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key               973 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_ALL, &key);
key               983 source3/lib/smbconf/smbconf_reg.c 	if (!smbconf_value_exists(key, param)) {
key               988 source3/lib/smbconf/smbconf_reg.c 	werr = reg_deletevalue(key, param);
key              1002 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key              1006 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_READ, &key);
key              1011 source3/lib/smbconf/smbconf_reg.c 	werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
key              1025 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key              1029 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_ALL, &key);
key              1035 source3/lib/smbconf/smbconf_reg.c 		if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
key              1038 source3/lib/smbconf/smbconf_reg.c 		werr = reg_deletevalue(key, INCLUDES_VALNAME);
key              1040 source3/lib/smbconf/smbconf_reg.c 		werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
key              1053 source3/lib/smbconf/smbconf_reg.c 	struct registry_key *key = NULL;
key              1057 source3/lib/smbconf/smbconf_reg.c 					    REG_KEY_ALL, &key);
key              1062 source3/lib/smbconf/smbconf_reg.c 	if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
key              1066 source3/lib/smbconf/smbconf_reg.c 	werr = reg_deletevalue(key, INCLUDES_VALNAME);
key               217 source3/lib/smbldap.c  const char* get_attr_key2string( ATTRIB_MAP_ENTRY table[], int key )
key               222 source3/lib/smbldap.c 		if ( table[i].attrib == key )
key               207 source3/lib/tdb_validate.c static int traverse_copy_fn(struct tdb_context *tdb, TDB_DATA key,
key               212 source3/lib/tdb_validate.c 	if (tdb_store(data->dst, key, dbuf, TDB_INSERT) != 0) {
key                46 source3/lib/util_tdb.c static int tdb_chainlock_with_timeout_internal( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout, int rw_type)
key                59 source3/lib/util_tdb.c 		ret = tdb_chainlock_read(tdb, key);
key                61 source3/lib/util_tdb.c 		ret = tdb_chainlock(tdb, key);
key                69 source3/lib/util_tdb.c 				timeout, key.dptr, tdb_name(tdb)));
key                85 source3/lib/util_tdb.c int tdb_chainlock_with_timeout( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout)
key                87 source3/lib/util_tdb.c 	return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_WRLCK);
key                93 source3/lib/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key                95 source3/lib/util_tdb.c 	return tdb_chainlock_with_timeout(tdb, key, timeout);
key               104 source3/lib/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keyval);
key               106 source3/lib/util_tdb.c 	return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_RDLCK);
key               115 source3/lib/util_tdb.c 	TDB_DATA key = string_term_tdb_data(keystr);
key               117 source3/lib/util_tdb.c 	return tdb_trans_store(tdb, key, data, flags);
key               430 source3/lib/util_tdb.c int tdb_trans_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
key               440 source3/lib/util_tdb.c 	if ((res = tdb_store(tdb, key, dbuf, flag)) != 0) {
key               460 source3/lib/util_tdb.c int tdb_trans_delete(struct tdb_context *tdb, TDB_DATA key)
key               469 source3/lib/util_tdb.c 	if ((res = tdb_delete(tdb, key)) != 0) {
key               361 source3/libaddns/dns.h 	uint8 *key;
key               436 source3/libaddns/dns.h 				 uint16 key_length, const uint8 *key,
key               188 source3/libaddns/dnsgss.c 			input_desc.value = talloc_move(mem_ctx, &tkey->key);
key               277 source3/libaddns/dnsgss.c 	struct dns_domain_name *key, *algorithm;
key               285 source3/libaddns/dnsgss.c 	err = dns_domain_name_from_string(buf, keyname, &key);
key               291 source3/libaddns/dnsgss.c 	dns_marshall_domain_name(buf, key);
key               181 source3/libaddns/dnsrecord.c 				 uint16 key_length, const uint8 *key,
key               201 source3/libaddns/dnsrecord.c 	dns_marshall_buffer(buf, key, key_length);
key               243 source3/libaddns/dnsrecord.c 		if (!(tkey->key = TALLOC_ARRAY(tkey, uint8, tkey->key_length))) {
key               248 source3/libaddns/dnsrecord.c 		tkey->key = NULL;
key               251 source3/libaddns/dnsrecord.c 	dns_unmarshall_buffer(&buf, tkey->key, tkey->key_length);
key               755 source3/libads/dns.c 	char *key;
key               766 source3/libads/dns.c 	key = sitename_key(realm);
key               770 source3/libads/dns.c 		ret = gencache_del(key);
key               771 source3/libads/dns.c 		SAFE_FREE(key);
key               780 source3/libads/dns.c 	ret = gencache_set( key, sitename, expire );
key               781 source3/libads/dns.c 	SAFE_FREE(key);
key               796 source3/libads/dns.c 	char *key;
key               808 source3/libads/dns.c 	key = sitename_key(query_realm);
key               810 source3/libads/dns.c 	ret = gencache_get( key, &sitename, &timeout );
key               811 source3/libads/dns.c 	SAFE_FREE(key);
key               383 source3/libads/kerberos.c 	char *key = NULL;
key               386 source3/libads/kerberos.c 	if (asprintf(&key, "%s/%s/enctype=%d",
key               390 source3/libads/kerberos.c 	ret = (char *)secrets_fetch(key, NULL);
key               391 source3/libads/kerberos.c 	SAFE_FREE(key);
key               415 source3/libads/kerberos.c 	char *key;
key               417 source3/libads/kerberos.c 	if (asprintf(&key, "%s/DES/%s", SECRETS_SALTING_PRINCIPAL,
key               422 source3/libads/kerberos.c 	return key;
key               430 source3/libads/kerberos.c 	char* key;
key               433 source3/libads/kerberos.c 	if ( (key = des_salt_key()) == NULL ) {
key               440 source3/libads/kerberos.c 		secrets_delete( key );
key               446 source3/libads/kerberos.c 	ret = secrets_store( key, salt, strlen(salt)+1 );
key               448 source3/libads/kerberos.c 	SAFE_FREE( key );
key               458 source3/libads/kerberos.c 	char *salt, *key;
key               460 source3/libads/kerberos.c 	if ( (key = des_salt_key()) == NULL ) {
key               465 source3/libads/kerberos.c 	salt = (char*)secrets_fetch( key, NULL );
key               467 source3/libads/kerberos.c 	SAFE_FREE( key );
key               579 source3/libads/kerberos.c 	char *key = NULL;
key               610 source3/libads/kerberos.c 	if (asprintf(&key, "%s/%s/enctype=%d",
key               617 source3/libads/kerberos.c 		ret = secrets_store(key, principal, strlen(principal) + 1);
key               619 source3/libads/kerberos.c 		ret = secrets_delete(key);
key               624 source3/libads/kerberos.c 	SAFE_FREE(key);
key                76 source3/libads/kerberos_verify.c 	enctype = dec_ticket->ticket.key.keytype;
key               350 source3/libads/kerberos_verify.c 		krb5_keyblock *key = NULL;
key               352 source3/libads/kerberos_verify.c 		if (!(key = SMB_MALLOC_P(krb5_keyblock))) {
key               357 source3/libads/kerberos_verify.c 		if (create_kerberos_key_from_string(context, host_princ, &password, key, enctypes[i], false)) {
key               358 source3/libads/kerberos_verify.c 			SAFE_FREE(key);
key               362 source3/libads/kerberos_verify.c 		krb5_auth_con_setuseruserkey(context, auth_context, key);
key               370 source3/libads/kerberos_verify.c 			krb5_copy_keyblock(context, key, keyblock);
key               371 source3/libads/kerberos_verify.c 			krb5_free_keyblock(context, key);
key               383 source3/libads/kerberos_verify.c 			krb5_free_keyblock(context, key);
key               387 source3/libads/kerberos_verify.c 		krb5_free_keyblock(context, key);
key               403 source3/libads/ldap_printer.c 	uint32 key,val;
key               405 source3/libads/ldap_printer.c 	for (key=0; key < data->num_keys; key++) {
key               406 source3/libads/ldap_printer.c 		REGVAL_CTR *ctr = data->keys[key].values;
key               397 source3/libgpo/gpext/gpext.c 					  struct registry_key *key,
key               405 source3/libgpo/gpext/gpext.c 		werr = reg_setvalue(key,
key               422 source3/libgpo/gpext/gpext.c 	struct registry_key *key = NULL;
key               437 source3/libgpo/gpext/gpext.c 				   &key);
key               441 source3/libgpo/gpext/gpext.c 					   key,
key                40 source3/libgpo/gpext/registry.c 	UNISTR key;
key               146 source3/libgpo/gpext/registry.c 	if (!prs_unistr("key", ps, depth, &entry->key))
key               258 source3/libgpo/gpext/registry.c 	char *key = NULL;
key               269 source3/libgpo/gpext/registry.c 	if (strlen_w((const smb_ucs2_t *)file_entry->key.buffer) <= 0)
key               272 source3/libgpo/gpext/registry.c 	if (!pull_ucs2_talloc(mem_ctx, &key, file_entry->key.buffer,
key               329 source3/libgpo/gpext/registry.c 	entry->key = key;
key                77 source3/libgpo/gpext/scripts.c 					   const char *key,
key               106 source3/libgpo/gpext/scripts.c 	entry->key = key;
key               131 source3/libgpo/gpext/scripts.c 		const char *key = NULL;
key               139 source3/libgpo/gpext/scripts.c 		key = talloc_asprintf(ini_ctx->mem_ctx, "%s:%s%s",
key               142 source3/libgpo/gpext/scripts.c 		NT_STATUS_HAVE_NO_MEMORY(key);
key               144 source3/libgpo/gpext/scripts.c 		script = iniparser_getstring(ini_ctx->dict, key, NULL);
key               149 source3/libgpo/gpext/scripts.c 		key = talloc_asprintf(ini_ctx->mem_ctx, "%s:%s%s",
key               152 source3/libgpo/gpext/scripts.c 		NT_STATUS_HAVE_NO_MEMORY(key);
key               154 source3/libgpo/gpext/scripts.c 		parameters = iniparser_getstring(ini_ctx->dict, key, NULL);
key               218 source3/libgpo/gpext/scripts.c 					struct registry_key *key,
key               223 source3/libgpo/gpext/scripts.c 	if (!key || !gpo) {
key               227 source3/libgpo/gpext/scripts.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "DisplayName",
key               231 source3/libgpo/gpext/scripts.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "FileSysPath",
key               235 source3/libgpo/gpext/scripts.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "GPO-ID",
key               239 source3/libgpo/gpext/scripts.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "GPOName",
key               243 source3/libgpo/gpext/scripts.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "SOM-ID",
key               140 source3/libgpo/gpo_reg.c 			  struct registry_key **key)
key               144 source3/libgpo/gpo_reg.c 	if (!reg_ctx || !subkeyname || !key) {
key               152 source3/libgpo/gpo_reg.c 			     reg_ctx->token, key);
key               159 source3/libgpo/gpo_reg.c 			   struct registry_key *key,
key               174 source3/libgpo/gpo_reg.c 	return reg_setvalue(key, val_name, &reg_val);
key               181 source3/libgpo/gpo_reg.c 				     struct registry_key *key,
key               191 source3/libgpo/gpo_reg.c 	return reg_setvalue(key, val_name, &reg_val);
key               198 source3/libgpo/gpo_reg.c 			  struct registry_key *key,
key               205 source3/libgpo/gpo_reg.c 	werr = reg_queryvalue(mem_ctx, key, val_name, &reg_val);
key               222 source3/libgpo/gpo_reg.c 				    struct registry_key *key,
key               229 source3/libgpo/gpo_reg.c 	werr = reg_queryvalue(mem_ctx, key, val_name, &reg_val);
key               245 source3/libgpo/gpo_reg.c 				   struct registry_key *key,
key               250 source3/libgpo/gpo_reg.c 	if (!key || !gpo) {
key               254 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "Version",
key               258 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "WQLFilterPass",
key               262 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "AccessDenied",
key               266 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "GPO-Disabled",
key               270 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "Options",
key               274 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "GPOID",
key               278 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "SOM",
key               282 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "DisplayName",
key               286 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_sz(mem_ctx, key, "WQL-Id",
key               312 source3/libgpo/gpo_reg.c 					 struct registry_key *key,
key               322 source3/libgpo/gpo_reg.c 	return reg_deletekey_recursive(mem_ctx, key, path);
key               334 source3/libgpo/gpo_reg.c 	struct registry_key *key = NULL;
key               349 source3/libgpo/gpo_reg.c 				   reg_ctx->curr_key, &key);
key               359 source3/libgpo/gpo_reg.c 		werr = gp_store_reg_val_sz(mem_ctx, key, valname, val);
key               363 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_val_dword(mem_ctx, key, "Count", count);
key               379 source3/libgpo/gpo_reg.c 	struct registry_key *key = NULL;
key               395 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_subkey(mem_ctx, reg_ctx, path, &key);
key               398 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_dword(mem_ctx, key, "Count", &count);
key               406 source3/libgpo/gpo_reg.c 		werr = gp_read_reg_val_sz(mem_ctx, key, valname, &val);
key               440 source3/libgpo/gpo_reg.c 			       struct registry_key *key,
key               443 source3/libgpo/gpo_reg.c 	return reg_deletesubkeys_recursive(mem_ctx, key, path);
key               460 source3/libgpo/gpo_reg.c 	struct registry_key *key;
key               506 source3/libgpo/gpo_reg.c 				   reg_ctx->curr_key, &key);
key               528 source3/libgpo/gpo_reg.c 					   reg_ctx->curr_key, &key);
key               533 source3/libgpo/gpo_reg.c 		werr = gp_store_reg_gpovals(mem_ctx, key, gpo);
key               550 source3/libgpo/gpo_reg.c 				  struct registry_key *key,
key               555 source3/libgpo/gpo_reg.c 	if (!key || !gpo) {
key               559 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_dword(mem_ctx, key, "Version",
key               563 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_dword(mem_ctx, key, "Options",
key               567 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_sz(mem_ctx, key, "GPOID",
key               571 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_sz(mem_ctx, key, "SOM",
key               575 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_val_sz(mem_ctx, key, "DisplayName",
key               586 source3/libgpo/gpo_reg.c 			      struct registry_key *key,
key               592 source3/libgpo/gpo_reg.c 	if (!gpo_ret || !key) {
key               599 source3/libgpo/gpo_reg.c 	werr = gp_read_reg_gpovals(mem_ctx, key, gpo);
key               620 source3/libgpo/gpo_reg.c 	struct registry_key *key = NULL;
key               658 source3/libgpo/gpo_reg.c 		werr = gp_read_reg_subkey(mem_ctx, reg_ctx, subkeyname, &key);
key               670 source3/libgpo/gpo_reg.c 		werr = gp_read_reg_gpo(mem_ctx, key, &gpo);
key               757 source3/libgpo/gpo_reg.c 		     struct registry_key *key,
key               772 source3/libgpo/gpo_reg.c 	return reg_setkeysecurity(key, sd);
key               779 source3/libgpo/gpo_reg.c 		  const char *key, const char *subkey,
key               793 source3/libgpo/gpo_reg.c 		direction, key, subkey, type_str));
key               842 source3/libgpo/gpo_reg.c 		     entry->key,
key               883 source3/libgpo/gpo_reg.c 	(*entries)[*num].key = entry->key;
key               931 source3/libgpo/gpo_reg.c 	struct registry_key *key = NULL;
key               934 source3/libgpo/gpo_reg.c 		printf("about to store key:    [%s]\n", entry->key);
key               940 source3/libgpo/gpo_reg.c 	werr = gp_store_reg_subkey(mem_ctx, entry->key,
key               941 source3/libgpo/gpo_reg.c 				   root_key, &key);
key               955 source3/libgpo/gpo_reg.c 					     key,
key               965 source3/libgpo/gpo_reg.c 			werr = reg_setvalue(key, entry->value, entry->data);
key               975 source3/libgpo/gpo_reg.c 			werr = reg_deletevalue(key, entry->value);
key               985 source3/libgpo/gpo_reg.c 			werr = reg_deleteallvalues(key);
key               219 source3/libsmb/clikrb5.c 						  krb5_keyblock *key,
key               232 source3/libsmb/clikrb5.c 	ret = krb5_string_to_key(context, &eblock, key, password, &salt);
key               241 source3/libsmb/clikrb5.c 						  krb5_keyblock *key,
key               253 source3/libsmb/clikrb5.c 	ret = krb5_string_to_key_salt(context, enctype, (const char *)password->data, salt, key);
key               265 source3/libsmb/clikrb5.c 					krb5_keyblock *key,
key               277 source3/libsmb/clikrb5.c 		KRB5_KEY_DATA(key) = (KRB5_KEY_DATA_CAST *)SMB_MALLOC(password->length);
key               278 source3/libsmb/clikrb5.c 		if (!KRB5_KEY_DATA(key)) {
key               281 source3/libsmb/clikrb5.c 		memcpy(KRB5_KEY_DATA(key), password->data, password->length);
key               282 source3/libsmb/clikrb5.c 		KRB5_KEY_LENGTH(key) = password->length;
key               283 source3/libsmb/clikrb5.c 		KRB5_KEY_TYPE(key) = enctype;
key               287 source3/libsmb/clikrb5.c 	ret = create_kerberos_key_from_string_direct(context, salt_princ ? salt_princ : host_princ, password, key, enctype);
key               121 source3/libsmb/conncache.c static void delete_matches(const char *key, const char *value,
key               124 source3/libsmb/conncache.c 	gencache_del(key);
key               139 source3/libsmb/conncache.c 	char *key = NULL;
key               142 source3/libsmb/conncache.c 	key = negative_conn_cache_keystr(domain, server);
key               143 source3/libsmb/conncache.c 	if (key == NULL)
key               146 source3/libsmb/conncache.c 	if (gencache_get(key, &value, (time_t *) NULL))
key               151 source3/libsmb/conncache.c 	TALLOC_FREE(key);
key               164 source3/libsmb/conncache.c 	char *key = NULL;
key               166 source3/libsmb/conncache.c 	key = negative_conn_cache_keystr(domain, server);
key               167 source3/libsmb/conncache.c 	if (key == NULL)
key               170 source3/libsmb/conncache.c 	gencache_del(key);
key               174 source3/libsmb/conncache.c 	TALLOC_FREE(key);
key               189 source3/libsmb/conncache.c 	char *key = NULL;
key               194 source3/libsmb/conncache.c 	key = negative_conn_cache_keystr(domain, server);
key               195 source3/libsmb/conncache.c 	if (key == NULL) {
key               206 source3/libsmb/conncache.c 	if (gencache_set(key, value,
key               217 source3/libsmb/conncache.c 	TALLOC_FREE(key);
key               134 source3/libsmb/dsgetdcname.c 	char *key;
key               140 source3/libsmb/dsgetdcname.c 	key = dsgetdcname_cache_key(mem_ctx, domain_name);
key               141 source3/libsmb/dsgetdcname.c 	if (!key) {
key               145 source3/libsmb/dsgetdcname.c 	if (!gencache_del(key)) {
key               160 source3/libsmb/dsgetdcname.c 	char *key;
key               167 source3/libsmb/dsgetdcname.c 	key = dsgetdcname_cache_key(mem_ctx, domain_name);
key               168 source3/libsmb/dsgetdcname.c 	if (!key) {
key               174 source3/libsmb/dsgetdcname.c 	if (gencache_lock_entry(key) != 0) {
key               178 source3/libsmb/dsgetdcname.c 	ret = gencache_set_data_blob(key, blob, expire_time);
key               180 source3/libsmb/dsgetdcname.c 	gencache_unlock_entry(key);
key               359 source3/libsmb/dsgetdcname.c 	char *key;
key               370 source3/libsmb/dsgetdcname.c 	key = dsgetdcname_cache_key(mem_ctx, domain_name);
key               371 source3/libsmb/dsgetdcname.c 	if (!key) {
key               375 source3/libsmb/dsgetdcname.c 	if (!gencache_get_data_blob(key, &blob, expired)) {
key               101 source3/libsmb/namecache.c 	char *key, *value_string;
key               138 source3/libsmb/namecache.c 	key = namecache_key(name, name_type);
key               139 source3/libsmb/namecache.c 	if (!key) {
key               151 source3/libsmb/namecache.c 		SAFE_FREE(key);
key               157 source3/libsmb/namecache.c 	ret = gencache_set(key, value_string, expiry);
key               158 source3/libsmb/namecache.c 	SAFE_FREE(key);
key               181 source3/libsmb/namecache.c 	char *key, *value;
key               202 source3/libsmb/namecache.c 	key = namecache_key(name, name_type);
key               203 source3/libsmb/namecache.c 	if (!key) {
key               207 source3/libsmb/namecache.c 	if (!gencache_get(key, &value, &timeout)) {
key               209 source3/libsmb/namecache.c 		SAFE_FREE(key);
key               220 source3/libsmb/namecache.c 	SAFE_FREE(key);
key               234 source3/libsmb/namecache.c 	char *key;
key               243 source3/libsmb/namecache.c 	key = namecache_key(name, name_type);
key               244 source3/libsmb/namecache.c 	if (!key) {
key               247 source3/libsmb/namecache.c 	ret = gencache_del(key);
key               248 source3/libsmb/namecache.c 	SAFE_FREE(key);
key               258 source3/libsmb/namecache.c static void flush_netbios_name(const char *key,
key               263 source3/libsmb/namecache.c 	gencache_del(key);
key               264 source3/libsmb/namecache.c 	DEBUG(5, ("Deleting entry %s\n", key));
key               311 source3/libsmb/namecache.c 	char *key;
key               319 source3/libsmb/namecache.c 	key = namecache_status_record_key(keyname, keyname_type,
key               321 source3/libsmb/namecache.c 	if (!key)
key               325 source3/libsmb/namecache.c 	ret = gencache_set(key, srvname, expiry);
key               329 source3/libsmb/namecache.c 					key, srvname ));
key               332 source3/libsmb/namecache.c 					key ));
key               335 source3/libsmb/namecache.c 	SAFE_FREE(key);
key               347 source3/libsmb/namecache.c 	char *key = NULL;
key               354 source3/libsmb/namecache.c 	key = namecache_status_record_key(keyname, keyname_type,
key               356 source3/libsmb/namecache.c 	if (!key)
key               359 source3/libsmb/namecache.c 	if (!gencache_get(key, &value, &timeout)) {
key               361 source3/libsmb/namecache.c 					key));
key               362 source3/libsmb/namecache.c 		SAFE_FREE(key);
key               366 source3/libsmb/namecache.c 					key, value ));
key               370 source3/libsmb/namecache.c 	SAFE_FREE(key);
key                63 source3/libsmb/namequery.c 	char *key;
key                82 source3/libsmb/namequery.c 	key = saf_key( domain );
key                88 source3/libsmb/namequery.c 	ret = gencache_set( key, servername, expire );
key                90 source3/libsmb/namequery.c 	SAFE_FREE( key );
key                97 source3/libsmb/namequery.c 	char *key;
key               114 source3/libsmb/namequery.c 	key = saf_join_key( domain );
key               120 source3/libsmb/namequery.c 	ret = gencache_set( key, servername, expire );
key               122 source3/libsmb/namequery.c 	SAFE_FREE( key );
key               129 source3/libsmb/namequery.c 	char *key;
key               140 source3/libsmb/namequery.c 	key = saf_join_key(domain);
key               141 source3/libsmb/namequery.c 	ret = gencache_del(key);
key               142 source3/libsmb/namequery.c 	SAFE_FREE(key);
key               148 source3/libsmb/namequery.c 	key = saf_key(domain);
key               149 source3/libsmb/namequery.c 	ret = gencache_del(key);
key               150 source3/libsmb/namequery.c 	SAFE_FREE(key);
key               167 source3/libsmb/namequery.c 	char *key = NULL;
key               177 source3/libsmb/namequery.c 	key = saf_join_key( domain );
key               179 source3/libsmb/namequery.c 	ret = gencache_get( key, &server, &timeout );
key               181 source3/libsmb/namequery.c 	SAFE_FREE( key );
key               189 source3/libsmb/namequery.c 	key = saf_key( domain );
key               191 source3/libsmb/namequery.c 	ret = gencache_get( key, &server, &timeout );
key               193 source3/libsmb/namequery.c 	SAFE_FREE( key );
key               236 source3/libsmb/samlogon_cache.c 			tdb_delete( netsamlogon_tdb, key );
key               181 source3/libsmb/smbdes.c static void dohash(char *out, char *in, char *key, int forw)
key               193 source3/libsmb/smbdes.c 	permute(pk1, key, perm1, 56);
key               261 source3/libsmb/smbdes.c static void str_to_key(const unsigned char str[7], unsigned char key[8])
key               265 source3/libsmb/smbdes.c 	key[0] = str[0]>>1;
key               266 source3/libsmb/smbdes.c 	key[1] = ((str[0]&0x01)<<6) | (str[1]>>2);
key               267 source3/libsmb/smbdes.c 	key[2] = ((str[1]&0x03)<<5) | (str[2]>>3);
key               268 source3/libsmb/smbdes.c 	key[3] = ((str[2]&0x07)<<4) | (str[3]>>4);
key               269 source3/libsmb/smbdes.c 	key[4] = ((str[3]&0x0F)<<3) | (str[4]>>5);
key               270 source3/libsmb/smbdes.c 	key[5] = ((str[4]&0x1F)<<2) | (str[5]>>6);
key               271 source3/libsmb/smbdes.c 	key[6] = ((str[5]&0x3F)<<1) | (str[6]>>7);
key               272 source3/libsmb/smbdes.c 	key[7] = str[6]&0x7F;
key               274 source3/libsmb/smbdes.c 		key[i] = (key[i]<<1);
key               279 source3/libsmb/smbdes.c void des_crypt56(unsigned char *out, const unsigned char *in, const unsigned char *key, int forw)
key               287 source3/libsmb/smbdes.c 	str_to_key(key, key2);
key               334 source3/libsmb/smbdes.c void des_crypt128(unsigned char out[8], const unsigned char in[8], const unsigned char key[16])
key               338 source3/libsmb/smbdes.c 	des_crypt56(buf, in, key, 1);
key               339 source3/libsmb/smbdes.c 	des_crypt56(out, buf, key+9, 1);
key               343 source3/libsmb/smbdes.c void des_crypt64(unsigned char out[8], const unsigned char in[8], const unsigned char key[8])
key               349 source3/libsmb/smbdes.c 	des_crypt56(buf, in, key, 1);
key               350 source3/libsmb/smbdes.c 	key2[0] = key[7];
key               358 source3/libsmb/smbdes.c void des_crypt112(unsigned char out[8], const unsigned char in[8], const unsigned char key[14], int forw)
key               361 source3/libsmb/smbdes.c 	des_crypt56(buf, in, key, forw);
key               362 source3/libsmb/smbdes.c 	des_crypt56(out, buf, key+7, forw);
key               365 source3/libsmb/smbdes.c void cred_hash3(unsigned char *out, const unsigned char *in, const unsigned char *key, int forw)
key               370 source3/libsmb/smbdes.c         des_crypt56(out, in, key, forw);
key               371 source3/libsmb/smbdes.c         key2[0] = key[7];
key               379 source3/libsmb/smbdes.c void des_crypt112_16(unsigned char out[16], unsigned char in[16], const unsigned char key[14], int forw)
key               381 source3/libsmb/smbdes.c 	des_crypt56(out, in, key, forw);
key               382 source3/libsmb/smbdes.c 	des_crypt56(out + 8, in + 8, key+7, forw);
key               389 source3/libsmb/smbdes.c void SamOEMhash( unsigned char *data, const unsigned char key[16], size_t len)
key               392 source3/libsmb/smbdes.c 	const DATA_BLOB keyblob = data_blob_const(key, 16);
key               398 source3/libsmb/smbdes.c void SamOEMhashBlob( unsigned char *data, size_t len, DATA_BLOB *key)
key               402 source3/libsmb/smbdes.c 	arcfour_init(&arc4_state, key);
key               617 source3/libsmb/smbencrypt.c 		uint8 bin[8], bout[8], key[7];
key               625 source3/libsmb/smbencrypt.c 		memcpy(key, &session_key->data[k], 7);
key               627 source3/libsmb/smbencrypt.c 		des_crypt56(bout, bin, key, forward?1:0);
key               114 source3/libsmb/trustdom_cache.c 	char *key, *alt_key;
key               128 source3/libsmb/trustdom_cache.c 	key = trustdom_cache_key(name);
key               140 source3/libsmb/trustdom_cache.c 			ret = gencache_set(key, sid_string, timeout);
key               143 source3/libsmb/trustdom_cache.c 		SAFE_FREE(key);
key               147 source3/libsmb/trustdom_cache.c 	ret = gencache_set(key, sid_string, timeout);
key               148 source3/libsmb/trustdom_cache.c 	SAFE_FREE(key);
key               166 source3/libsmb/trustdom_cache.c 	char *key = NULL, *value = NULL;
key               178 source3/libsmb/trustdom_cache.c 	key = trustdom_cache_key(name);
key               179 source3/libsmb/trustdom_cache.c 	if (!key)
key               182 source3/libsmb/trustdom_cache.c 	if (!gencache_get(key, &value, &timeout)) {
key               184 source3/libsmb/trustdom_cache.c 		SAFE_FREE(key);
key               187 source3/libsmb/trustdom_cache.c 		SAFE_FREE(key);
key               258 source3/libsmb/trustdom_cache.c static void flush_trustdom_name(const char* key, const char *value, time_t timeout, void* dptr)
key               260 source3/libsmb/trustdom_cache.c 	gencache_del(key);
key               261 source3/libsmb/trustdom_cache.c 	DEBUG(5, ("Deleting entry %s\n", key));
key                42 source3/libsmb/unexpected.c 	struct unexpected_key key;
key                66 source3/libsmb/unexpected.c 	ZERO_STRUCT(key);	/* needed for potential alignment */
key                68 source3/libsmb/unexpected.c 	key.packet_type = p->packet_type;
key                69 source3/libsmb/unexpected.c 	key.timestamp = p->timestamp;
key                70 source3/libsmb/unexpected.c 	key.count = count++;
key                72 source3/libsmb/unexpected.c 	kbuf.dptr = (uint8_t *)&key;
key                73 source3/libsmb/unexpected.c 	kbuf.dsize = sizeof(key);
key                89 source3/libsmb/unexpected.c 	struct unexpected_key key;
key                91 source3/libsmb/unexpected.c 	if (kbuf.dsize != sizeof(key)) {
key                95 source3/libsmb/unexpected.c 	memcpy(&key, kbuf.dptr, sizeof(key));
key                97 source3/libsmb/unexpected.c 	if (lastt - key.timestamp > NMBD_UNEXPECTED_TIMEOUT) {
key               137 source3/libsmb/unexpected.c 	struct unexpected_key key;
key               143 source3/libsmb/unexpected.c 	if (kbuf.dsize != sizeof(key)) {
key               147 source3/libsmb/unexpected.c 	memcpy(&key, kbuf.dptr, sizeof(key));
key               149 source3/libsmb/unexpected.c 	if (key.packet_type != state->match_type) return 0;
key              1633 source3/locking/brlock.c 	struct file_id *key;
key              1647 source3/locking/brlock.c 	key = (struct file_id *)rec->key.dptr;
key              1670 source3/locking/brlock.c 			cb->fn(*key,
key              1760 source3/locking/brlock.c 	TDB_DATA key, data;
key              1770 source3/locking/brlock.c 	memset(&br_lck->key, '\0', sizeof(struct file_id));
key              1771 source3/locking/brlock.c 	br_lck->key = fsp->file_id;
key              1773 source3/locking/brlock.c 	key.dptr = (uint8 *)&br_lck->key;
key              1774 source3/locking/brlock.c 	key.dsize = sizeof(struct file_id);
key              1783 source3/locking/brlock.c 		if (brlock_db->fetch(brlock_db, br_lck, key, &data) == -1) {
key              1791 source3/locking/brlock.c 		br_lck->record = brlock_db->fetch_locked(brlock_db, br_lck, key);
key               843 source3/locking/locking.c 	TDB_DATA key = locking_key(&id, &tmp);
key               850 source3/locking/locking.c 	if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
key               875 source3/locking/locking.c 	TDB_DATA key = locking_key(&id, &tmp);
key               883 source3/locking/locking.c 	if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
key              1483 source3/locking/locking.c 	if (rec->key.dsize != sizeof(struct file_id))
key              1097 source3/modules/vfs_default.c 	struct file_id key;
key              1101 source3/modules/vfs_default.c 	ZERO_STRUCT(key);
key              1103 source3/modules/vfs_default.c 	key.devid = sbuf->st_dev;
key              1104 source3/modules/vfs_default.c 	key.inode = sbuf->st_ino;
key              1107 source3/modules/vfs_default.c 	return key;
key               112 source3/modules/vfs_onefs.c 	struct file_id key;
key               116 source3/modules/vfs_onefs.c 	ZERO_STRUCT(key);
key               118 source3/modules/vfs_onefs.c 	key.devid = sbuf->st_dev;
key               119 source3/modules/vfs_onefs.c 	key.inode = sbuf->st_ino;
key               120 source3/modules/vfs_onefs.c 	key.extid = sbuf->st_snapid;
key               122 source3/modules/vfs_onefs.c 	return key;
key                37 source3/modules/vfs_streams_depot.c static uint32_t hash_fn(DATA_BLOB key)
key                43 source3/modules/vfs_streams_depot.c 	for (value = 0x238F13AF * key.length, i=0; i < key.length; i++)
key                44 source3/modules/vfs_streams_depot.c 		value = (value + (key.data[i] << (i*5 % 24)));
key                58 source3/nmbd/nmbd_winsserver.c static struct name_record *wins_record_to_name_record(TDB_DATA key, TDB_DATA data)
key               105 source3/nmbd/nmbd_winsserver.c 	push_ascii_nstring(namerec->name.name, (const char *)key.dptr);
key               106 source3/nmbd/nmbd_winsserver.c 	namerec->name.name_type = key.dptr[sizeof(unstring)];
key               192 source3/nmbd/nmbd_winsserver.c 	TDB_DATA key;
key               199 source3/nmbd/nmbd_winsserver.c 	key.dptr = (uint8 *)keydata;
key               200 source3/nmbd/nmbd_winsserver.c 	key.dsize = sizeof(keydata);
key               202 source3/nmbd/nmbd_winsserver.c 	return key;
key               212 source3/nmbd/nmbd_winsserver.c 	TDB_DATA data, key;
key               220 source3/nmbd/nmbd_winsserver.c 	key = name_to_key(nmbname);
key               221 source3/nmbd/nmbd_winsserver.c 	data = tdb_fetch(wins_tdb, key);
key               227 source3/nmbd/nmbd_winsserver.c 	namerec = wins_record_to_name_record(key, data);
key               267 source3/nmbd/nmbd_winsserver.c 	TDB_DATA key, data;
key               274 source3/nmbd/nmbd_winsserver.c 	key = name_to_key(&namerec->name);
key               281 source3/nmbd/nmbd_winsserver.c 	ret = tdb_store(wins_tdb, key, data, tdb_flag);
key               312 source3/nmbd/nmbd_winsserver.c 	TDB_DATA key;
key               319 source3/nmbd/nmbd_winsserver.c 	key = name_to_key(&namerec->name);
key               320 source3/nmbd/nmbd_winsserver.c 	ret = tdb_delete(wins_tdb, key);
key               105 source3/param/loadparm.c 	char *key;
key              5660 source3/param/loadparm.c 		if (strwicmp(data->key, param_key) == 0) {
key              5672 source3/param/loadparm.c 		        if (strwicmp(data->key, param_key) == 0) {
key              5903 source3/param/loadparm.c 		string_free(&opt->key);
key              6632 source3/param/loadparm.c 		if (strwicmp(opt->key, opt_name) == 0) {
key              6643 source3/param/loadparm.c 	    new_opt->key = SMB_STRDUP(opt_name);
key              6713 source3/param/loadparm.c 		set_param_opt(&pserviceDest->param_opt, data->key, data->value);
key              7800 source3/param/loadparm.c 			fprintf(f, "\t%s = %s\n", data->key, data->value);
key              7865 source3/param/loadparm.c 				fprintf(f, "\t%s = %s\n", data->key, data->value);
key                95 source3/passdb/pdb_ldap.c static const char* get_userattr_key2string( int schema_ver, int key )
key                99 source3/passdb/pdb_ldap.c 			return get_attr_key2string( attrib_map_v22, key );
key               102 source3/passdb/pdb_ldap.c 			return get_attr_key2string( attrib_map_v30, key );
key                70 source3/passdb/pdb_tdb.c 	if (rec->key.dsize < USERPREFIX_LEN) {
key                73 source3/passdb/pdb_tdb.c 	if (strncmp((char *)rec->key.dptr, USERPREFIX, USERPREFIX_LEN) != 0) {
key                85 source3/passdb/pdb_tdb.c 		  "(version:%d)\n", rec->key.dptr, state->from));
key               119 source3/passdb/pdb_tdb.c 			 "from TDB (key:%s) (version:%d)\n", rec->key.dptr,
key               162 source3/passdb/pdb_tdb.c 	new_rec = bs->new_db->fetch_locked(bs->new_db, talloc_tos(), orig_rec->key);
key              1114 source3/passdb/pdb_tdb.c 	if ((rec->key.dsize < prefixlen)
key              1115 source3/passdb/pdb_tdb.c 	    || (strncmp((char *)rec->key.dptr, RIDPREFIX, prefixlen))) {
key              1119 source3/passdb/pdb_tdb.c 	rid = strtoul((char *)rec->key.dptr+prefixlen, NULL, 16);
key               112 source3/passdb/secrets.c void *secrets_fetch(const char *key, size_t *size)
key               121 source3/passdb/secrets.c 	if (db_ctx->fetch(db_ctx, talloc_tos(), string_tdb_data(key),
key               141 source3/passdb/secrets.c bool secrets_store(const char *key, const void *data, size_t size)
key               149 source3/passdb/secrets.c 	status = dbwrap_trans_store(db_ctx, string_tdb_data(key),
key               158 source3/passdb/secrets.c bool secrets_delete(const char *key)
key               165 source3/passdb/secrets.c 	status = dbwrap_trans_delete(db_ctx, string_tdb_data(key));
key               221 source3/passdb/secrets.c 	fstring key;
key               223 source3/passdb/secrets.c 	slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_GUID, domain);
key               224 source3/passdb/secrets.c 	strupper_m(key);
key               225 source3/passdb/secrets.c 	return secrets_store(key, guid, sizeof(struct GUID));
key               231 source3/passdb/secrets.c 	fstring key;
key               235 source3/passdb/secrets.c 	slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_GUID, domain);
key               236 source3/passdb/secrets.c 	strupper_m(key);
key               237 source3/passdb/secrets.c 	dyn_guid = (struct GUID *)secrets_fetch(key, &size);
key               244 source3/passdb/secrets.c 			dyn_guid = (struct GUID *)secrets_fetch(key, &size);
key               270 source3/passdb/secrets.c 	uint8_t *key;
key               272 source3/passdb/secrets.c 	key = (uint8_t *)secrets_fetch(SECRETS_LOCAL_SCHANNEL_KEY, &size);
key               273 source3/passdb/secrets.c 	if (key == NULL) {
key               278 source3/passdb/secrets.c 		SAFE_FREE(key);
key               282 source3/passdb/secrets.c 	memcpy(schannel_key, key, 16);
key               283 source3/passdb/secrets.c 	SAFE_FREE(key);
key               864 source3/passdb/secrets.c 	char *key = NULL;
key               867 source3/passdb/secrets.c 	if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, dn) < 0) {
key               872 source3/passdb/secrets.c 	ret = secrets_store(key, pw, strlen(pw)+1);
key               874 source3/passdb/secrets.c 	SAFE_FREE(key);
key               884 source3/passdb/secrets.c 	char *key = NULL;
key               889 source3/passdb/secrets.c 	if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, *dn) < 0) {
key               894 source3/passdb/secrets.c 	*pw=(char *)secrets_fetch(key, &size);
key               895 source3/passdb/secrets.c 	SAFE_FREE(key);
key               964 source3/passdb/secrets.c 	if ((rec->key.dsize < prefix_len)
key               965 source3/passdb/secrets.c 	    || (strncmp((char *)rec->key.dptr, SECRETS_DOMTRUST_ACCT_PASS,
key              1046 source3/passdb/secrets.c 	fstring key;
key              1054 source3/passdb/secrets.c 	slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_AFS_KEYFILE, cell);
key              1055 source3/passdb/secrets.c 	return secrets_store(key, keyfile, sizeof(struct afs_keyfile));
key              1063 source3/passdb/secrets.c 	fstring key;
key              1068 source3/passdb/secrets.c 	slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_AFS_KEYFILE, cell);
key              1070 source3/passdb/secrets.c 	keyfile = (struct afs_keyfile *)secrets_fetch(key, &size);
key              1351 source3/passdb/secrets.c bool secrets_store_generic(const char *owner, const char *key, const char *secret)
key              1356 source3/passdb/secrets.c 	if (asprintf(&tdbkey, "SECRETS/GENERIC/%s/%s", owner, key) < 0) {
key              1371 source3/passdb/secrets.c char *secrets_fetch_generic(const char *owner, const char *key)
key              1376 source3/passdb/secrets.c 	if (( ! owner) || ( ! key)) {
key              1381 source3/passdb/secrets.c 	if (asprintf(&tdbkey, "SECRETS/GENERIC/%s/%s", owner, key) < 0) {
key               228 source3/printing/nt_printing.c 	TDB_DATA key;
key               234 source3/printing/nt_printing.c 	key = string_term_tdb_data(keystr ? keystr : "");
key               236 source3/printing/nt_printing.c 	return key;
key               248 source3/printing/nt_printing.c 	TDB_DATA key;
key               254 source3/printing/nt_printing.c 	key = string_term_tdb_data(keystr ? keystr : "");
key               256 source3/printing/nt_printing.c 	return key;
key               329 source3/printing/nt_printing.c static int sec_desc_upg_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
key               345 source3/printing/nt_printing.c 	if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) {
key               355 source3/printing/nt_printing.c 			(const char *)key.dptr ));
key               356 source3/printing/nt_printing.c 		tdb_delete( tdb_printers, key );
key               406 source3/printing/nt_printing.c 		DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr ));
key               417 source3/printing/nt_printing.c 		DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr ));
key               421 source3/printing/nt_printing.c 	result = tdb_store( tdb_printers, key, data, TDB_REPLACE );
key               456 source3/printing/nt_printing.c static int normalize_printers_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
key               467 source3/printing/nt_printing.c 	if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) {
key               468 source3/printing/nt_printing.c 		new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) );
key               470 source3/printing/nt_printing.c 	else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) {
key               471 source3/printing/nt_printing.c 		new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) );
key               480 source3/printing/nt_printing.c 	if ( tdb_delete( the_tdb, key ) != 0 ) {
key               482 source3/printing/nt_printing.c 			key.dptr));
key               488 source3/printing/nt_printing.c 			key.dptr));
key               662 source3/printing/nt_printing.c static int traverse_counting_printers(TDB_CONTEXT *t, TDB_DATA key,
key               667 source3/printing/nt_printing.c 	if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
key               669 source3/printing/nt_printing.c 		DEBUG(10,("traverse_counting_printers: printer = [%s]  printer_count = %d\n", key.dptr, *printer_count));
key               810 source3/printing/nt_printing.c 	char *key = NULL;
key               832 source3/printing/nt_printing.c 		key = talloc_asprintf(ctx, "%s%s", FORMS_PREFIX, (*list)[i].name);
key               833 source3/printing/nt_printing.c 		if (!key) {
key               838 source3/printing/nt_printing.c 		if (tdb_store_bystring(tdb_forms, key, dbuf, TDB_REPLACE) != 0) {
key               839 source3/printing/nt_printing.c 			TALLOC_FREE(key);
key               843 source3/printing/nt_printing.c 		TALLOC_FREE(key);
key               902 source3/printing/nt_printing.c 	char *key = NULL;
key               920 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s", FORMS_PREFIX, (*list)[n].name) < 0) {
key               924 source3/printing/nt_printing.c 	if (tdb_delete_bystring(tdb_forms, key) != 0) {
key               925 source3/printing/nt_printing.c 		SAFE_FREE(key);
key               929 source3/printing/nt_printing.c 	SAFE_FREE(key);
key               967 source3/printing/nt_printing.c 	char *key = NULL;
key               975 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s/%d/", DRIVERS_PREFIX,
key               984 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, key, strlen(key)) != 0)
key               989 source3/printing/nt_printing.c 			SAFE_FREE(key);
key               993 source3/printing/nt_printing.c 		fstrcpy((*list)[total], (const char *)kbuf.dptr+strlen(key));
key               997 source3/printing/nt_printing.c 	SAFE_FREE(key);
key              2057 source3/printing/nt_printing.c 	char *key = NULL;
key              2111 source3/printing/nt_printing.c 	key = talloc_asprintf(ctx, "%s%s/%d/%s", DRIVERS_PREFIX,
key              2113 source3/printing/nt_printing.c 	if (!key) {
key              2117 source3/printing/nt_printing.c 	DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
key              2156 source3/printing/nt_printing.c 	ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
key              2160 source3/printing/nt_printing.c 		DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
key              2230 source3/printing/nt_printing.c 	char *key = NULL;
key              2246 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
key              2251 source3/printing/nt_printing.c 	dbuf = tdb_fetch_bystring(tdb_drivers, key);
key              2253 source3/printing/nt_printing.c 		SAFE_FREE(key);
key              2285 source3/printing/nt_printing.c 	SAFE_FREE(key);
key              2888 source3/printing/nt_printing.c int get_printer_subkeys( NT_PRINTER_DATA *data, const char* key, fstring **subkeys )
key              2902 source3/printing/nt_printing.c 	if ( !key )
key              2907 source3/printing/nt_printing.c 	if ( strlen(key) == 0 ) {
key              2929 source3/printing/nt_printing.c 		if ( StrnCaseCmp(data->keys[i].name, key, strlen(key)) == 0 ) {
key              2932 source3/printing/nt_printing.c 			key_len = strlen( key );
key              3486 source3/printing/nt_printing.c WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key )
key              3496 source3/printing/nt_printing.c 	if ( !key )
key              3501 source3/printing/nt_printing.c 	if ( !strlen(key) ) {
key              3516 source3/printing/nt_printing.c 		if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 ) {
key              3573 source3/printing/nt_printing.c WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
key              3580 source3/printing/nt_printing.c 	if ( !key || !*key|| !value || !*value )
key              3585 source3/printing/nt_printing.c 	key_index = lookup_printerkey( p2->data, key );
key              3597 source3/printing/nt_printing.c 		key, value ));
key              3605 source3/printing/nt_printing.c WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value,
key              3613 source3/printing/nt_printing.c 	if ( !key || !*key|| !value || !*value )
key              3618 source3/printing/nt_printing.c 	key_index = lookup_printerkey( p2->data, key );
key              3620 source3/printing/nt_printing.c 		key_index = add_new_printer_key( p2->data, key );
key              3629 source3/printing/nt_printing.c 		key, value, type, real_len  ));
key              3637 source3/printing/nt_printing.c REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
key              3641 source3/printing/nt_printing.c 	if ( (key_index = lookup_printerkey( p2->data, key )) == -1 )
key              3645 source3/printing/nt_printing.c 		key, value ));
key              4248 source3/printing/nt_printing.c 	char *key = NULL;
key              4264 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX,
key              4269 source3/printing/nt_printing.c 	dbuf = tdb_fetch_bystring(tdb_drivers, key);
key              4276 source3/printing/nt_printing.c 		SAFE_FREE(key);
key              4280 source3/printing/nt_printing.c 	SAFE_FREE(key);
key              4362 source3/printing/nt_printing.c 	char *key;
key              4370 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, drivername) < 0) {
key              4377 source3/printing/nt_printing.c 	ret = (tdb_delete_bystring(tdb_drivers, key) == 0);
key              4378 source3/printing/nt_printing.c 	SAFE_FREE(key);
key              4392 source3/printing/nt_printing.c 	char *key = NULL;
key              4423 source3/printing/nt_printing.c 	SAFE_FREE(key);
key              4424 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, info->drivername) < 0) {
key              4432 source3/printing/nt_printing.c 	ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
key              5232 source3/printing/nt_printing.c 	char *key = NULL;
key              5243 source3/printing/nt_printing.c 	if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
key              5249 source3/printing/nt_printing.c 		key, delete_files ? "TRUE" : "FALSE" ));
key              5256 source3/printing/nt_printing.c 	dbuf = tdb_fetch_bystring( tdb_drivers, key );
key              5258 source3/printing/nt_printing.c 		DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key));
key              5259 source3/printing/nt_printing.c 		SAFE_FREE(key);
key              5267 source3/printing/nt_printing.c 	if (tdb_delete_bystring(tdb_drivers, key) == -1) {
key              5268 source3/printing/nt_printing.c 		DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key));
key              5269 source3/printing/nt_printing.c 		SAFE_FREE(key);
key              5282 source3/printing/nt_printing.c 	DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key));
key              5283 source3/printing/nt_printing.c 	SAFE_FREE(key);
key                60 source3/printing/printing.c 	TDB_DATA data, key;
key                76 source3/printing/printing.c 	key.dptr = (uint8 *)&jinfo;
key                77 source3/printing/printing.c 	key.dsize = sizeof(jinfo);
key                79 source3/printing/printing.c 	data = tdb_fetch(rap_tdb, key);
key                95 source3/printing/printing.c 	tdb_store(rap_tdb, key, data, TDB_REPLACE);
key                96 source3/printing/printing.c 	tdb_store(rap_tdb, data, key, TDB_REPLACE);
key               105 source3/printing/printing.c 	TDB_DATA data, key;
key               114 source3/printing/printing.c 	key.dptr = buf;
key               115 source3/printing/printing.c 	key.dsize = sizeof(rap_jobid);
key               116 source3/printing/printing.c 	data = tdb_fetch(rap_tdb, key);
key               138 source3/printing/printing.c 	TDB_DATA key, data;
key               151 source3/printing/printing.c 	key.dptr = (uint8 *)&jinfo;
key               152 source3/printing/printing.c 	key.dsize = sizeof(jinfo);
key               154 source3/printing/printing.c 	data = tdb_fetch(rap_tdb, key);
key               170 source3/printing/printing.c 	tdb_delete(rap_tdb, key);
key               381 source3/printing/printing.c static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
key               392 source3/printing/printing.c 	if (key.dsize != sizeof(uint32))
key               396 source3/printing/printing.c 		uint32 jobid = IVAL(key.dptr,0);
key               717 source3/printing/printing.c static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
key               724 source3/printing/printing.c 	if (  key.dsize != sizeof(jobid) )
key               727 source3/printing/printing.c 	jobid = IVAL(key.dptr, 0);
key               852 source3/printing/printing.c 	fstring key;
key               857 source3/printing/printing.c 	slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
key               858 source3/printing/printing.c 	tdb_store_int32(pdb->tdb, key, -1);
key               869 source3/printing/printing.c 	TDB_DATA data, key;
key               876 source3/printing/printing.c     	key = string_tdb_data(keystr);
key               878 source3/printing/printing.c 	data = tdb_fetch(pdb->tdb, key);
key               902 source3/printing/printing.c 	TDB_DATA key;
key               913 source3/printing/printing.c     	key = string_tdb_data(keystr);
key               920 source3/printing/printing.c 		tdb_delete(pdb->tdb, key);
key               929 source3/printing/printing.c 	tdb_store(pdb->tdb, key, data, TDB_REPLACE);
key              1054 source3/printing/printing.c 	fstring key;
key              1062 source3/printing/printing.c 	snprintf(key, sizeof(key), "CACHE/%s", sharename);
key              1063 source3/printing/printing.c 	last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
key              1092 source3/printing/printing.c 		snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
key              1095 source3/printing/printing.c 			&& tdb_fetch_uint32( pdb->tdb, key, &u )
key              1127 source3/printing/printing.c 	TDB_DATA data, key;
key              1240 source3/printing/printing.c 	key = string_tdb_data(keystr);
key              1245 source3/printing/printing.c 	tdb_store(pdb->tdb, key, data, TDB_REPLACE);
key              1485 source3/printing/printing.c 	fstring key;
key              1589 source3/printing/printing.c 	snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
key              1591 source3/printing/printing.c 	if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
key              1888 source3/printing/printing.c 	TDB_DATA data, key;
key              1899 source3/printing/printing.c 	key = string_tdb_data("INFO/jobs_changed");
key              1901 source3/printing/printing.c 	if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
key              1906 source3/printing/printing.c 	data = tdb_fetch(pdb->tdb, key);
key              1920 source3/printing/printing.c 			if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
key              1930 source3/printing/printing.c 		tdb_chainunlock(pdb->tdb, key);
key              2749 source3/printing/printing.c 	TDB_DATA data, key;
key              2777 source3/printing/printing.c 	key = string_tdb_data(keystr);
key              2779 source3/printing/printing.c 	data = tdb_fetch(pdb->tdb, key);
key                76 source3/registry/reg_api.c static WERROR fill_value_cache(struct registry_key *key)
key                78 source3/registry/reg_api.c 	if (key->values != NULL) {
key                79 source3/registry/reg_api.c 		if (!reg_values_need_update(key->key, key->values)) {
key                84 source3/registry/reg_api.c 	if (!(key->values = TALLOC_ZERO_P(key, REGVAL_CTR))) {
key                87 source3/registry/reg_api.c 	if (fetch_reg_values(key->key, key->values) == -1) {
key                88 source3/registry/reg_api.c 		TALLOC_FREE(key->values);
key                95 source3/registry/reg_api.c static WERROR fill_subkey_cache(struct registry_key *key)
key                99 source3/registry/reg_api.c 	if (key->subkeys != NULL) {
key               100 source3/registry/reg_api.c 		if (!reg_subkeys_need_update(key->key, key->subkeys)) {
key               105 source3/registry/reg_api.c 	werr = regsubkey_ctr_init(key, &(key->subkeys));
key               108 source3/registry/reg_api.c 	if (fetch_reg_keys(key->key, key->subkeys) == -1) {
key               109 source3/registry/reg_api.c 		TALLOC_FREE(key->subkeys);
key               116 source3/registry/reg_api.c static int regkey_destructor(REGISTRY_KEY *key)
key               130 source3/registry/reg_api.c 	REGISTRY_KEY *key;
key               139 source3/registry/reg_api.c 	    !(regkey->key = TALLOC_ZERO_P(regkey, REGISTRY_KEY))) {
key               148 source3/registry/reg_api.c 	key = regkey->key;
key               149 source3/registry/reg_api.c 	talloc_set_destructor(key, regkey_destructor);
key               153 source3/registry/reg_api.c 	key->type = REG_KEY_GENERIC;
key               163 source3/registry/reg_api.c 		key->name = talloc_strdup(key, parent->key->name);
key               169 source3/registry/reg_api.c 		key->name = talloc_asprintf(key, "%s%s%s",
key               170 source3/registry/reg_api.c 					    parent ? parent->key->name : "",
key               175 source3/registry/reg_api.c 	if (key->name == NULL) {
key               182 source3/registry/reg_api.c 	if( StrnCaseCmp(key->name, KEY_HKPD, strlen(KEY_HKPD)) == 0 )
key               183 source3/registry/reg_api.c 		key->type = REG_KEY_HKPD;
key               187 source3/registry/reg_api.c 	if ( !(key->ops = reghook_cache_find( key->name )) ) {
key               189 source3/registry/reg_api.c 			 "REGISTRY_OPS to [%s]\n", key->name ));
key               197 source3/registry/reg_api.c 	result = regsubkey_ctr_init(key, &subkeys);
key               202 source3/registry/reg_api.c 	if ( fetch_reg_keys( key, subkeys ) == -1 )  {
key               209 source3/registry/reg_api.c 	if ( !regkey_access_check( key, access_desired, &key->access_granted,
key               299 source3/registry/reg_api.c WERROR reg_enumkey(TALLOC_CTX *mem_ctx, struct registry_key *key,
key               304 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_ENUMERATE_SUB_KEYS)) {
key               308 source3/registry/reg_api.c 	if (!W_ERROR_IS_OK(err = fill_subkey_cache(key))) {
key               312 source3/registry/reg_api.c 	if (idx >= regsubkey_ctr_numkeys(key->subkeys)) {
key               317 source3/registry/reg_api.c 			regsubkey_ctr_specific_key(key->subkeys, idx))))
key               329 source3/registry/reg_api.c WERROR reg_enumvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
key               335 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
key               339 source3/registry/reg_api.c 	if (!(W_ERROR_IS_OK(err = fill_value_cache(key)))) {
key               343 source3/registry/reg_api.c 	if (idx >= key->values->num_values) {
key               348 source3/registry/reg_api.c 				  key->values->values[idx]->type,
key               349 source3/registry/reg_api.c 				  key->values->values[idx]->data_p,
key               350 source3/registry/reg_api.c 				  key->values->values[idx]->size,
key               351 source3/registry/reg_api.c 				  key->values->values[idx]->size);
key               358 source3/registry/reg_api.c 			 mem_ctx, key->values->values[idx]->valuename))) {
key               367 source3/registry/reg_api.c WERROR reg_queryvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
key               373 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
key               377 source3/registry/reg_api.c 	if (!(W_ERROR_IS_OK(err = fill_value_cache(key)))) {
key               381 source3/registry/reg_api.c 	for (i=0; i<key->values->num_values; i++) {
key               382 source3/registry/reg_api.c 		if (strequal(key->values->values[i]->valuename, name)) {
key               383 source3/registry/reg_api.c 			return reg_enumvalue(mem_ctx, key, i, NULL, pval);
key               390 source3/registry/reg_api.c WERROR reg_queryinfokey(struct registry_key *key, uint32_t *num_subkeys,
key               402 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
key               406 source3/registry/reg_api.c 	if (!W_ERROR_IS_OK(fill_subkey_cache(key)) ||
key               407 source3/registry/reg_api.c 	    !W_ERROR_IS_OK(fill_value_cache(key))) {
key               412 source3/registry/reg_api.c 	for (i=0; i< regsubkey_ctr_numkeys(key->subkeys); i++) {
key               414 source3/registry/reg_api.c 			strlen(regsubkey_ctr_specific_key(key->subkeys, i)));
key               417 source3/registry/reg_api.c 	*num_subkeys = regsubkey_ctr_numkeys(key->subkeys);
key               423 source3/registry/reg_api.c 	for (i=0; i<key->values->num_values; i++) {
key               425 source3/registry/reg_api.c 			      strlen(key->values->values[i]->valuename));
key               426 source3/registry/reg_api.c 		max_size = MAX(max_size, key->values->values[i]->size);
key               429 source3/registry/reg_api.c 	*num_values = key->values->num_values;
key               433 source3/registry/reg_api.c 	if (!(mem_ctx = talloc_new(key))) {
key               437 source3/registry/reg_api.c 	err = regkey_get_secdesc(mem_ctx, key->key, &secdesc);
key               456 source3/registry/reg_api.c 	struct registry_key *key = parent;
key               485 source3/registry/reg_api.c 		err = reg_createkey(mem_ctx, key, path,
key               491 source3/registry/reg_api.c 		if (key != parent) {
key               492 source3/registry/reg_api.c 			TALLOC_FREE(key);
key               495 source3/registry/reg_api.c 		key = tmp;
key               504 source3/registry/reg_api.c 	err = reg_openkey(ctx, key, path, desired_access, pkey);
key               524 source3/registry/reg_api.c 	err = reg_openkey(mem_ctx, key, "", KEY_CREATE_SUB_KEY,
key               537 source3/registry/reg_api.c 	err = create_reg_subkey(key->key, path);
key               558 source3/registry/reg_api.c 	struct registry_key *tmp_key, *key;
key               568 source3/registry/reg_api.c 	err = reg_openkey(mem_ctx, parent, name, REG_KEY_READ, &key);
key               571 source3/registry/reg_api.c 	err = fill_subkey_cache(key);
key               574 source3/registry/reg_api.c 	if (regsubkey_ctr_numkeys(key->subkeys) > 0) {
key               597 source3/registry/reg_api.c 	err = delete_reg_subkey(parent->key, name);
key               604 source3/registry/reg_api.c WERROR reg_setvalue(struct registry_key *key, const char *name,
key               611 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_SET_VALUE)) {
key               615 source3/registry/reg_api.c 	if (!W_ERROR_IS_OK(err = fill_value_cache(key))) {
key               619 source3/registry/reg_api.c 	err = registry_push_value(key, val, &value_data);
key               624 source3/registry/reg_api.c 	res = regval_ctr_addvalue(key->values, name, val->type,
key               629 source3/registry/reg_api.c 		TALLOC_FREE(key->values);
key               633 source3/registry/reg_api.c 	if (!store_reg_values(key->key, key->values)) {
key               634 source3/registry/reg_api.c 		TALLOC_FREE(key->values);
key               641 source3/registry/reg_api.c static WERROR reg_value_exists(struct registry_key *key, const char *name)
key               645 source3/registry/reg_api.c 	for (i=0; i<key->values->num_values; i++) {
key               646 source3/registry/reg_api.c 		if (strequal(key->values->values[i]->valuename, name)) {
key               654 source3/registry/reg_api.c WERROR reg_deletevalue(struct registry_key *key, const char *name)
key               658 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_SET_VALUE)) {
key               662 source3/registry/reg_api.c 	if (!W_ERROR_IS_OK(err = fill_value_cache(key))) {
key               666 source3/registry/reg_api.c 	err = reg_value_exists(key, name);
key               671 source3/registry/reg_api.c 	regval_ctr_delvalue(key->values, name);
key               673 source3/registry/reg_api.c 	if (!store_reg_values(key->key, key->values)) {
key               674 source3/registry/reg_api.c 		TALLOC_FREE(key->values);
key               681 source3/registry/reg_api.c WERROR reg_getkeysecurity(TALLOC_CTX *mem_ctx, struct registry_key *key,
key               684 source3/registry/reg_api.c 	return regkey_get_secdesc(mem_ctx, key->key, psecdesc);
key               687 source3/registry/reg_api.c WERROR reg_setkeysecurity(struct registry_key *key,
key               690 source3/registry/reg_api.c 	return regkey_set_secdesc(key->key, psecdesc);
key               709 source3/registry/reg_api.c 			    REGF_NK_REC *key)
key               746 source3/registry/reg_api.c 	for (i=0; i<key->num_values; i++) {
key               747 source3/registry/reg_api.c 		regval_ctr_addvalue(values, key->values[i].valuename,
key               748 source3/registry/reg_api.c 				    key->values[i].type,
key               749 source3/registry/reg_api.c 				    (char*)key->values[i].data,
key               750 source3/registry/reg_api.c 				    (key->values[i].data_size & ~VK_DATA_IN_OFFSET));
key               755 source3/registry/reg_api.c 	key->subkey_index = 0;
key               756 source3/registry/reg_api.c 	while ((subkey = regfio_fetch_subkey( regfile, key ))) {
key               781 source3/registry/reg_api.c 	key->subkey_index = 0;
key               782 source3/registry/reg_api.c 	while ((subkey = regfio_fetch_subkey(regfile, key))) {
key               834 source3/registry/reg_api.c WERROR reg_restorekey(struct registry_key *key, const char *fname)
key               836 source3/registry/reg_api.c 	return restore_registry_key(key->key, fname);
key               845 source3/registry/reg_api.c 	REGF_NK_REC *key;
key               913 source3/registry/reg_api.c 	key = regfio_write_key(regfile, keyname, values, subkeys, sec_desc,
key               915 source3/registry/reg_api.c 	if (key == NULL) {
key               931 source3/registry/reg_api.c 		result = reg_write_tree(regfile, subkeypath, key);
key               971 source3/registry/reg_api.c WERROR reg_savekey(struct registry_key *key, const char *fname)
key               973 source3/registry/reg_api.c 	return backup_registry_key(key->key, fname);
key               980 source3/registry/reg_api.c WERROR reg_deleteallvalues(struct registry_key *key)
key               985 source3/registry/reg_api.c 	if (!(key->key->access_granted & KEY_SET_VALUE)) {
key               989 source3/registry/reg_api.c 	if (!W_ERROR_IS_OK(err = fill_value_cache(key))) {
key               993 source3/registry/reg_api.c 	for (i=0; i<key->values->num_values; i++) {
key               994 source3/registry/reg_api.c 		regval_ctr_delvalue(key->values, key->values->values[i]->valuename);
key               997 source3/registry/reg_api.c 	if (!store_reg_values(key->key, key->values)) {
key               998 source3/registry/reg_api.c 		TALLOC_FREE(key->values);
key              1013 source3/registry/reg_api.c 	struct registry_key *hive, *key;
key              1048 source3/registry/reg_api.c 	err = reg_openkey(mem_ctx, hive, p+1, desired_access, &key);
key              1057 source3/registry/reg_api.c 	*pkey = key;
key              1073 source3/registry/reg_api.c 	struct registry_key *key;
key              1084 source3/registry/reg_api.c 	werr = reg_openkey(mem_ctx, parent, path, REG_KEY_ALL, &key);
key              1089 source3/registry/reg_api.c 	werr = fill_subkey_cache(key);
key              1096 source3/registry/reg_api.c 	for (i = regsubkey_ctr_numkeys(key->subkeys) ; i > 0; i--) {
key              1097 source3/registry/reg_api.c 		subkey_name = regsubkey_ctr_specific_key(key->subkeys, i-1);
key              1098 source3/registry/reg_api.c 		werr = reg_deletekey_recursive_internal(mem_ctx, key,
key              1133 source3/registry/reg_api.c 			  "'%s': %s\n", path, parent->key->name,
key                36 source3/registry/reg_backend_current_version.c static int current_version_fetch_values(const char *key, REGVAL_CTR *values)
key                45 source3/registry/reg_backend_current_version.c 	path = talloc_strdup(ctx, key);
key                55 source3/registry/reg_backend_current_version.c 		return regdb_ops.fetch_values(key, values);
key                72 source3/registry/reg_backend_current_version.c static int current_version_fetch_subkeys(const char *key,
key                75 source3/registry/reg_backend_current_version.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                30 source3/registry/reg_backend_db.c static bool regdb_key_exists(const char *key);
key                31 source3/registry/reg_backend_db.c static bool regdb_key_is_base_key(const char *key);
key               603 source3/registry/reg_backend_db.c static bool regdb_store_keys_internal(const char *key, struct regsubkey_ctr *ctr)
key               615 source3/registry/reg_backend_db.c 	if (!key) {
key               619 source3/registry/reg_backend_db.c 	keyname = talloc_strdup(ctx, key);
key               704 source3/registry/reg_backend_db.c bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
key               713 source3/registry/reg_backend_db.c 	if (!regdb_key_is_base_key(key) && !regdb_key_exists(key)) {
key               728 source3/registry/reg_backend_db.c 	regdb_fetch_keys(key, old_subkeys);
key               770 source3/registry/reg_backend_db.c 	regdb_fetch_keys(key, old_subkeys);
key               807 source3/registry/reg_backend_db.c 		path = talloc_asprintf(ctx, "%s/%s", key, oldkeyname);
key               822 source3/registry/reg_backend_db.c 	if (!regdb_store_keys_internal(key, ctr) ) {
key               824 source3/registry/reg_backend_db.c 			 "for parent [%s]\n", key));
key               839 source3/registry/reg_backend_db.c 		if (!regdb_store_keys_internal(key, subkeys)) {
key               841 source3/registry/reg_backend_db.c 				 "new record for key [%s]\n", key));
key               850 source3/registry/reg_backend_db.c 					key,
key               893 source3/registry/reg_backend_db.c static WERROR regdb_create_subkey(const char *key, const char *subkey)
key               899 source3/registry/reg_backend_db.c 	if (!regdb_key_is_base_key(key) && !regdb_key_exists(key)) {
key               907 source3/registry/reg_backend_db.c 	if (regdb_fetch_keys(key, subkeys) < 0) {
key               925 source3/registry/reg_backend_db.c 	if (regdb_fetch_keys(key, subkeys) < 0) {
key               933 source3/registry/reg_backend_db.c 	if (!regdb_store_keys_internal(key, subkeys)) {
key               935 source3/registry/reg_backend_db.c 			 "parent key %s\n", key));
key               960 source3/registry/reg_backend_db.c static WERROR regdb_delete_subkey(const char *key, const char *subkey)
key               967 source3/registry/reg_backend_db.c 	if (!regdb_key_is_base_key(key) && !regdb_key_exists(key)) {
key               972 source3/registry/reg_backend_db.c 	path = talloc_asprintf(mem_ctx, "%s/%s", key, subkey);
key               992 source3/registry/reg_backend_db.c 	if (regdb_fetch_keys(key, subkeys) < 0) {
key              1000 source3/registry/reg_backend_db.c 	if (!regdb_store_keys_internal(key, subkeys)) {
key              1002 source3/registry/reg_backend_db.c 			 "parent key %s\n", key));
key              1027 source3/registry/reg_backend_db.c static TDB_DATA regdb_fetch_key_internal(TALLOC_CTX *mem_ctx, const char *key)
key              1032 source3/registry/reg_backend_db.c 	path = normalize_reg_path(mem_ctx, key);
key              1048 source3/registry/reg_backend_db.c static bool regdb_key_is_base_key(const char *key)
key              1054 source3/registry/reg_backend_db.c 	if (key == NULL) {
key              1058 source3/registry/reg_backend_db.c 	path = normalize_reg_path(mem_ctx, key);
key              1103 source3/registry/reg_backend_db.c static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
key              1127 source3/registry/reg_backend_db.c 	res = regdb_fetch_keys(key, ctr);
key              1207 source3/registry/reg_backend_db.c static int parent_subkey_scanner(TDB_DATA key, TDB_DATA data,
key              1247 source3/registry/reg_backend_db.c 	char *key = NULL;
key              1259 source3/registry/reg_backend_db.c 	key = talloc_asprintf(talloc_tos(), "%s/%s",
key              1261 source3/registry/reg_backend_db.c 	if (key == NULL) {
key              1271 source3/registry/reg_backend_db.c 	res = regdb->parse_record(regdb, string_term_tdb_data(key),
key              1277 source3/registry/reg_backend_db.c 		if (!create_sorted_subkeys(path, key)) {
key              1280 source3/registry/reg_backend_db.c 		res = regdb->parse_record(regdb, string_term_tdb_data(key),
key              1301 source3/registry/reg_backend_db.c static bool regdb_key_exists(const char *key)
key              1308 source3/registry/reg_backend_db.c 	if (key == NULL) {
key              1312 source3/registry/reg_backend_db.c 	path = normalize_reg_path(mem_ctx, key);
key              1343 source3/registry/reg_backend_db.c int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
key              1355 source3/registry/reg_backend_db.c 	DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
key              1357 source3/registry/reg_backend_db.c 	if (!regdb_key_exists(key)) {
key              1366 source3/registry/reg_backend_db.c 	value = regdb_fetch_key_internal(frame, key);
key              1370 source3/registry/reg_backend_db.c 			   key));
key              1481 source3/registry/reg_backend_db.c int regdb_fetch_values( const char* key, REGVAL_CTR *values )
key              1488 source3/registry/reg_backend_db.c 	DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key));
key              1490 source3/registry/reg_backend_db.c 	if (!regdb_key_exists(key)) {
key              1494 source3/registry/reg_backend_db.c 	keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key);
key              1516 source3/registry/reg_backend_db.c bool regdb_store_values( const char *key, REGVAL_CTR *values )
key              1525 source3/registry/reg_backend_db.c 	DEBUG(10,("regdb_store_values: Looking for value of key [%s] \n", key));
key              1527 source3/registry/reg_backend_db.c 	if (!regdb_key_exists(key)) {
key              1546 source3/registry/reg_backend_db.c 	keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key );
key              1574 source3/registry/reg_backend_db.c static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
key              1583 source3/registry/reg_backend_db.c 	DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key));
key              1585 source3/registry/reg_backend_db.c 	if (!regdb_key_exists(key)) {
key              1590 source3/registry/reg_backend_db.c 	tdbkey = talloc_asprintf(tmp_ctx, "%s/%s", REG_SECDESC_PREFIX, key);
key              1617 source3/registry/reg_backend_db.c static WERROR regdb_set_secdesc(const char *key,
key              1625 source3/registry/reg_backend_db.c 	if (!regdb_key_exists(key)) {
key              1630 source3/registry/reg_backend_db.c 	tdbkey = talloc_asprintf(mem_ctx, "%s/%s", REG_SECDESC_PREFIX, key);
key                34 source3/registry/reg_backend_hkpt_params.c static int hkpt_params_fetch_values(const char *key, REGVAL_CTR *regvals)
key                61 source3/registry/reg_backend_hkpt_params.c static int hkpt_params_fetch_subkeys(const char *key,
key                64 source3/registry/reg_backend_hkpt_params.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                34 source3/registry/reg_backend_netlogon_params.c static int netlogon_params_fetch_values(const char *key, REGVAL_CTR *regvals)
key                48 source3/registry/reg_backend_netlogon_params.c static int netlogon_params_fetch_subkeys(const char *key,
key                51 source3/registry/reg_backend_netlogon_params.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                74 source3/registry/reg_backend_perflib.c static int perflib_fetch_values(const char *key, REGVAL_CTR *regvals)
key                79 source3/registry/reg_backend_perflib.c 	path = talloc_strdup(ctx, key);
key                97 source3/registry/reg_backend_perflib.c static int perflib_fetch_subkeys(const char *key,
key               100 source3/registry/reg_backend_perflib.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                80 source3/registry/reg_backend_printing.c static int key_forms_fetch_keys(const char *key, struct regsubkey_ctr *subkeys)
key                82 source3/registry/reg_backend_printing.c 	char *p = reg_remaining_path(talloc_tos(), key + strlen(KEY_FORMS));
key                96 source3/registry/reg_backend_printing.c static int key_forms_fetch_values( const char *key, REGVAL_CTR *values )
key               103 source3/registry/reg_backend_printing.c 	DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
key               169 source3/registry/reg_backend_printing.c static char *strip_printers_prefix(const char *key)
key               175 source3/registry/reg_backend_printing.c 	path = talloc_strdup(ctx, key);
key               187 source3/registry/reg_backend_printing.c 		subkeypath = reg_remaining_path(ctx, key + strlen(KEY_WINNT_PRINTERS));
key               189 source3/registry/reg_backend_printing.c 		subkeypath = reg_remaining_path(ctx, key + strlen(KEY_CONTROL_PRINTERS));
key               199 source3/registry/reg_backend_printing.c static int key_printers_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
key               211 source3/registry/reg_backend_printing.c 	DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key ? key : "NULL" ));
key               213 source3/registry/reg_backend_printing.c 	printers_key = strip_printers_prefix( key );
key               313 source3/registry/reg_backend_printing.c static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subkeys )
key               322 source3/registry/reg_backend_printing.c 	printers_key = strip_printers_prefix( key );
key               478 source3/registry/reg_backend_printing.c static int key_printers_fetch_values( const char *key, REGVAL_CTR *values )
key               487 source3/registry/reg_backend_printing.c 	printers_key = strip_printers_prefix( key );	
key               674 source3/registry/reg_backend_printing.c static bool key_printers_store_values( const char *key, REGVAL_CTR *values )
key               681 source3/registry/reg_backend_printing.c 	printers_key = strip_printers_prefix( key );
key               739 source3/registry/reg_backend_printing.c static int key_driver_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
key               758 source3/registry/reg_backend_printing.c 	DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key ? key : "NULL" ));
key               760 source3/registry/reg_backend_printing.c 	keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS) );
key               882 source3/registry/reg_backend_printing.c 		key, subkeypath ));
key               970 source3/registry/reg_backend_printing.c static int driver_arch_fetch_values( char *key, REGVAL_CTR *values )
key               979 source3/registry/reg_backend_printing.c 	if (!reg_split_path( key, &base, &subkeypath )) {
key              1057 source3/registry/reg_backend_printing.c static int key_driver_fetch_values( const char *key, REGVAL_CTR *values )
key              1063 source3/registry/reg_backend_printing.c 	DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key ? key : "NULL"));
key              1067 source3/registry/reg_backend_printing.c 	if (!(keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS))))
key              1086 source3/registry/reg_backend_printing.c static int key_print_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
key              1088 source3/registry/reg_backend_printing.c 	int key_len = strlen(key);
key              1164 source3/registry/reg_backend_printing.c static int match_registry_path(const char *key)
key              1170 source3/registry/reg_backend_printing.c 	if ( !key )
key              1173 source3/registry/reg_backend_printing.c 	path = talloc_strdup(ctx, key);
key              1193 source3/registry/reg_backend_printing.c static int regprint_fetch_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
key              1195 source3/registry/reg_backend_printing.c 	int i = match_registry_path( key );
key              1203 source3/registry/reg_backend_printing.c 	return print_registry[i].fetch_subkeys( key, subkeys );
key              1209 source3/registry/reg_backend_printing.c static bool regprint_store_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
key              1211 source3/registry/reg_backend_printing.c 	int i = match_registry_path( key );
key              1219 source3/registry/reg_backend_printing.c 	return print_registry[i].store_subkeys( key, subkeys );
key              1225 source3/registry/reg_backend_printing.c static int regprint_fetch_reg_values( const char *key, REGVAL_CTR *values )
key              1227 source3/registry/reg_backend_printing.c 	int i = match_registry_path( key );
key              1238 source3/registry/reg_backend_printing.c 	return print_registry[i].fetch_values( key, values );
key              1244 source3/registry/reg_backend_printing.c static bool regprint_store_reg_values( const char *key, REGVAL_CTR *values )
key              1246 source3/registry/reg_backend_printing.c 	int i = match_registry_path( key );
key              1254 source3/registry/reg_backend_printing.c 	return print_registry[i].store_values( key, values );
key                34 source3/registry/reg_backend_prod_options.c static int prod_options_fetch_values(const char *key, REGVAL_CTR *regvals)
key                61 source3/registry/reg_backend_prod_options.c static int prod_options_fetch_subkeys(const char *key,
key                64 source3/registry/reg_backend_prod_options.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                69 source3/registry/reg_backend_shares.c static int shares_subkey_info( const char *key, struct regsubkey_ctr *subkey_ctr )
key                75 source3/registry/reg_backend_shares.c 	DEBUG(10,("printing_subkey_info: key=>[%s]\n", key));
key                77 source3/registry/reg_backend_shares.c 	path = trim_reg_path( key );
key               103 source3/registry/reg_backend_shares.c static int shares_value_info( const char *key, REGVAL_CTR *val )
key               109 source3/registry/reg_backend_shares.c 	DEBUG(10,("printing_value_info: key=>[%s]\n", key));
key               111 source3/registry/reg_backend_shares.c 	path = trim_reg_path( key );
key               137 source3/registry/reg_backend_shares.c static bool shares_store_subkey( const char *key, struct regsubkey_ctr *subkeys )
key               148 source3/registry/reg_backend_shares.c static bool shares_store_value( const char *key, REGVAL_CTR *val )
key                28 source3/registry/reg_backend_smbconf.c static int smbconf_fetch_keys( const char *key, struct regsubkey_ctr *subkey_ctr )
key                30 source3/registry/reg_backend_smbconf.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                33 source3/registry/reg_backend_smbconf.c static bool smbconf_store_keys( const char *key, struct regsubkey_ctr *subkeys )
key                35 source3/registry/reg_backend_smbconf.c 	return regdb_ops.store_subkeys(key, subkeys);
key                38 source3/registry/reg_backend_smbconf.c static WERROR smbconf_create_subkey(const char *key, const char *subkey)
key                40 source3/registry/reg_backend_smbconf.c 	return regdb_ops.create_subkey(key, subkey);
key                43 source3/registry/reg_backend_smbconf.c static WERROR smbconf_delete_subkey(const char *key, const char *subkey)
key                45 source3/registry/reg_backend_smbconf.c 	return regdb_ops.delete_subkey(key, subkey);
key                48 source3/registry/reg_backend_smbconf.c static int smbconf_fetch_values( const char *key, REGVAL_CTR *val )
key                50 source3/registry/reg_backend_smbconf.c 	return regdb_ops.fetch_values(key, val);
key                53 source3/registry/reg_backend_smbconf.c static bool smbconf_store_values( const char *key, REGVAL_CTR *val )
key                55 source3/registry/reg_backend_smbconf.c 	return regdb_ops.store_values(key, val);
key                70 source3/registry/reg_backend_smbconf.c static WERROR smbconf_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
key                73 source3/registry/reg_backend_smbconf.c 	return regdb_ops.get_secdesc(mem_ctx, key, psecdesc);
key                76 source3/registry/reg_backend_smbconf.c static WERROR smbconf_set_secdesc(const char *key,
key                79 source3/registry/reg_backend_smbconf.c 	return regdb_ops.set_secdesc(key, secdesc);
key                34 source3/registry/reg_backend_tcpip_params.c static int tcpip_params_fetch_values(const char *key, REGVAL_CTR *regvals)
key                58 source3/registry/reg_backend_tcpip_params.c static int tcpip_params_fetch_subkeys(const char *key,
key                61 source3/registry/reg_backend_tcpip_params.c 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
key                85 source3/registry/reg_cachehook.c 	char *key = NULL;
key                91 source3/registry/reg_cachehook.c 	werr = keyname_to_path(talloc_tos(), keyname, &key);
key                97 source3/registry/reg_cachehook.c 		   (void *)ops, key));
key                99 source3/registry/reg_cachehook.c 	werr = pathtree_add(cache_tree, key, ops);
key               102 source3/registry/reg_cachehook.c 	TALLOC_FREE(key);
key               113 source3/registry/reg_cachehook.c 	char *key = NULL;
key               120 source3/registry/reg_cachehook.c 	werr = keyname_to_path(talloc_tos(), keyname, &key);
key               125 source3/registry/reg_cachehook.c 	DEBUG(10,("reghook_cache_find: Searching for keyname [%s]\n", key));
key               127 source3/registry/reg_cachehook.c 	ops = (REGISTRY_OPS *)pathtree_find(cache_tree, key);
key               130 source3/registry/reg_cachehook.c 		   ops ? (void *)ops : 0, key));
key               133 source3/registry/reg_cachehook.c 	TALLOC_FREE(key);
key                83 source3/registry/reg_dispatcher.c bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys )
key                85 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->store_subkeys)
key                86 source3/registry/reg_dispatcher.c 		return key->ops->store_subkeys(key->name, subkeys);
key                95 source3/registry/reg_dispatcher.c bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
key                97 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->store_values)
key                98 source3/registry/reg_dispatcher.c 		return key->ops->store_values(key->name, val);
key               103 source3/registry/reg_dispatcher.c WERROR create_reg_subkey(REGISTRY_KEY *key, const char *subkey)
key               105 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->create_subkey) {
key               106 source3/registry/reg_dispatcher.c 		return key->ops->create_subkey(key->name, subkey);
key               112 source3/registry/reg_dispatcher.c WERROR delete_reg_subkey(REGISTRY_KEY *key, const char *subkey)
key               114 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->delete_subkey) {
key               115 source3/registry/reg_dispatcher.c 		return key->ops->delete_subkey(key->name, subkey);
key               126 source3/registry/reg_dispatcher.c int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr )
key               130 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->fetch_subkeys)
key               131 source3/registry/reg_dispatcher.c 		result = key->ops->fetch_subkeys(key->name, subkey_ctr);
key               140 source3/registry/reg_dispatcher.c int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
key               144 source3/registry/reg_dispatcher.c 	DEBUG(10, ("fetch_reg_values called for key '%s' (ops %p)\n", key->name,
key               145 source3/registry/reg_dispatcher.c 		   (key->ops) ? (void *)key->ops : NULL));
key               147 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->fetch_values)
key               148 source3/registry/reg_dispatcher.c 		result = key->ops->fetch_values(key->name, val);
key               158 source3/registry/reg_dispatcher.c bool regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted,
key               168 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->reg_access_check) {
key               169 source3/registry/reg_dispatcher.c 		return key->ops->reg_access_check(key->name, requested,
key               173 source3/registry/reg_dispatcher.c 	err = regkey_get_secdesc(talloc_tos(), key, &sec_desc);
key               190 source3/registry/reg_dispatcher.c WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, REGISTRY_KEY *key,
key               196 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->get_secdesc) {
key               197 source3/registry/reg_dispatcher.c 		werr = key->ops->get_secdesc(mem_ctx, key->name, psecdesc);
key               212 source3/registry/reg_dispatcher.c WERROR regkey_set_secdesc(REGISTRY_KEY *key,
key               215 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->set_secdesc) {
key               216 source3/registry/reg_dispatcher.c 		return key->ops->set_secdesc(key->name, psecdesc);
key               226 source3/registry/reg_dispatcher.c bool reg_subkeys_need_update(REGISTRY_KEY *key, struct regsubkey_ctr *subkeys)
key               228 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->subkeys_need_update)
key               230 source3/registry/reg_dispatcher.c 		return key->ops->subkeys_need_update(subkeys);
key               240 source3/registry/reg_dispatcher.c bool reg_values_need_update(REGISTRY_KEY *key, REGVAL_CTR *values)
key               242 source3/registry/reg_dispatcher.c 	if (key->ops && key->ops->values_need_update)
key               244 source3/registry/reg_dispatcher.c 		return key->ops->values_need_update(values);
key                77 source3/registry/reg_perfcount.c 	char key[] = "1";
key               101 source3/registry/reg_perfcount.c 	kbuf = string_tdb_data(key);
key               298 source3/registry/reg_perfcount.c static void _reg_perfcount_make_key(TDB_DATA *key,
key               310 source3/registry/reg_perfcount.c 	*key = string_tdb_data(buf);
key               350 source3/registry/reg_perfcount.c 	TDB_DATA key, data;
key               353 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, objInd, "inst");
key               354 source3/registry/reg_perfcount.c 	data = tdb_fetch(names, key);
key               410 source3/registry/reg_perfcount.c bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data)
key               423 source3/registry/reg_perfcount.c 	*data = tdb_fetch(counters, key);
key               478 source3/registry/reg_perfcount.c 	TDB_DATA key, data;
key               489 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, CounterIndex, "type");
key               490 source3/registry/reg_perfcount.c 	data = tdb_fetch(names, key);
key               504 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, CounterIndex, "");
key               505 source3/registry/reg_perfcount.c 	_reg_perfcount_get_counter_data(key, &data);
key               669 source3/registry/reg_perfcount.c 	TDB_DATA key, data;
key               677 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, obj->ObjectNameTitleIndex, temp);
key               678 source3/registry/reg_perfcount.c 	if (!_reg_perfcount_get_counter_data(key, &data)) {
key               702 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, obj->ObjectNameTitleIndex, temp);
key               703 source3/registry/reg_perfcount.c 	data = tdb_fetch(names, key);
key               789 source3/registry/reg_perfcount.c 	TDB_DATA key, data;
key               794 source3/registry/reg_perfcount.c 		_reg_perfcount_make_key(&key, keybuf, PERFCOUNT_MAX_LEN, j, "rel");
key               795 source3/registry/reg_perfcount.c 		data = tdb_fetch(names, key);
key               828 source3/registry/reg_perfcount.c 	TDB_DATA key, data;
key               831 source3/registry/reg_perfcount.c 	_reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, key_part1, key_part2);
key               833 source3/registry/reg_perfcount.c 	data = tdb_fetch(tdb, key);
key               836 source3/registry/reg_perfcount.c 		DEBUG(3,("_reg_perfcount_get_64: No data found for key [%s].\n", key.dptr));
key                64 source3/registry/reg_util.c bool reg_split_key(char *path, char **base, char **key)
key                68 source3/registry/reg_util.c 	*key = *base = NULL;
key                80 source3/registry/reg_util.c 		*key = p+1;
key               124 source3/registry/reg_util.c void normalize_dbkey(char *key)
key               126 source3/registry/reg_util.c 	size_t len = strlen(key);
key               127 source3/registry/reg_util.c 	string_sub(key, "\\", "/", len+1);
key               128 source3/registry/reg_util.c 	strupper_m(key);
key               135 source3/registry/reg_util.c char *reg_remaining_path(TALLOC_CTX *ctx, const char *key)
key               140 source3/registry/reg_util.c 	if (!key || !*key) {
key               144 source3/registry/reg_util.c 	new_path = talloc_strdup(ctx, key);
key                36 source3/registry/reg_util_legacy.c 	struct registry_key *key;
key                39 source3/registry/reg_util_legacy.c 	err = reg_open_path(NULL, path, access_desired, token, &key);
key                44 source3/registry/reg_util_legacy.c 	*regkey = talloc_move(ctx, &key->key);
key                45 source3/registry/reg_util_legacy.c 	TALLOC_FREE(key);
key               186 source3/rpc_client/cli_netlogon.c 		unsigned char key[16];
key               202 source3/rpc_client/cli_netlogon.c 		memset(key, 0, 16);
key               203 source3/rpc_client/cli_netlogon.c 		memcpy(key, cli->dc->sess_key, 8);
key               206 source3/rpc_client/cli_netlogon.c 		SamOEMhash(lm_owf, key, 16);
key               208 source3/rpc_client/cli_netlogon.c 		SamOEMhash(nt_owf, key, 16);
key               410 source3/rpc_client/cli_netlogon.c 	if (memcmp(zeros, validation.sam3->base.key.key, 16) != 0) {
key               411 source3/rpc_client/cli_netlogon.c 		SamOEMhash(validation.sam3->base.key.key,
key               415 source3/rpc_client/cli_netlogon.c 	if (memcmp(zeros, validation.sam3->base.LMSessKey.key, 8) != 0) {
key               416 source3/rpc_client/cli_netlogon.c 		SamOEMhash(validation.sam3->base.LMSessKey.key,
key               527 source3/rpc_client/cli_netlogon.c 	if (memcmp(zeros, validation.sam3->base.key.key, 16) != 0) {
key               528 source3/rpc_client/cli_netlogon.c 		SamOEMhash(validation.sam3->base.key.key,
key               532 source3/rpc_client/cli_netlogon.c 	if (memcmp(zeros, validation.sam3->base.LMSessKey.key, 8) != 0) {
key               533 source3/rpc_client/cli_netlogon.c 		SamOEMhash(validation.sam3->base.LMSessKey.key,
key                45 source3/rpc_client/init_netlogon.c 			   struct netr_UserSessionKey key,
key                70 source3/rpc_client/init_netlogon.c 	r->key = key;
key               101 source3/rpc_client/init_netlogon.c 			struct netr_UserSessionKey key,
key               129 source3/rpc_client/init_netlogon.c 			      key,
key               257 source3/rpc_client/init_netlogon.c 		memcpy(user_session_key.key,
key               259 source3/rpc_client/init_netlogon.c 		       MIN(sizeof(user_session_key.key),
key               262 source3/rpc_client/init_netlogon.c 			SamOEMhash(user_session_key.key, pipe_session_key, 16);
key               266 source3/rpc_client/init_netlogon.c 		memcpy(lm_session_key.key,
key               268 source3/rpc_client/init_netlogon.c 		       MIN(sizeof(lm_session_key.key),
key               271 source3/rpc_client/init_netlogon.c 			SamOEMhash(lm_session_key.key, pipe_session_key, 8);
key               289 source3/rpc_server/srv_eventlog_nt.c 	struct registry_key *key;
key               318 source3/rpc_server/srv_eventlog_nt.c 				&key);
key               327 source3/rpc_server/srv_eventlog_nt.c 	wresult = reg_queryvalue(key, key, "Retention", &value);
key               335 source3/rpc_server/srv_eventlog_nt.c 	wresult = reg_queryvalue(key, key, "MaxSize", &value);
key              2333 source3/rpc_server/srv_spoolss_nt.c static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
key              2335 source3/rpc_server/srv_spoolss_nt.c 	return delete_printer_data( printer->info_2, key, value );
key              2343 source3/rpc_server/srv_spoolss_nt.c 			  const char *key, const char *value,
key              2348 source3/rpc_server/srv_spoolss_nt.c 	return add_printer_data( printer->info_2, key, value, type, data, real_len );
key                59 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key;
key                63 source3/rpc_server/srv_winreg_nt.c 				      p->server_info->ptok, &key);
key                67 source3/rpc_server/srv_winreg_nt.c 				     access_desired, &key);
key                74 source3/rpc_server/srv_winreg_nt.c 	if ( !create_policy_hnd( p, hnd, key ) ) {
key               229 source3/rpc_server/srv_winreg_nt.c 	DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
key               230 source3/rpc_server/srv_winreg_nt.c 	DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
key               233 source3/rpc_server/srv_winreg_nt.c 	if(regkey->key->type == REG_KEY_HKPD) 
key               376 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
key               378 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               384 source3/rpc_server/srv_winreg_nt.c 	DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
key               386 source3/rpc_server/srv_winreg_nt.c 	err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
key               402 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
key               407 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               414 source3/rpc_server/srv_winreg_nt.c 		 key->key->name));
key               416 source3/rpc_server/srv_winreg_nt.c 	err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
key               670 source3/rpc_server/srv_winreg_nt.c 		 "\"%s\"\n", regkey->key->name, fname));
key               681 source3/rpc_server/srv_winreg_nt.c 		 regkey->key->name, fname, lp_servicename(snum) ));
key               704 source3/rpc_server/srv_winreg_nt.c 		 regkey->key->name, fname));
key               710 source3/rpc_server/srv_winreg_nt.c 		 regkey->key->name, fname, lp_servicename(snum) ));
key               740 source3/rpc_server/srv_winreg_nt.c 		   "subkey name '%s'\n", parent->key->name, r->in.name.name));
key               761 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
key               765 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               769 source3/rpc_server/srv_winreg_nt.c 			 key->key->name, r->in.name.name));
key               777 source3/rpc_server/srv_winreg_nt.c 	return reg_setvalue(key, r->in.name.name, val);
key               790 source3/rpc_server/srv_winreg_nt.c 	return reg_deletekey(parent, r->in.key.name);
key               799 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
key               801 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               804 source3/rpc_server/srv_winreg_nt.c 	return reg_deletevalue(key, r->in.value.name);
key               812 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
key               818 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               823 source3/rpc_server/srv_winreg_nt.c 	if ( !(key->key->access_granted & STD_RIGHT_READ_CONTROL_ACCESS) )
key               826 source3/rpc_server/srv_winreg_nt.c 	err = reg_getkeysecurity(p->mem_ctx, key, &secdesc);
key               854 source3/rpc_server/srv_winreg_nt.c 	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
key               858 source3/rpc_server/srv_winreg_nt.c 	if ( !key )
key               863 source3/rpc_server/srv_winreg_nt.c 	if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
key               872 source3/rpc_server/srv_winreg_nt.c 	return reg_setkeysecurity(key, secdesc);
key               449 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               454 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, KEY_SERVICES,
key               465 source3/services/services_db.c 	wresult = regsubkey_ctr_init(key, &subkeys);
key               468 source3/services/services_db.c 		TALLOC_FREE( key );
key               472 source3/services/services_db.c 	fetch_reg_keys( key, subkeys );
key               477 source3/services/services_db.c 		add_new_svc_name( key, subkeys, builtin_svcs[i].servicename );
key               487 source3/services/services_db.c 		add_new_svc_name( key, subkeys, service_list[i] );
key               490 source3/services/services_db.c 	TALLOC_FREE( key );
key               507 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               520 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, path, token,
key               528 source3/services/services_db.c 	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
key               533 source3/services/services_db.c 	if (fetch_reg_values( key, values ) == -1) {
key               558 source3/services/services_db.c 	TALLOC_FREE(key);
key               568 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               581 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, path, token,
key               591 source3/services/services_db.c 	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
key               593 source3/services/services_db.c 		TALLOC_FREE( key );
key               602 source3/services/services_db.c 		TALLOC_FREE( key );
key               607 source3/services/services_db.c 	ret = store_reg_values( key, values );
key               611 source3/services/services_db.c 	TALLOC_FREE( key);
key               622 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               633 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, path, token,
key               643 source3/services/services_db.c 	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
key               645 source3/services/services_db.c 		TALLOC_FREE( key );
key               649 source3/services/services_db.c 	fetch_reg_values( key, values );
key               656 source3/services/services_db.c 	TALLOC_FREE( key );
key               662 source3/services/services_db.c 	TALLOC_FREE( key );
key               672 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               683 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, path, token,
key               693 source3/services/services_db.c 	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
key               695 source3/services/services_db.c 		TALLOC_FREE( key );
key               699 source3/services/services_db.c 	fetch_reg_values( key, values );
key               702 source3/services/services_db.c 		TALLOC_FREE( key );
key               706 source3/services/services_db.c 	TALLOC_FREE(key);
key               717 source3/services/services_db.c 	REGISTRY_KEY *key = NULL;
key               727 source3/services/services_db.c 	wresult = regkey_open_internal( NULL, &key, path, token,
key               739 source3/services/services_db.c 		TALLOC_FREE( key );
key               742 source3/services/services_db.c 	fetch_reg_values( key, values );
key               744 source3/services/services_db.c 	TALLOC_FREE( key );
key               176 source3/smbd/dir.c static struct dptr_struct *dptr_get(int key, bool forclose)
key               181 source3/smbd/dir.c 		if(dptr->dnum == key) {
key               185 source3/smbd/dir.c 				DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
key               205 source3/smbd/dir.c char *dptr_path(int key)
key               207 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
key               217 source3/smbd/dir.c char *dptr_wcard(int key)
key               219 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
key               229 source3/smbd/dir.c uint16 dptr_attr(int key)
key               231 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
key               271 source3/smbd/dir.c void dptr_close(int *key)
key               275 source3/smbd/dir.c 	if(*key == INVALID_DPTR_KEY)
key               279 source3/smbd/dir.c 	if (*key == -1) {
key               285 source3/smbd/dir.c 		*key = INVALID_DPTR_KEY;
key               289 source3/smbd/dir.c 	dptr = dptr_get(*key, True);
key               292 source3/smbd/dir.c 		DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
key               298 source3/smbd/dir.c 	*key = INVALID_DPTR_KEY;
key               717 source3/smbd/dir.c bool dptr_fill(char *buf1,unsigned int key)
key               720 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
key               723 source3/smbd/dir.c 		DEBUG(1,("filling null dirptr %d\n",key));
key               727 source3/smbd/dir.c 	DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
key               729 source3/smbd/dir.c 	buf[0] = key;
key               740 source3/smbd/dir.c 	unsigned int key = *(unsigned char *)buf;
key               741 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
key               746 source3/smbd/dir.c 		DEBUG(3,("fetched null dirptr %d\n",key));
key               749 source3/smbd/dir.c 	*num = key;
key               758 source3/smbd/dir.c 		key,dptr_path(key),(int)seekoff));
key               102 source3/smbd/mangle_hash2.c static unsigned int mangle_hash(const char *key, unsigned int length)
key               113 source3/smbd/mangle_hash2.c 	strncpy(str, key, length);
key                37 source3/smbd/notify_internal.c 	TDB_DATA key;
key               107 source3/smbd/notify_internal.c 	notify->key = string_term_tdb_data(NOTIFY_KEY);
key               126 source3/smbd/notify_internal.c 	*rec = notify->db->fetch_locked(notify->db, notify, notify->key);
key               156 source3/smbd/notify_internal.c 		if (notify->db->fetch(notify->db, notify, notify->key, &dbuf) != 0) {
key               112 source3/smbd/oplock_irix.c 	struct file_id key;
key               116 source3/smbd/oplock_irix.c 	ZERO_STRUCT(key);
key               118 source3/smbd/oplock_irix.c 	key.devid = dev;
key               119 source3/smbd/oplock_irix.c 	key.inode = inode;
key               121 source3/smbd/oplock_irix.c 	return key;
key                62 source3/smbd/session.c 	TDB_DATA key, data;
key               101 source3/smbd/session.c 			key = string_term_tdb_data(keystr);
key               103 source3/smbd/session.c 			rec = ctx->fetch_locked(ctx, NULL, key);
key               142 source3/smbd/session.c 		key = string_term_tdb_data(keystr);
key               144 source3/smbd/session.c 		rec = ctx->fetch_locked(ctx, NULL, key);
key               222 source3/smbd/session.c 	TDB_DATA key;
key               233 source3/smbd/session.c 	key = string_term_tdb_data(vuser->session_keystr);
key               235 source3/smbd/session.c 	if (!(rec = ctx->fetch_locked(ctx, NULL, key))) {
key              1329 source3/smbd/sesssetup.c 				const struct connections_key *key,
key               369 source3/smbd/statcache.c unsigned int fast_string_hash(TDB_DATA *key)
key               373 source3/smbd/statcache.c         for (p = (const char *)key->dptr; *p != '\0'; p++) {
key               775 source3/smbd/vfs.c 	struct file_id key;
key               795 source3/smbd/vfs.c 	key = vfs_file_id_from_sbuf(conn, &st);
key               798 source3/smbd/vfs.c 			     data_blob_const(&key, sizeof(key)),
key               834 source3/smbd/vfs.c 		key = vfs_file_id_from_sbuf(conn, &st);
key               837 source3/smbd/vfs.c 			     data_blob_const(&key, sizeof(key)),
key              5538 source3/torture/torture.c static bool rbt_testval(struct db_context *db, const char *key,
key              5546 source3/torture/torture.c 	rec = db->fetch_locked(db, db, string_tdb_data(key));
key              5558 source3/torture/torture.c 	rec = db->fetch_locked(db, db, string_tdb_data(key));
key              5589 source3/torture/torture.c 		char *key, *value;
key              5591 source3/torture/torture.c 		if (asprintf(&key, "key%ld", random()) == -1) {
key              5595 source3/torture/torture.c 			SAFE_FREE(key);
key              5599 source3/torture/torture.c 		if (!rbt_testval(db, key, value)) {
key              5600 source3/torture/torture.c 			SAFE_FREE(key);
key              5607 source3/torture/torture.c 			SAFE_FREE(key);
key              5611 source3/torture/torture.c 		if (!rbt_testval(db, key, value)) {
key              5612 source3/torture/torture.c 			SAFE_FREE(key);
key              5617 source3/torture/torture.c 		SAFE_FREE(key);
key               142 source3/utils/dbwrap_tool.c 	int length = rec->key.dsize;
key               143 source3/utils/dbwrap_tool.c 	unsigned char *p = (unsigned char *)rec->key.dptr;
key                34 source3/utils/net_idmap.c 				    TDB_DATA key,
key                38 source3/utils/net_idmap.c 	if (strcmp((char *)key.dptr, "USER HWM") == 0) {
key                43 source3/utils/net_idmap.c 	if (strcmp((char *)key.dptr, "GROUP HWM") == 0) {
key                48 source3/utils/net_idmap.c 	if (strncmp((char *)key.dptr, "S-", 2) != 0)
key                51 source3/utils/net_idmap.c 	printf("%s %s\n", data.dptr, key.dptr);
key                81 source3/utils/net_registry.c 		       struct registry_key **key)
key                88 source3/utils/net_registry.c 	if ((path == NULL) || (key == NULL)) {
key                98 source3/utils/net_registry.c 	werr = reg_openkey(ctx, hive, subkey_name, desired_access, key);
key               122 source3/utils/net_registry.c 	struct registry_key *key = NULL;
key               138 source3/utils/net_registry.c 	werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
key               145 source3/utils/net_registry.c 	     werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
key               156 source3/utils/net_registry.c 	     werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
key               271 source3/utils/net_registry.c 	struct registry_key *key = NULL;
key               281 source3/utils/net_registry.c 	werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
key               287 source3/utils/net_registry.c 	werr = reg_queryvalue(ctx, key, argv[1], &value);
key               320 source3/utils/net_registry.c 	struct registry_key *key = NULL;
key               351 source3/utils/net_registry.c 	werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
key               357 source3/utils/net_registry.c 	werr = reg_setvalue(key, argv[1], &value);
key               375 source3/utils/net_registry.c 	struct registry_key *key = NULL;
key               385 source3/utils/net_registry.c 	werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
key               391 source3/utils/net_registry.c 	werr = reg_deletevalue(key, argv[1]);
key               410 source3/utils/net_registry.c 	struct registry_key *key = NULL;
key               434 source3/utils/net_registry.c 	werr = open_key(ctx, argv[0], access_mask, &key);
key               440 source3/utils/net_registry.c 	werr = reg_getkeysecurity(ctx, key, &secdesc);
key                86 source3/utils/net_rpc_registry.c 	struct winreg_String key;
key                88 source3/utils/net_rpc_registry.c 	ZERO_STRUCT(key);
key                90 source3/utils/net_rpc_registry.c 	if (!reg_hive_key(mem_ctx, name, &hive, &key.name)) {
key               100 source3/utils/net_rpc_registry.c 	status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
key               648 source3/utils/net_rpc_registry.c 	struct winreg_String key, keyclass;
key               652 source3/utils/net_rpc_registry.c 	ZERO_STRUCT(key);
key               655 source3/utils/net_rpc_registry.c 	if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
key               669 source3/utils/net_rpc_registry.c 	status = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
key               720 source3/utils/net_rpc_registry.c 	struct winreg_String key;
key               723 source3/utils/net_rpc_registry.c 	ZERO_STRUCT(key);
key               725 source3/utils/net_rpc_registry.c 	if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
key               736 source3/utils/net_rpc_registry.c 	status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key, NULL);
key               946 source3/utils/net_rpc_registry.c 	REGF_NK_REC *key;
key               950 source3/utils/net_rpc_registry.c 	while ( (key = regfio_fetch_subkey( file, nk )) ) {
key               952 source3/utils/net_rpc_registry.c 		if (asprintf(&regpath, "%s\\%s", parent, key->keyname) < 0) {
key               956 source3/utils/net_rpc_registry.c 		dump_values( key );
key               958 source3/utils/net_rpc_registry.c 		dump_registry_tree( file, key, regpath );
key               972 source3/utils/net_rpc_registry.c 	REGF_NK_REC *key, *subkey;
key              1005 source3/utils/net_rpc_registry.c 	key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
key              1021 source3/utils/net_rpc_registry.c 		write_registry_tree( infile, subkey, key, outfile, path );
key               103 source3/utils/net_status.c 		      const struct connections_key *key,
key               152 source3/utils/net_status.c 				const struct connections_key *key,
key               118 source3/utils/profiles.c 	REGF_NK_REC *key, *subkey;
key               161 source3/utils/profiles.c 	key = regfio_write_key( outfile, nk->keyname, values, subkeys, new_sd, parent );
key               174 source3/utils/profiles.c 		if (!copy_registry_tree( infile, subkey, key, outfile, path)) {
key               263 source3/utils/smbcontrol.c 				  const struct connections_key *key,
key               226 source3/utils/status.c 			const struct connections_key *key,
key               183 source3/web/statuspage.c 			const struct connections_key *key,
key               200 source3/web/statuspage.c                         const struct connections_key *key,
key               225 source3/web/statuspage.c                         const struct connections_key *key,
key                54 source3/winbindd/idmap_hash/idmap_hash.h 			    char **key);
key                57 source3/winbindd/idmap_hash/idmap_hash.h 			      const char *key,
key                59 source3/winbindd/idmap_hash/mapfile.c static bool mapfile_read_line(fstring key, fstring value)
key                88 source3/winbindd/idmap_hash/mapfile.c 	fstrcpy(key, buffer);
key                93 source3/winbindd/idmap_hash/mapfile.c 	if (!trim_char(key, ' ', ' '))
key               120 source3/winbindd/idmap_hash/mapfile.c NTSTATUS mapfile_lookup_key(TALLOC_CTX *ctx, const char *value, char **key)
key               134 source3/winbindd/idmap_hash/mapfile.c 			*key = talloc_strdup(ctx, r_key);
key               135 source3/winbindd/idmap_hash/mapfile.c 			if (!*key) {
key               150 source3/winbindd/idmap_hash/mapfile.c NTSTATUS mapfile_lookup_value(TALLOC_CTX *ctx, const char *key, char **value)
key               160 source3/winbindd/idmap_hash/mapfile.c 		if (strequal(r_key, key)) {
key               165 source3/winbindd/idmap_hash/mapfile.c 			if (!*key) {
key                70 source3/winbindd/idmap_tdb.c 	DEBUG(10,("Converting %s\n", (const char *)rec->key.dptr));
key                72 source3/winbindd/idmap_tdb.c 	p = strchr((const char *)rec->key.dptr, '/');
key                77 source3/winbindd/idmap_tdb.c 	fstrcpy(dom_name, (const char *)rec->key.dptr);
key                84 source3/winbindd/idmap_tdb.c 		DEBUG(0,("deleting record %s\n", (const char *)rec->key.dptr ));
key                89 source3/winbindd/idmap_tdb.c 				(const char *)rec->key.dptr,
key               127 source3/winbindd/idmap_tdb.c 			(const char *)rec->key.dptr,
key              1138 source3/winbindd/idmap_tdb.c 	if (strncmp((const char *)rec->key.dptr, "S-", 2) == 0) {
key              1154 source3/winbindd/idmap_tdb.c 		if (!string_to_sid(maps[num_maps].sid, (const char *)rec->key.dptr)) {
key              1155 source3/winbindd/idmap_tdb.c 			DEBUG(10,("INVALID record %s\n", (const char *)rec->key.dptr));
key              1177 source3/winbindd/idmap_tdb.c 				(const char *)rec->key.dptr,
key               393 source3/winbindd/winbindd_cache.c 	fstring key;
key               401 source3/winbindd/winbindd_cache.c 	fstr_sprintf( key, "SEQNUM/%s", domain->name );
key               403 source3/winbindd/winbindd_cache.c 	data = tdb_fetch_bystring( wcache->tdb, key );
key               405 source3/winbindd/winbindd_cache.c 		DEBUG(10,("fetch_cache_seqnum: invalid data size key [%s]\n", key ));
key               592 source3/winbindd/winbindd_cache.c 	TDB_DATA key;
key               594 source3/winbindd/winbindd_cache.c 	key = string_tdb_data(kstr);
key               595 source3/winbindd/winbindd_cache.c 	data = tdb_fetch(wcache->tdb, key);
key               672 source3/winbindd/winbindd_cache.c 	TDB_DATA key;
key               678 source3/winbindd/winbindd_cache.c 	key = string_tdb_data(kstr);
key               680 source3/winbindd/winbindd_cache.c 	tdb_delete(wcache->tdb, key);
key               834 source3/winbindd/winbindd_cache.c 	TDB_DATA key, data;
key               844 source3/winbindd/winbindd_cache.c 	key = string_tdb_data(kstr);
key               848 source3/winbindd/winbindd_cache.c 	tdb_store(wcache->tdb, key, data, TDB_REPLACE);
key              2940 source3/winbindd/winbindd_cache.c 	TDB_DATA key;
key              3880 source3/winbindd/winbindd_cache.c 	TDB_DATA key = { NULL, 0 };
key              3884 source3/winbindd/winbindd_cache.c 		return key;
key              3889 source3/winbindd/winbindd_cache.c 		return key;
key              3891 source3/winbindd/winbindd_cache.c 	key = string_term_tdb_data(keystr);
key              3893 source3/winbindd/winbindd_cache.c 	return key;	
key              4024 source3/winbindd/winbindd_cache.c 	TDB_DATA key = make_tdc_key( lp_workgroup() );	 
key              4028 source3/winbindd/winbindd_cache.c 	if ( !key.dptr )
key              4034 source3/winbindd/winbindd_cache.c 		ret = tdb_delete( wcache->tdb, key );
key              4045 source3/winbindd/winbindd_cache.c 	ret = tdb_store( wcache->tdb, key, data, 0 );
key              4049 source3/winbindd/winbindd_cache.c 	SAFE_FREE( key.dptr );
key              4059 source3/winbindd/winbindd_cache.c 	TDB_DATA key = make_tdc_key( lp_workgroup() );
key              4065 source3/winbindd/winbindd_cache.c 	if ( !key.dptr )
key              4068 source3/winbindd/winbindd_cache.c 	data = tdb_fetch( wcache->tdb, key );
key              4070 source3/winbindd/winbindd_cache.c 	SAFE_FREE( key.dptr );
key               755 source3/winbindd/winbindd_pam.c 		       info3->base.key.key,
key               762 source3/winbindd/winbindd_pam.c 		       info3->base.LMSessKey.key,
key                92 source4/auth/auth_sam_reply.c 	ZERO_STRUCT(sam->key);
key                93 source4/auth/auth_sam_reply.c 	if (server_info->user_session_key.length == sizeof(sam->key.key)) {
key                94 source4/auth/auth_sam_reply.c 		memcpy(sam->key.key, server_info->user_session_key.data, sizeof(sam->key.key));
key                98 source4/auth/auth_sam_reply.c 	if (server_info->lm_session_key.length == sizeof(sam->LMSessKey.key)) {
key                99 source4/auth/auth_sam_reply.c 		memcpy(sam->LMSessKey.key, server_info->lm_session_key.data, 
key               100 source4/auth/auth_sam_reply.c 		       sizeof(sam->LMSessKey.key));
key               268 source4/auth/auth_sam_reply.c 	if (all_zero(base->key.key, sizeof(base->key.key))) {
key               271 source4/auth/auth_sam_reply.c 		server_info->user_session_key = data_blob_talloc(server_info, base->key.key, sizeof(base->key.key));
key               275 source4/auth/auth_sam_reply.c 	if (all_zero(base->LMSessKey.key, sizeof(base->LMSessKey.key))) {
key               278 source4/auth/auth_sam_reply.c 		server_info->lm_session_key = data_blob_talloc(server_info, base->LMSessKey.key, sizeof(base->LMSessKey.key));
key                34 source4/auth/kerberos/clikrb5.c 					krb5_keyblock *key,
key                47 source4/auth/kerberos/clikrb5.c 	ret = krb5_string_to_key(context, &eblock, key, password, &salt);
key                55 source4/auth/kerberos/clikrb5.c 					krb5_keyblock *key,
key                67 source4/auth/kerberos/clikrb5.c 				      salt, key);
key                78 source4/auth/kerberos/kerberos.h int create_kerberos_key_from_string(krb5_context context, krb5_principal host_princ, krb5_data *password, krb5_keyblock *key, krb5_enctype enctype);
key                79 source4/auth/kerberos/kerberos.h int create_kerberos_key_from_string_direct(krb5_context context, krb5_principal host_princ, krb5_data *password, krb5_keyblock *key, krb5_enctype enctype);
key               233 source4/dsdb/samdb/ldb_modules/password_hash.c 	krb5_keyblock key;
key               337 source4/dsdb/samdb/ldb_modules/password_hash.c 						&key);
key               346 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.data,
key               347 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.length);
key               348 source4/dsdb/samdb/ldb_modules/password_hash.c 	krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
key               362 source4/dsdb/samdb/ldb_modules/password_hash.c 						&key);
key               371 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.data,
key               372 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.length);
key               373 source4/dsdb/samdb/ldb_modules/password_hash.c 	krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
key               387 source4/dsdb/samdb/ldb_modules/password_hash.c 						&key);
key               396 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.data,
key               397 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.length);
key               398 source4/dsdb/samdb/ldb_modules/password_hash.c 	krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
key               412 source4/dsdb/samdb/ldb_modules/password_hash.c 						&key);
key               421 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.data,
key               422 source4/dsdb/samdb/ldb_modules/password_hash.c 					 key.keyvalue.length);
key               423 source4/dsdb/samdb/ldb_modules/password_hash.c 	krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
key               274 source4/heimdal/kdc/524.c 				&skey->key, ticket);
key               328 source4/heimdal/kdc/524.c     ret = krb5_crypto_init(context, &skey->key, 0, &crypto);
key                65 source4/heimdal/kdc/digest.c     Key *key;
key                72 source4/heimdal/kdc/digest.c 				 &key);
key                75 source4/heimdal/kdc/digest.c     return krb5_crypto_init(context, &key->key, 0, crypto);
key               335 source4/heimdal/kdc/digest.c 	krb5_keyblock *key;
key               337 source4/heimdal/kdc/digest.c 	ret = krb5_auth_con_getremotesubkey(context, ac, &key);
key               340 source4/heimdal/kdc/digest.c 	if (key == NULL) {
key               346 source4/heimdal/kdc/digest.c 	ret = krb5_crypto_init(context, key, 0, &crypto);
key               347 source4/heimdal/kdc/digest.c 	krb5_free_keyblock (context, key);
key               789 source4/heimdal/kdc/digest.c 	    Key *key = NULL;
key               862 source4/heimdal/kdc/digest.c 				  ETYPE_ARCFOUR_HMAC_MD5, &key);
key               871 source4/heimdal/kdc/digest.c 	    ret = heim_ntlm_calculate_ntlm1(key->key.keyvalue.data,
key               872 source4/heimdal/kdc/digest.c 					    key->key.keyvalue.length,
key               907 source4/heimdal/kdc/digest.c 		    MD4_Update(&hctx, key->key.keyvalue.data,
key               908 source4/heimdal/kdc/digest.c 			       key->key.keyvalue.length);
key              1110 source4/heimdal/kdc/digest.c 	Key *key = NULL;
key              1177 source4/heimdal/kdc/digest.c 			      ETYPE_ARCFOUR_HMAC_MD5, &key);
key              1205 source4/heimdal/kdc/digest.c 	    ret = heim_ntlm_verify_ntlm2(key->key.keyvalue.data,
key              1206 source4/heimdal/kdc/digest.c 					 key->key.keyvalue.length,
key              1259 source4/heimdal/kdc/digest.c 	    ret = heim_ntlm_calculate_ntlm1(key->key.keyvalue.data,
key              1260 source4/heimdal/kdc/digest.c 					    key->key.keyvalue.length,
key              1282 source4/heimdal/kdc/digest.c 			   key->key.keyvalue.data, key->key.keyvalue.length);
key              1401 source4/heimdal/kdc/digest.c 	krb5_keyblock *key;
key              1403 source4/heimdal/kdc/digest.c 	ret = krb5_auth_con_getlocalsubkey(context, ac, &key);
key              1407 source4/heimdal/kdc/digest.c 	ret = krb5_crypto_init(context, key, 0, &crypto);
key              1408 source4/heimdal/kdc/digest.c 	krb5_free_keyblock (context, key);
key               294 source4/heimdal/kdc/kaserver.c 		     krb5_keyblock *key,
key               322 source4/heimdal/kdc/kaserver.c 			    &skey->key,
key               368 source4/heimdal/kdc/kaserver.c 	memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               522 source4/heimdal/kdc/kaserver.c 	DES_cblock key;
key               526 source4/heimdal/kdc/kaserver.c 	memcpy (&key, ckey->key.keyvalue.data, sizeof(key));
key               527 source4/heimdal/kdc/kaserver.c 	DES_set_key_unchecked (&key, &schedule);
key               532 source4/heimdal/kdc/kaserver.c 			  &key,
key               535 source4/heimdal/kdc/kaserver.c 	memset (&key, 0, sizeof(key));
key               574 source4/heimdal/kdc/kaserver.c 			 &ckey->key, reply);
key               667 source4/heimdal/kdc/kaserver.c     DES_cblock key;
key               730 source4/heimdal/kdc/kaserver.c     memcpy (&key, kkey->key.keyvalue.data, sizeof(key));
key               737 source4/heimdal/kdc/kaserver.c 	ret = _krb5_krb_decomp_ticket(context, &aticket, &kkey->key,
key               298 source4/heimdal/kdc/kerberos4.c 				      &skey->key,
key               316 source4/heimdal/kdc/kerberos4.c 				    &ckey->key,
key               419 source4/heimdal/kdc/kerberos4.c 			       address, &tkey->key, &ad);
key               566 source4/heimdal/kdc/kerberos4.c 					  &skey->key,
key               703 source4/heimdal/kdc/kerberos4.c     if((et->key.keytype != ETYPE_DES_CBC_MD5 &&
key               704 source4/heimdal/kdc/kerberos4.c 	et->key.keytype != ETYPE_DES_CBC_MD4 &&
key               705 source4/heimdal/kdc/kerberos4.c 	et->key.keytype != ETYPE_DES_CBC_CRC) ||
key               706 source4/heimdal/kdc/kerberos4.c        et->key.keyvalue.length != 8)
key               708 source4/heimdal/kdc/kerberos4.c     krb5_storage_write(sp, et->key.keyvalue.data, 8);
key               749 source4/heimdal/kdc/kerberos4.c 	Key *key = NULL;
key               750 source4/heimdal/kdc/kerberos4.c 	while(hdb_next_enctype2key(context, &principal->entry, etypes[i], &key) == 0) {
key               751 source4/heimdal/kdc/kerberos4.c 	    if(key->salt == NULL) {
key               753 source4/heimdal/kdc/kerberos4.c 		    v5_key = key;
key               754 source4/heimdal/kdc/kerberos4.c 	    } else if(key->salt->type == hdb_pw_salt &&
key               755 source4/heimdal/kdc/kerberos4.c 		      key->salt->salt.length == 0) {
key               757 source4/heimdal/kdc/kerberos4.c 		    v4_key = key;
key               758 source4/heimdal/kdc/kerberos4.c 	    } else if(key->salt->type == hdb_afs3_salt) {
key               760 source4/heimdal/kdc/kerberos4.c 		    afs_key = key;
key               762 source4/heimdal/kdc/kerberos4.c 		server_key = key;
key               790 source4/heimdal/kdc/kerberos4.c     if((*ret_key)->key.keyvalue.length == 0)
key               110 source4/heimdal/kdc/kerberos5.c is_default_salt_p(const krb5_salt *default_salt, const Key *key)
key               112 source4/heimdal/kdc/kerberos5.c     if (key->salt == NULL)
key               114 source4/heimdal/kdc/kerberos5.c     if (default_salt->salttype != key->salt->type)
key               116 source4/heimdal/kdc/kerberos5.c     if (krb5_data_cmp(&default_salt->saltvalue, &key->salt->salt))
key               139 source4/heimdal/kdc/kerberos5.c 	Key *key = NULL;
key               145 source4/heimdal/kdc/kerberos5.c 	while (hdb_next_enctype2key(context, &princ->entry, etypes[i], &key) == 0) {
key               146 source4/heimdal/kdc/kerberos5.c 	    if (key->key.keyvalue.length == 0) {
key               150 source4/heimdal/kdc/kerberos5.c 	    *ret_key   = key;
key               153 source4/heimdal/kdc/kerberos5.c 	    if (is_default_salt_p(&def_salt, key)) {
key               414 source4/heimdal/kdc/kerberos5.c make_etype_info_entry(krb5_context context, ETYPE_INFO_ENTRY *ent, Key *key)
key               416 source4/heimdal/kdc/kerberos5.c     ent->etype = key->key.keytype;
key               417 source4/heimdal/kdc/kerberos5.c     if(key->salt){
key               421 source4/heimdal/kdc/kerberos5.c 	if(key->salt->type == hdb_pw_salt)
key               423 source4/heimdal/kdc/kerberos5.c 	else if(key->salt->type == hdb_afs3_salt)
key               427 source4/heimdal/kdc/kerberos5.c 		    key->salt->type);
key               437 source4/heimdal/kdc/kerberos5.c 	*ent->salttype = key->salt->type;
key               447 source4/heimdal/kdc/kerberos5.c 	krb5_copy_data(context, &key->salt->salt,
key               485 source4/heimdal/kdc/kerberos5.c 	    if (pa.val[j].etype == client->keys.val[i].key.keytype)
key               488 source4/heimdal/kdc/kerberos5.c 	    if(client->keys.val[i].key.keytype == etypes[j]) {
key               509 source4/heimdal/kdc/kerberos5.c 	    if(client->keys.val[i].key.keytype == etypes[j])
key               512 source4/heimdal/kdc/kerberos5.c 	if (krb5_enctype_valid(context, client->keys.val[i].key.keytype) != 0)
key               554 source4/heimdal/kdc/kerberos5.c make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent, Key *key)
key               556 source4/heimdal/kdc/kerberos5.c     ent->etype = key->key.keytype;
key               557 source4/heimdal/kdc/kerberos5.c     if(key->salt) {
key               561 source4/heimdal/kdc/kerberos5.c 	*ent->salt = malloc(key->salt->salt.length + 1);
key               567 source4/heimdal/kdc/kerberos5.c 	memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
key               568 source4/heimdal/kdc/kerberos5.c 	(*ent->salt)[key->salt->salt.length] = '\0';
key               574 source4/heimdal/kdc/kerberos5.c     switch (key->key.keytype) {
key               595 source4/heimdal/kdc/kerberos5.c 	if(key->salt && key->salt->type == hdb_afs3_salt){
key               646 source4/heimdal/kdc/kerberos5.c 	    if (pa.val[j].etype == client->keys.val[i].key.keytype)
key               649 source4/heimdal/kdc/kerberos5.c 	    if(client->keys.val[i].key.keytype == etypes[j]) {
key               668 source4/heimdal/kdc/kerberos5.c 	    if(client->keys.val[i].key.keytype == etypes[j])
key               671 source4/heimdal/kdc/kerberos5.c 	if (krb5_enctype_valid(context, client->keys.val[i].key.keytype) != 0)
key              1195 source4/heimdal/kdc/kerberos5.c 	    ret = krb5_crypto_init(context, &pa_key->key, 0, &crypto);
key              1212 source4/heimdal/kdc/kerberos5.c 					      pa_key->key.keytype, &str);
key              1278 source4/heimdal/kdc/kerberos5.c 	    ret = krb5_enctype_to_string(context,pa_key->key.keytype, &str);
key              1503 source4/heimdal/kdc/kerberos5.c     ret = krb5_generate_random_keyblock(context, sessionetype, &et.key);
key              1571 source4/heimdal/kdc/kerberos5.c     copy_EncryptionKey(&et.key, &ek.key);
key              1640 source4/heimdal/kdc/kerberos5.c     reply_key = &ckey->key;
key              1680 source4/heimdal/kdc/kerberos5.c 	ret = krb5_crypto_init(context, &et.key, 0, &crypto);
key              1730 source4/heimdal/kdc/kerberos5.c 				 &skey->key, /* Server key */
key              1731 source4/heimdal/kdc/kerberos5.c 				 &skey->key, /* FIXME: should be krbtgt key */
key              1765 source4/heimdal/kdc/kerberos5.c 			    &skey->key, client->entry.kvno,
key               140 source4/heimdal/kdc/krb5tgs.c 	Key *key;
key               141 source4/heimdal/kdc/krb5tgs.c 	ret = hdb_enctype2key(context, &krbtgt->entry, enctype, &key);
key               143 source4/heimdal/kdc/krb5tgs.c 	    ret = krb5_crypto_init(context, &key->key, 0, &crypto);
key               230 source4/heimdal/kdc/krb5tgs.c 	    Key *key;
key               231 source4/heimdal/kdc/krb5tgs.c 	    ret = hdb_enctype2key(context, &krbtgt->entry, sp.etype, &key);
key               233 source4/heimdal/kdc/krb5tgs.c 		ret = krb5_crypto_init(context, &key->key, 0, &crypto);
key               836 source4/heimdal/kdc/krb5tgs.c     ret = krb5_copy_keyblock_contents(context, sessionkey, &et.key);
key               842 source4/heimdal/kdc/krb5tgs.c     ek.key = et.key;
key               890 source4/heimdal/kdc/krb5tgs.c     if (krb5_enctype_valid(context, et.key.keytype) != 0
key               891 source4/heimdal/kdc/krb5tgs.c 	&& _kdc_is_weak_expection(server->entry.principal, et.key.keytype))
key               893 source4/heimdal/kdc/krb5tgs.c 	krb5_enctype_enable(context, et.key.keytype);
key               909 source4/heimdal/kdc/krb5tgs.c 			    &rep, &et, &ek, et.key.keytype,
key               911 source4/heimdal/kdc/krb5tgs.c 			    serverkey, 0, &tgt->key, e_text, reply);
key               913 source4/heimdal/kdc/krb5tgs.c 	krb5_enctype_disable(context, et.key.keytype);
key               927 source4/heimdal/kdc/krb5tgs.c     memset(et.key.keyvalue.data, 0, et.key.keyvalue.length);
key               928 source4/heimdal/kdc/krb5tgs.c     free_EncryptionKey(&et.key);
key               938 source4/heimdal/kdc/krb5tgs.c 			krb5_keyblock *key)
key               983 source4/heimdal/kdc/krb5tgs.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key              1160 source4/heimdal/kdc/krb5tgs.c 			      &tkey->key,
key              1197 source4/heimdal/kdc/krb5tgs.c 				  ac, b, e_text, &(*ticket)->ticket.key);
key              1440 source4/heimdal/kdc/krb5tgs.c 	ret = krb5_decrypt_ticket(context, t, &uukey->key, &adtkt, 0);
key              1575 source4/heimdal/kdc/krb5tgs.c 	    ekey = &adtkt.key;
key              1577 source4/heimdal/kdc/krb5tgs.c 		if (b->etype.val[i] == adtkt.key.keytype)
key              1597 source4/heimdal/kdc/krb5tgs.c 	    ekey = &skey->key;
key              1642 source4/heimdal/kdc/krb5tgs.c 		    client, server, ekey, &tkey->key,
key              1695 source4/heimdal/kdc/krb5tgs.c 	    ret = krb5_crypto_init(context, &tgt->key, 0, &crypto);
key              1798 source4/heimdal/kdc/krb5tgs.c 	ret = krb5_decrypt_ticket(context, t, &clientkey->key, &adtkt, 0);
key                64 source4/heimdal/kdc/kx509.c 		krb5_keyblock *key)
key                78 source4/heimdal/kdc/kx509.c 		 key->keyvalue.data, key->keyvalue.length,
key                97 source4/heimdal/kdc/kx509.c 		     krb5_keyblock *key,
key               105 source4/heimdal/kdc/kx509.c 		 key->keyvalue.data, key->keyvalue.length,
key               142 source4/heimdal/kdc/kx509.c 		  const krb5_data *key,
key               208 source4/heimdal/kdc/kx509.c 	spki.subjectPublicKey.data = key->data;
key               209 source4/heimdal/kdc/kx509.c 	spki.subjectPublicKey.length = key->length * 8;
key               304 source4/heimdal/kdc/kx509.c     krb5_keyblock *key = NULL;
key               366 source4/heimdal/kdc/kx509.c     ret = krb5_auth_con_getkey(context, ac, &key);
key               367 source4/heimdal/kdc/kx509.c     if (ret == 0 && key == NULL)
key               374 source4/heimdal/kdc/kx509.c     ret = verify_req_hash(context, req, key);
key               380 source4/heimdal/kdc/kx509.c 	RSAPublicKey key;
key               384 source4/heimdal/kdc/kx509.c 				  &key, &size);
key               387 source4/heimdal/kdc/kx509.c 	free_RSAPublicKey(&key);
key               407 source4/heimdal/kdc/kx509.c     ret = calculate_reply_hash(context, key, &rep);
key               453 source4/heimdal/kdc/kx509.c     if (key)
key               454 source4/heimdal/kdc/kx509.c 	krb5_free_keyblock (context, key);
key               101 source4/heimdal/kdc/misc.c 		       Key **key)
key               112 source4/heimdal/kdc/misc.c 	ret = hdb_enctype2key(context, &h->entry, p[i], key);
key               183 source4/heimdal/kdc/pkinit.c     krb5_keyblock key;
key               187 source4/heimdal/kdc/pkinit.c     memset(&key, 0, sizeof(key));
key               231 source4/heimdal/kdc/pkinit.c     if (key.keyvalue.data)
key               232 source4/heimdal/kdc/pkinit.c 	krb5_free_keyblock_contents(context, &key);
key                85 source4/heimdal/lib/asn1/hash.h #define hashtabdel(htab,key)  _hashtabdel(htab,key,FALSE)
key                87 source4/heimdal/lib/asn1/hash.h #define hashtabfree(htab,key) _hashtabdel(htab,key,TRUE) /* Do! */
key                78 source4/heimdal/lib/asn1/symbol.c     Symbol key, *s;
key                80 source4/heimdal/lib/asn1/symbol.c     key.name = name;
key                81 source4/heimdal/lib/asn1/symbol.c     s = (Symbol *) hashtabsearch(htab, (void *) &key);
key                79 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c     krb5_keyblock *key;
key                86 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c 	    key = ctx->auth_context->local_subkey;
key                88 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c 	    key = ctx->auth_context->remote_subkey;
key                91 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c 	    key = ctx->auth_context->remote_subkey;
key                93 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c 	    key = ctx->auth_context->local_subkey;
key                95 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c     if (key == NULL)
key                96 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c 	key = ctx->auth_context->keyblock;
key                98 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c     if (key == NULL)
key               101 source4/heimdal/lib/gssapi/krb5/accept_sec_context.c     switch (key->keytype) {
key                73 source4/heimdal/lib/gssapi/krb5/arcfour.c arcfour_mic_key(krb5_context context, krb5_keyblock *key,
key                91 source4/heimdal/lib/gssapi/krb5/arcfour.c     if (key->keytype == KEYTYPE_ARCFOUR_56) {
key                96 source4/heimdal/lib/gssapi/krb5/arcfour.c 			L40, 14, 0, key, &cksum_k5);
key               100 source4/heimdal/lib/gssapi/krb5/arcfour.c 			T, 4, 0, key, &cksum_k5);
key               118 source4/heimdal/lib/gssapi/krb5/arcfour.c 		  krb5_keyblock *key, unsigned usage,
key               142 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               172 source4/heimdal/lib/gssapi/krb5/arcfour.c 			krb5_keyblock *key)
key               206 source4/heimdal/lib/gssapi/krb5/arcfour.c 			    key, KRB5_KU_USAGE_SIGN,
key               217 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = arcfour_mic_key(context, key,
key               258 source4/heimdal/lib/gssapi/krb5/arcfour.c 			   krb5_keyblock *key,
key               287 source4/heimdal/lib/gssapi/krb5/arcfour.c 			    key, KRB5_KU_USAGE_SIGN,
key               297 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = arcfour_mic_key(context, key,
key               353 source4/heimdal/lib/gssapi/krb5/arcfour.c 		     krb5_keyblock *key)
key               430 source4/heimdal/lib/gssapi/krb5/arcfour.c 			    key, KRB5_KU_USAGE_SEAL,
key               445 source4/heimdal/lib/gssapi/krb5/arcfour.c 	Klocal.keytype = key->keytype;
key               450 source4/heimdal/lib/gssapi/krb5/arcfour.c 	    Klocaldata[i] = ((u_char *)key->keyvalue.data)[i] ^ 0xF0;
key               473 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = arcfour_mic_key(context, key,
key               505 source4/heimdal/lib/gssapi/krb5/arcfour.c 				 krb5_keyblock *key)
key               573 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = arcfour_mic_key(context, key,
key               605 source4/heimdal/lib/gssapi/krb5/arcfour.c 	Klocal.keytype = key->keytype;
key               610 source4/heimdal/lib/gssapi/krb5/arcfour.c 	    Klocaldata[i] = ((u_char *)key->keyvalue.data)[i] ^ 0xF0;
key               655 source4/heimdal/lib/gssapi/krb5/arcfour.c 			    key, KRB5_KU_USAGE_SEAL,
key               738 source4/heimdal/lib/gssapi/krb5/arcfour.c 			  krb5_keyblock *key)
key               743 source4/heimdal/lib/gssapi/krb5/arcfour.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               172 source4/heimdal/lib/gssapi/krb5/cfx.c 				krb5_keyblock *key)
key               177 source4/heimdal/lib/gssapi/krb5/cfx.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               248 source4/heimdal/lib/gssapi/krb5/cfx.c 			   krb5_keyblock *key)
key               260 source4/heimdal/lib/gssapi/krb5/cfx.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               474 source4/heimdal/lib/gssapi/krb5/cfx.c 			     krb5_keyblock *key)
key               553 source4/heimdal/lib/gssapi/krb5/cfx.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               696 source4/heimdal/lib/gssapi/krb5/cfx.c 			  krb5_keyblock *key)
key               707 source4/heimdal/lib/gssapi/krb5/cfx.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               788 source4/heimdal/lib/gssapi/krb5/cfx.c 				 krb5_keyblock *key)
key               854 source4/heimdal/lib/gssapi/krb5/cfx.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                46 source4/heimdal/lib/gssapi/krb5/get_mic.c 	    krb5_keyblock *key
key                90 source4/heimdal/lib/gssapi/krb5/get_mic.c   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               135 source4/heimdal/lib/gssapi/krb5/get_mic.c 	    krb5_keyblock *key
key               185 source4/heimdal/lib/gssapi/krb5/get_mic.c   kret = krb5_crypto_init(context, key, 0, &crypto);
key               228 source4/heimdal/lib/gssapi/krb5/get_mic.c   kret = krb5_crypto_init(context, key,
key               281 source4/heimdal/lib/gssapi/krb5/get_mic.c   krb5_keyblock *key;
key               288 source4/heimdal/lib/gssapi/krb5/get_mic.c   ret = _gsskrb5i_get_token_key(ctx, context, &key);
key               294 source4/heimdal/lib/gssapi/krb5/get_mic.c   krb5_enctype_to_keytype (context, key->keytype, &keytype);
key               299 source4/heimdal/lib/gssapi/krb5/get_mic.c 		     message_buffer, message_token, key);
key               303 source4/heimdal/lib/gssapi/krb5/get_mic.c 		      message_buffer, message_token, key);
key               308 source4/heimdal/lib/gssapi/krb5/get_mic.c 				     message_buffer, message_token, key);
key               312 source4/heimdal/lib/gssapi/krb5/get_mic.c 			     message_buffer, message_token, key);
key               315 source4/heimdal/lib/gssapi/krb5/get_mic.c   krb5_free_keyblock (context, key);
key               764 source4/heimdal/lib/gssapi/krb5/init_sec_context.c 	krb5_keyblock *key = NULL;
key               768 source4/heimdal/lib/gssapi/krb5/init_sec_context.c 					     &key);
key               769 source4/heimdal/lib/gssapi/krb5/init_sec_context.c 	if (kret == 0 && key != NULL) {
key               771 source4/heimdal/lib/gssapi/krb5/init_sec_context.c 	    krb5_free_keyblock (context, key);
key               113 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     krb5_keyblock *key = NULL;
key               131 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	ret = _gsskrb5i_get_acceptor_subkey(context_handle, context, &key);
key               134 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	ret = _gsskrb5i_get_initiator_subkey(context_handle, context, &key);
key               137 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	ret = _gsskrb5i_get_token_key(context_handle, context, &key);
key               147 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     if (key == NULL) {
key               153 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     ret = krb5_store_keyblock(sp, *key);
key               154 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     krb5_free_keyblock (context, key);
key               276 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     krb5_keyblock *key = NULL;
key               317 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     ret = _gsskrb5i_get_token_key(context_handle, context, &key);
key               323 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	switch (key->keytype) {
key               350 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	ret = krb5_store_keyblock(sp, *key);
key               359 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	ret = krb5_store_keyblock(sp, *key);
key               363 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	    ret = krb5_store_keyblock(sp, *key);
key               383 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c     if (key)
key               384 source4/heimdal/lib/gssapi/krb5/inquire_sec_context_by_oid.c 	krb5_free_keyblock (context, key);
key                53 source4/heimdal/lib/gssapi/krb5/prf.c     krb5_keyblock *key = NULL;
key                69 source4/heimdal/lib/gssapi/krb5/prf.c 	_gsskrb5i_get_acceptor_subkey(ctx, context, &key);
key                72 source4/heimdal/lib/gssapi/krb5/prf.c 	_gsskrb5i_get_initiator_subkey(ctx, context, &key);
key                80 source4/heimdal/lib/gssapi/krb5/prf.c     if (key == NULL) {
key                86 source4/heimdal/lib/gssapi/krb5/prf.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                87 source4/heimdal/lib/gssapi/krb5/prf.c     krb5_free_keyblock (context, key);
key                46 source4/heimdal/lib/gssapi/krb5/unwrap.c 	    krb5_keyblock *key
key                99 source4/heimdal/lib/gssapi/krb5/unwrap.c       memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               133 source4/heimdal/lib/gssapi/krb5/unwrap.c   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               195 source4/heimdal/lib/gssapi/krb5/unwrap.c 	    krb5_keyblock *key
key               249 source4/heimdal/lib/gssapi/krb5/unwrap.c       ret = krb5_crypto_init(context, key,
key               285 source4/heimdal/lib/gssapi/krb5/unwrap.c   ret = krb5_crypto_init(context, key,
key               349 source4/heimdal/lib/gssapi/krb5/unwrap.c   ret = krb5_crypto_init(context, key, 0, &crypto);
key               388 source4/heimdal/lib/gssapi/krb5/unwrap.c   krb5_keyblock *key;
key               402 source4/heimdal/lib/gssapi/krb5/unwrap.c   ret = _gsskrb5i_get_token_key(ctx, context, &key);
key               408 source4/heimdal/lib/gssapi/krb5/unwrap.c   krb5_enctype_to_keytype (context, key->keytype, &keytype);
key               416 source4/heimdal/lib/gssapi/krb5/unwrap.c 			conf_state, qop_state, key);
key               421 source4/heimdal/lib/gssapi/krb5/unwrap.c 			 conf_state, qop_state, key);
key               427 source4/heimdal/lib/gssapi/krb5/unwrap.c 				    conf_state, qop_state, key);
key               432 source4/heimdal/lib/gssapi/krb5/unwrap.c 				conf_state, qop_state, key);
key               435 source4/heimdal/lib/gssapi/krb5/unwrap.c   krb5_free_keyblock (context, key);
key                46 source4/heimdal/lib/gssapi/krb5/verify_mic.c 	    krb5_keyblock *key,
key                84 source4/heimdal/lib/gssapi/krb5/verify_mic.c   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               139 source4/heimdal/lib/gssapi/krb5/verify_mic.c 	    krb5_keyblock *key,
key               169 source4/heimdal/lib/gssapi/krb5/verify_mic.c   ret = krb5_crypto_init(context, key,
key               277 source4/heimdal/lib/gssapi/krb5/verify_mic.c     krb5_keyblock *key;
key               282 source4/heimdal/lib/gssapi/krb5/verify_mic.c     ret = _gsskrb5i_get_token_key(context_handle, context, &key);
key               289 source4/heimdal/lib/gssapi/krb5/verify_mic.c     krb5_enctype_to_keytype (context, key->keytype, &keytype);
key               293 source4/heimdal/lib/gssapi/krb5/verify_mic.c 			      message_buffer, token_buffer, qop_state, key,
key               298 source4/heimdal/lib/gssapi/krb5/verify_mic.c 			       message_buffer, token_buffer, qop_state, key,
key               306 source4/heimdal/lib/gssapi/krb5/verify_mic.c 					  qop_state, key, type);
key               312 source4/heimdal/lib/gssapi/krb5/verify_mic.c 				      key);
key               315 source4/heimdal/lib/gssapi/krb5/verify_mic.c     krb5_free_keyblock (context, key);
key                45 source4/heimdal/lib/gssapi/krb5/wrap.c 			       krb5_keyblock **key)
key                48 source4/heimdal/lib/gssapi/krb5/wrap.c     *key = NULL;
key                53 source4/heimdal/lib/gssapi/krb5/wrap.c 				     key);
key                57 source4/heimdal/lib/gssapi/krb5/wrap.c 				      key);
key                59 source4/heimdal/lib/gssapi/krb5/wrap.c     if (ret == 0 && *key == NULL)
key                62 source4/heimdal/lib/gssapi/krb5/wrap.c 				   key);
key                63 source4/heimdal/lib/gssapi/krb5/wrap.c     if (ret == 0 && *key == NULL) {
key                73 source4/heimdal/lib/gssapi/krb5/wrap.c 			      krb5_keyblock **key)
key                76 source4/heimdal/lib/gssapi/krb5/wrap.c     *key = NULL;
key                81 source4/heimdal/lib/gssapi/krb5/wrap.c 				      key);
key                85 source4/heimdal/lib/gssapi/krb5/wrap.c 				     key);
key                87 source4/heimdal/lib/gssapi/krb5/wrap.c     if (ret == 0 && *key == NULL) {
key                97 source4/heimdal/lib/gssapi/krb5/wrap.c 			krb5_keyblock **key)
key                99 source4/heimdal/lib/gssapi/krb5/wrap.c     _gsskrb5i_get_acceptor_subkey(ctx, context, key);
key               100 source4/heimdal/lib/gssapi/krb5/wrap.c     if(*key == NULL) {
key               106 source4/heimdal/lib/gssapi/krb5/wrap.c 	    _gsskrb5i_get_initiator_subkey(ctx, context, key);
key               108 source4/heimdal/lib/gssapi/krb5/wrap.c     if (*key == NULL) {
key               150 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_keyblock *key;
key               158 source4/heimdal/lib/gssapi/krb5/wrap.c   ret = _gsskrb5i_get_token_key(ctx, context, &key);
key               164 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_enctype_to_keytype (context, key->keytype, &keytype);
key               174 source4/heimdal/lib/gssapi/krb5/wrap.c 				      req_output_size, max_input_size, key);
key               182 source4/heimdal/lib/gssapi/krb5/wrap.c 				  req_output_size, max_input_size, key);
key               185 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_free_keyblock (context, key);
key               200 source4/heimdal/lib/gssapi/krb5/wrap.c 	    krb5_keyblock *key
key               270 source4/heimdal/lib/gssapi/krb5/wrap.c   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               304 source4/heimdal/lib/gssapi/krb5/wrap.c       memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
key               336 source4/heimdal/lib/gssapi/krb5/wrap.c 	    krb5_keyblock *key
key               396 source4/heimdal/lib/gssapi/krb5/wrap.c   ret = krb5_crypto_init(context, key, 0, &crypto);
key               442 source4/heimdal/lib/gssapi/krb5/wrap.c   ret = krb5_crypto_init(context, key, ETYPE_DES3_CBC_NONE,
key               487 source4/heimdal/lib/gssapi/krb5/wrap.c       ret = krb5_crypto_init(context, key,
key               528 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_keyblock *key;
key               536 source4/heimdal/lib/gssapi/krb5/wrap.c   ret = _gsskrb5i_get_token_key(ctx, context, &key);
key               542 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_enctype_to_keytype (context, key->keytype, &keytype);
key               548 source4/heimdal/lib/gssapi/krb5/wrap.c 		      output_message_buffer, key);
key               553 source4/heimdal/lib/gssapi/krb5/wrap.c 		       output_message_buffer, key);
key               559 source4/heimdal/lib/gssapi/krb5/wrap.c 				  output_message_buffer, key);
key               564 source4/heimdal/lib/gssapi/krb5/wrap.c 			      output_message_buffer, key);
key               567 source4/heimdal/lib/gssapi/krb5/wrap.c   krb5_free_keyblock (context, key);
key               244 source4/heimdal/lib/gssapi/mech/gss_krb5.c set_key(krb5_keyblock *keyblock, gss_krb5_lucid_key_t *key)
key               246 source4/heimdal/lib/gssapi/mech/gss_krb5.c     key->type = keyblock->keytype;
key               247 source4/heimdal/lib/gssapi/mech/gss_krb5.c     key->length = keyblock->keyvalue.length;
key               248 source4/heimdal/lib/gssapi/mech/gss_krb5.c     key->data = malloc(key->length);
key               249 source4/heimdal/lib/gssapi/mech/gss_krb5.c     if (key->data == NULL && key->length != 0)
key               251 source4/heimdal/lib/gssapi/mech/gss_krb5.c     memcpy(key->data, keyblock->keyvalue.data, key->length);
key               256 source4/heimdal/lib/gssapi/mech/gss_krb5.c free_key(gss_krb5_lucid_key_t *key)
key               258 source4/heimdal/lib/gssapi/mech/gss_krb5.c     memset(key->data, 0, key->length);
key               259 source4/heimdal/lib/gssapi/mech/gss_krb5.c     free(key->data);
key               260 source4/heimdal/lib/gssapi/mech/gss_krb5.c     memset(key, 0, sizeof(*key));
key               347 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	krb5_keyblock key;
key               356 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	ret = krb5_ret_keyblock(sp, &key);
key               358 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	ret = set_key(&key, &ctx->rfc1964_kd.ctx_key);
key               359 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	krb5_free_keyblock_contents(context, &key);
key               362 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	krb5_keyblock key;
key               368 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	ret = krb5_ret_keyblock(sp, &key);
key               370 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	ret = set_key(&key, &ctx->cfx_kd.ctx_key);
key               371 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	krb5_free_keyblock_contents(context, &key);
key               375 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	    ret = krb5_ret_keyblock(sp, &key);
key               377 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	    ret = set_key(&key, &ctx->cfx_kd.acceptor_subkey);
key               378 source4/heimdal/lib/gssapi/mech/gss_krb5.c 	    krb5_free_keyblock_contents(context, &key);
key                50 source4/heimdal/lib/hcrypto/aes.c AES_set_encrypt_key(const unsigned char *userkey, const int bits, AES_KEY *key)
key                52 source4/heimdal/lib/hcrypto/aes.c     key->rounds = rijndaelKeySetupEnc(key->key, userkey, bits);
key                53 source4/heimdal/lib/hcrypto/aes.c     if (key->rounds == 0)
key                59 source4/heimdal/lib/hcrypto/aes.c AES_set_decrypt_key(const unsigned char *userkey, const int bits, AES_KEY *key)
key                61 source4/heimdal/lib/hcrypto/aes.c     key->rounds = rijndaelKeySetupDec(key->key, userkey, bits);
key                62 source4/heimdal/lib/hcrypto/aes.c     if (key->rounds == 0)
key                68 source4/heimdal/lib/hcrypto/aes.c AES_encrypt(const unsigned char *in, unsigned char *out, const AES_KEY *key)
key                70 source4/heimdal/lib/hcrypto/aes.c     rijndaelEncrypt(key->key, key->rounds, in, out);
key                74 source4/heimdal/lib/hcrypto/aes.c AES_decrypt(const unsigned char *in, unsigned char *out, const AES_KEY *key)
key                76 source4/heimdal/lib/hcrypto/aes.c     rijndaelDecrypt(key->key, key->rounds, in, out);
key                81 source4/heimdal/lib/hcrypto/aes.c 		unsigned long size, const AES_KEY *key,
key                91 source4/heimdal/lib/hcrypto/aes.c 	    AES_encrypt(tmp, out, key);
key               102 source4/heimdal/lib/hcrypto/aes.c 	    AES_encrypt(tmp, out, key);
key               108 source4/heimdal/lib/hcrypto/aes.c 	    AES_decrypt(tmp, out, key);
key               118 source4/heimdal/lib/hcrypto/aes.c 	    AES_decrypt(tmp, out, key);
key                57 source4/heimdal/lib/hcrypto/aes.h     uint32_t key[(AES_MAXNR+1)*4];
key               450 source4/heimdal/lib/hcrypto/camellia-ntt.c static void camellia_setup128(const unsigned char *key, u32 *subkey)
key               461 source4/heimdal/lib/hcrypto/camellia-ntt.c     kll = GETU32(key     );
key               462 source4/heimdal/lib/hcrypto/camellia-ntt.c     klr = GETU32(key +  4);
key               463 source4/heimdal/lib/hcrypto/camellia-ntt.c     krl = GETU32(key +  8);
key               464 source4/heimdal/lib/hcrypto/camellia-ntt.c     krr = GETU32(key + 12);
key               661 source4/heimdal/lib/hcrypto/camellia-ntt.c static void camellia_setup256(const unsigned char *key, u32 *subkey)
key               675 source4/heimdal/lib/hcrypto/camellia-ntt.c     kll  = GETU32(key     );
key               676 source4/heimdal/lib/hcrypto/camellia-ntt.c     klr  = GETU32(key +  4);
key               677 source4/heimdal/lib/hcrypto/camellia-ntt.c     krl  = GETU32(key +  8);
key               678 source4/heimdal/lib/hcrypto/camellia-ntt.c     krr  = GETU32(key + 12);
key               679 source4/heimdal/lib/hcrypto/camellia-ntt.c     krll = GETU32(key + 16);
key               680 source4/heimdal/lib/hcrypto/camellia-ntt.c     krlr = GETU32(key + 20);
key               681 source4/heimdal/lib/hcrypto/camellia-ntt.c     krrl = GETU32(key + 24);
key               682 source4/heimdal/lib/hcrypto/camellia-ntt.c     krrr = GETU32(key + 28);
key               947 source4/heimdal/lib/hcrypto/camellia-ntt.c static void camellia_setup192(const unsigned char *key, u32 *subkey)
key               952 source4/heimdal/lib/hcrypto/camellia-ntt.c     memcpy(kk, key, 24);
key               953 source4/heimdal/lib/hcrypto/camellia-ntt.c     memcpy((unsigned char *)&krll, key+16,4);
key               954 source4/heimdal/lib/hcrypto/camellia-ntt.c     memcpy((unsigned char *)&krlr, key+20,4);
key                53 source4/heimdal/lib/hcrypto/camellia.c 		 const int bits, CAMELLIA_KEY *key)
key                55 source4/heimdal/lib/hcrypto/camellia.c     key->bits = bits;
key                56 source4/heimdal/lib/hcrypto/camellia.c     Camellia_Ekeygen(bits, userkey, key->key);
key                62 source4/heimdal/lib/hcrypto/camellia.c 		 const CAMELLIA_KEY *key)
key                64 source4/heimdal/lib/hcrypto/camellia.c     Camellia_EncryptBlock(key->bits, in, key->key, out);
key                70 source4/heimdal/lib/hcrypto/camellia.c 		 const CAMELLIA_KEY *key)
key                72 source4/heimdal/lib/hcrypto/camellia.c     Camellia_DecryptBlock(key->bits, in, key->key, out);
key                77 source4/heimdal/lib/hcrypto/camellia.c 		     unsigned long size, const CAMELLIA_KEY *key,
key                87 source4/heimdal/lib/hcrypto/camellia.c 	    CAMELLIA_encrypt(tmp, out, key);
key                98 source4/heimdal/lib/hcrypto/camellia.c 	    CAMELLIA_encrypt(tmp, out, key);
key               104 source4/heimdal/lib/hcrypto/camellia.c 	    CAMELLIA_decrypt(tmp, out, key);
key               114 source4/heimdal/lib/hcrypto/camellia.c 	    CAMELLIA_decrypt(tmp, out, key);
key                58 source4/heimdal/lib/hcrypto/camellia.h     uint32_t key[CAMELLIA_TABLE_WORD_LEN];
key               123 source4/heimdal/lib/hcrypto/des.c DES_set_odd_parity(DES_cblock *key)
key               127 source4/heimdal/lib/hcrypto/des.c 	(*key)[i] = odd_parity[(*key)[i]];
key               139 source4/heimdal/lib/hcrypto/des.c DES_check_key_parity(DES_cblock *key)
key               144 source4/heimdal/lib/hcrypto/des.c 	if ((*key)[i] != odd_parity[(*key)[i]])
key               184 source4/heimdal/lib/hcrypto/des.c DES_is_weak_key(DES_cblock *key)
key               189 source4/heimdal/lib/hcrypto/des.c 	if (memcmp(weak_keys[i], key, DES_CBLOCK_LEN) == 0)
key               207 source4/heimdal/lib/hcrypto/des.c DES_set_key(DES_cblock *key, DES_key_schedule *ks)
key               209 source4/heimdal/lib/hcrypto/des.c     return DES_set_key_checked(key, ks);
key               226 source4/heimdal/lib/hcrypto/des.c DES_set_key_unchecked(DES_cblock *key, DES_key_schedule *ks)
key               234 source4/heimdal/lib/hcrypto/des.c     t1 = (*key)[0] << 24 | (*key)[1] << 16 | (*key)[2] << 8 | (*key)[3];
key               235 source4/heimdal/lib/hcrypto/des.c     t2 = (*key)[4] << 24 | (*key)[5] << 16 | (*key)[6] << 8 | (*key)[7];
key               297 source4/heimdal/lib/hcrypto/des.c DES_set_key_checked(DES_cblock *key, DES_key_schedule *ks)
key               299 source4/heimdal/lib/hcrypto/des.c     if (!DES_check_key_parity(key)) {
key               303 source4/heimdal/lib/hcrypto/des.c     if (DES_is_weak_key(key)) {
key               307 source4/heimdal/lib/hcrypto/des.c     return DES_set_key_unchecked(key, ks);
key               322 source4/heimdal/lib/hcrypto/des.c DES_key_sched(DES_cblock *key, DES_key_schedule *ks)
key               324 source4/heimdal/lib/hcrypto/des.c     return DES_set_key_checked(key, ks);
key               830 source4/heimdal/lib/hcrypto/des.c DES_string_to_key(const char *str, DES_cblock *key)
key               837 source4/heimdal/lib/hcrypto/des.c     memset(key, 0, sizeof(*key));
key               838 source4/heimdal/lib/hcrypto/des.c     k = *key;
key               848 source4/heimdal/lib/hcrypto/des.c     DES_set_odd_parity(key);
key               849 source4/heimdal/lib/hcrypto/des.c     if (DES_is_weak_key(key))
key               851 source4/heimdal/lib/hcrypto/des.c     DES_set_key(key, &ks);
key               852 source4/heimdal/lib/hcrypto/des.c     DES_cbc_cksum(s, key, len, &ks, key);
key               854 source4/heimdal/lib/hcrypto/des.c     DES_set_odd_parity(key);
key               855 source4/heimdal/lib/hcrypto/des.c     if (DES_is_weak_key(key))
key               872 source4/heimdal/lib/hcrypto/des.c DES_read_password(DES_cblock *key, char *prompt, int verify)
key               879 source4/heimdal/lib/hcrypto/des.c 	DES_string_to_key(buf, key);
key                79 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	     const unsigned char * key,
key                85 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
key                87 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
key                93 source4/heimdal/lib/hcrypto/evp-aes-cts.c 		      size_t len, const AES_KEY *key,
key               109 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	    AES_encrypt(tmp, out, key);
key               121 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	AES_encrypt(tmp, out - AES_BLOCK_SIZE, key);
key               132 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	    AES_decrypt(in, out, key);
key               144 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	AES_decrypt(in, tmp2, key);
key               152 source4/heimdal/lib/hcrypto/evp-aes-cts.c 	AES_decrypt(tmp3, out, key);
key                60 source4/heimdal/lib/hcrypto/evp-hcrypto.c 	 const unsigned char * key,
key                66 source4/heimdal/lib/hcrypto/evp-hcrypto.c 	AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
key                68 source4/heimdal/lib/hcrypto/evp-hcrypto.c 	AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
key               766 source4/heimdal/lib/hcrypto/evp.c 		  const void *key, const void *iv, int encp)
key               805 source4/heimdal/lib/hcrypto/evp.c     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
key               806 source4/heimdal/lib/hcrypto/evp.c 	ctx->cipher->init(ctx, key, iv, encp);
key               965 source4/heimdal/lib/hcrypto/evp.c 		  const unsigned char * key,
key              1023 source4/heimdal/lib/hcrypto/evp.c     RC2_KEY key;
key              1028 source4/heimdal/lib/hcrypto/evp.c 	 const unsigned char * key,
key              1034 source4/heimdal/lib/hcrypto/evp.c     RC2_set_key(&k->key,
key              1036 source4/heimdal/lib/hcrypto/evp.c 		key,
key              1048 source4/heimdal/lib/hcrypto/evp.c     RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
key              1184 source4/heimdal/lib/hcrypto/evp.c 	     const unsigned char * key,
key              1190 source4/heimdal/lib/hcrypto/evp.c     memcpy(&deskey, key, sizeof(deskey));
key              1253 source4/heimdal/lib/hcrypto/evp.c 		  const unsigned char * key,
key              1260 source4/heimdal/lib/hcrypto/evp.c     memcpy(&deskey, key, sizeof(deskey));
key              1264 source4/heimdal/lib/hcrypto/evp.c     memcpy(&deskey, key + 8, sizeof(deskey));
key              1268 source4/heimdal/lib/hcrypto/evp.c     memcpy(&deskey, key + 16, sizeof(deskey));
key              1368 source4/heimdal/lib/hcrypto/evp.c 	 const unsigned char * key,
key              1374 source4/heimdal/lib/hcrypto/evp.c     CAMELLIA_set_key(key, ctx->cipher->key_len * 8, k);
key              1561 source4/heimdal/lib/hcrypto/evp.c     unsigned char *key = keydata;
key              1604 source4/heimdal/lib/hcrypto/evp.c 	    if (key) {
key              1605 source4/heimdal/lib/hcrypto/evp.c 		memcpy(key, buf, sz);
key              1606 source4/heimdal/lib/hcrypto/evp.c 		key += sz;
key              1641 source4/heimdal/lib/hcrypto/evp.c EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, void *key)
key              1644 source4/heimdal/lib/hcrypto/evp.c 	return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
key              1645 source4/heimdal/lib/hcrypto/evp.c     if (RAND_bytes(key, ctx->key_len) != 1)
key                78 source4/heimdal/lib/hcrypto/hmac.c 	     const void *key,
key               100 source4/heimdal/lib/hcrypto/hmac.c 	EVP_Digest(key, keylen, ctx->buf, NULL, ctx->md, engine);
key               101 source4/heimdal/lib/hcrypto/hmac.c 	key = ctx->buf;
key               120 source4/heimdal/lib/hcrypto/hmac.c 	p[i] ^= ((const unsigned char *)key)[i];
key               122 source4/heimdal/lib/hcrypto/hmac.c 	p[i] ^= ((const unsigned char *)key)[i];
key               149 source4/heimdal/lib/hcrypto/hmac.c      const void *key, size_t key_size,
key               156 source4/heimdal/lib/hcrypto/hmac.c     HMAC_Init_ex(&ctx, key, key_size, md, NULL);
key                79 source4/heimdal/lib/hcrypto/hmac.h void *	HMAC(const EVP_MD *evp_md, const void *key, size_t key_len,
key                50 source4/heimdal/lib/hcrypto/pkcs12.c PKCS12_key_gen(const void *key, size_t keylen,
key                90 source4/heimdal/lib/hcrypto/pkcs12.c     if (key && keylen >= 0) {
key                93 source4/heimdal/lib/hcrypto/pkcs12.c 	    I[(i * 2) + size_I + 1] = ((unsigned char*)key)[i % (keylen + 1)];
key                72 source4/heimdal/lib/hcrypto/pkcs5.c 		       size_t keylen, void *key)
key                97 source4/heimdal/lib/hcrypto/pkcs5.c     p = key;
key               113 source4/heimdal/lib/hcrypto/rand-fortuna.c     unsigned char	key[BLOCK];
key               135 source4/heimdal/lib/hcrypto/rand-fortuna.c ciph_init(CIPH_CTX * ctx, const unsigned char *key, int klen)
key               137 source4/heimdal/lib/hcrypto/rand-fortuna.c     AES_set_encrypt_key(key, klen * 8, ctx);
key               279 source4/heimdal/lib/hcrypto/rand-fortuna.c     md_update(&key_md, st->key, BLOCK);
key               285 source4/heimdal/lib/hcrypto/rand-fortuna.c     md_result(&key_md, st->key);
key               288 source4/heimdal/lib/hcrypto/rand-fortuna.c     ciph_init(&st->ciph, st->key, BLOCK);
key               305 source4/heimdal/lib/hcrypto/rand-fortuna.c     rnd = st->key[st->rnd_pos] % NUM_POOLS;
key               351 source4/heimdal/lib/hcrypto/rand-fortuna.c     encrypt_counter(st, st->key);
key               352 source4/heimdal/lib/hcrypto/rand-fortuna.c     encrypt_counter(st, st->key + CIPH_BLOCK);
key               353 source4/heimdal/lib/hcrypto/rand-fortuna.c     ciph_init(&st->ciph, st->key, BLOCK);
key                85 source4/heimdal/lib/hcrypto/rc2.c RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, int bits)
key               112 source4/heimdal/lib/hcrypto/rc2.c 	key->data[j] = k[(j * 2) + 0] | (k[(j * 2) + 1] << 8);	
key               120 source4/heimdal/lib/hcrypto/rc2.c RC2_encryptc(unsigned char *in, unsigned char *out, const RC2_KEY *key)
key               133 source4/heimdal/lib/hcrypto/rc2.c 	t0 = (w0 + (w1 & ~w3) + (w2 & w3) + key->data[j + 0]) & 0xffff;
key               135 source4/heimdal/lib/hcrypto/rc2.c 	t1 = (w1 + (w2 & ~w0) + (w3 & w0) + key->data[j + 1]) & 0xffff;
key               137 source4/heimdal/lib/hcrypto/rc2.c 	t2 = (w2 + (w3 & ~w1) + (w0 & w1) + key->data[j + 2]) & 0xffff;
key               139 source4/heimdal/lib/hcrypto/rc2.c 	t3 = (w3 + (w0 & ~w2) + (w1 & w2) + key->data[j + 3]) & 0xffff;
key               142 source4/heimdal/lib/hcrypto/rc2.c 	    w0 += key->data[w3 & 63];
key               143 source4/heimdal/lib/hcrypto/rc2.c 	    w1 += key->data[w0 & 63];
key               144 source4/heimdal/lib/hcrypto/rc2.c 	    w2 += key->data[w1 & 63];
key               145 source4/heimdal/lib/hcrypto/rc2.c 	    w3 += key->data[w2 & 63];
key               160 source4/heimdal/lib/hcrypto/rc2.c RC2_decryptc(unsigned char *in, unsigned char *out, const RC2_KEY *key)
key               175 source4/heimdal/lib/hcrypto/rc2.c 	    w3 = (w3 - key->data[w2 & 63]) & 0xffff;
key               176 source4/heimdal/lib/hcrypto/rc2.c 	    w2 = (w2 - key->data[w1 & 63]) & 0xffff;
key               177 source4/heimdal/lib/hcrypto/rc2.c 	    w1 = (w1 - key->data[w0 & 63]) & 0xffff;
key               178 source4/heimdal/lib/hcrypto/rc2.c 	    w0 = (w0 - key->data[w3 & 63]) & 0xffff;
key               182 source4/heimdal/lib/hcrypto/rc2.c 	w3 = (t3 - (w0 & ~w2) - (w1 & w2) - key->data[j + 3]) & 0xffff;
key               184 source4/heimdal/lib/hcrypto/rc2.c 	w2 = (t2 - (w3 & ~w1) - (w0 & w1) - key->data[j + 2]) & 0xffff;
key               186 source4/heimdal/lib/hcrypto/rc2.c 	w1 = (t1 - (w2 & ~w0) - (w3 & w0) - key->data[j + 1]) & 0xffff;
key               188 source4/heimdal/lib/hcrypto/rc2.c 	w0 = (t0 - (w1 & ~w3) - (w2 & w3) - key->data[j + 0]) & 0xffff;
key               203 source4/heimdal/lib/hcrypto/rc2.c 		RC2_KEY *key, unsigned char *iv, int forward_encrypt)
key               212 source4/heimdal/lib/hcrypto/rc2.c 	    RC2_encryptc(tmp, out, key);
key               223 source4/heimdal/lib/hcrypto/rc2.c 	    RC2_encryptc(tmp, out, key);
key               229 source4/heimdal/lib/hcrypto/rc2.c 	    RC2_decryptc(tmp, out, key);
key               239 source4/heimdal/lib/hcrypto/rc2.c 	    RC2_decryptc(tmp, out, key);
key                52 source4/heimdal/lib/hcrypto/rc4.c RC4_set_key(RC4_KEY *key, const int len, unsigned char *data)
key                57 source4/heimdal/lib/hcrypto/rc4.c 	key->state[i] = i;
key                59 source4/heimdal/lib/hcrypto/rc4.c 	j = (j + key->state[i] + data[i % len]) % 256;
key                60 source4/heimdal/lib/hcrypto/rc4.c 	SWAP(key, i, j);
key                62 source4/heimdal/lib/hcrypto/rc4.c     key->x = key->y = 0;
key                66 source4/heimdal/lib/hcrypto/rc4.c RC4(RC4_KEY *key, const int len, const unsigned char *in, unsigned char *out)
key                71 source4/heimdal/lib/hcrypto/rc4.c     x = key->x;
key                72 source4/heimdal/lib/hcrypto/rc4.c     y = key->y;
key                75 source4/heimdal/lib/hcrypto/rc4.c 	y = (y + key->state[x]) % 256;
key                76 source4/heimdal/lib/hcrypto/rc4.c 	SWAP(key, x, y);
key                77 source4/heimdal/lib/hcrypto/rc4.c 	t = (key->state[x] + key->state[y]) % 256;
key                78 source4/heimdal/lib/hcrypto/rc4.c 	*out++ = key->state[t] ^ *in++;
key                80 source4/heimdal/lib/hcrypto/rc4.c     key->x = x;
key                81 source4/heimdal/lib/hcrypto/rc4.c     key->y = y;
key                68 source4/heimdal/lib/hcrypto/rnd_keys.c DES_rand_data_key(DES_cblock *key);
key                75 source4/heimdal/lib/hcrypto/rnd_keys.c DES_rand_data_key(DES_cblock *key)
key                77 source4/heimdal/lib/hcrypto/rnd_keys.c     DES_new_random_key(key);
key               103 source4/heimdal/lib/hcrypto/rnd_keys.c DES_new_random_key(DES_cblock *key)
key               106 source4/heimdal/lib/hcrypto/rnd_keys.c 	if (RAND_bytes(key, sizeof(*key)) != 1)
key               108 source4/heimdal/lib/hcrypto/rnd_keys.c 	DES_set_odd_parity(key);
key               109 source4/heimdal/lib/hcrypto/rnd_keys.c     } while(DES_is_weak_key(key));
key               138 source4/heimdal/lib/hcrypto/rnd_keys.c DES_random_key(DES_cblock *key)
key               140 source4/heimdal/lib/hcrypto/rnd_keys.c     if (DES_new_random_key(key))
key               250 source4/heimdal/lib/hcrypto/rsa.c RSA_check_key(const RSA *key)
key               253 source4/heimdal/lib/hcrypto/rsa.c     RSA *rsa = rk_UNCONST(key);
key                97 source4/heimdal/lib/hdb/db.c     DBT key, value;
key               106 source4/heimdal/lib/hdb/db.c     code = (*d->seq)(d, &key, &value, flag);
key               119 source4/heimdal/lib/hdb/db.c     key_data.data = key.data;
key               120 source4/heimdal/lib/hdb/db.c     key_data.length = key.size;
key               178 source4/heimdal/lib/hdb/db.c DB__get(krb5_context context, HDB *db, krb5_data key, krb5_data *reply)
key               184 source4/heimdal/lib/hdb/db.c     k.data = key.data;
key               185 source4/heimdal/lib/hdb/db.c     k.size = key.length;
key               208 source4/heimdal/lib/hdb/db.c 	krb5_data key, krb5_data value)
key               214 source4/heimdal/lib/hdb/db.c     k.data = key.data;
key               215 source4/heimdal/lib/hdb/db.c     k.size = key.length;
key               237 source4/heimdal/lib/hdb/db.c DB__del(krb5_context context, HDB *db, krb5_data key)
key               242 source4/heimdal/lib/hdb/db.c     k.data = key.data;
key               243 source4/heimdal/lib/hdb/db.c     k.size = key.length;
key               281 source4/heimdal/lib/hdb/ext.c 	    hdb_master_key key;
key               283 source4/heimdal/lib/hdb/ext.c 	    key = _hdb_find_master_key(ext->data.u.password.mkvno,
key               286 source4/heimdal/lib/hdb/ext.c 	    if (key == NULL) {
key               293 source4/heimdal/lib/hdb/ext.c 	    ret = _hdb_mkey_decrypt(context, key, HDB_KU_MKEY,
key               336 source4/heimdal/lib/hdb/ext.c     hdb_master_key key;
key               344 source4/heimdal/lib/hdb/ext.c 	key = _hdb_find_master_key(NULL, db->hdb_master_key);
key               345 source4/heimdal/lib/hdb/ext.c 	if (key == NULL) {
key               352 source4/heimdal/lib/hdb/ext.c 	ret = _hdb_mkey_encrypt(context, key, HDB_KU_MKEY,
key               365 source4/heimdal/lib/hdb/ext.c 	*ext.data.u.password.mkvno = _hdb_mkey_version(key);
key                72 source4/heimdal/lib/hdb/hdb.c 		     Key **key)
key                76 source4/heimdal/lib/hdb/hdb.c     for (k = *key ? (*key) + 1 : e->keys.val;
key                80 source4/heimdal/lib/hdb/hdb.c 	if(k->key.keytype == enctype){
key                81 source4/heimdal/lib/hdb/hdb.c 	    *key = k;
key                95 source4/heimdal/lib/hdb/hdb.c 		Key **key)
key                97 source4/heimdal/lib/hdb/hdb.c     *key = NULL;
key                98 source4/heimdal/lib/hdb/hdb.c     return hdb_next_enctype2key(context, e, enctype, key);
key               102 source4/heimdal/lib/hdb/hdb.c hdb_free_key(Key *key)
key               104 source4/heimdal/lib/hdb/hdb.c     memset(key->key.keyvalue.data,
key               106 source4/heimdal/lib/hdb/hdb.c 	   key->key.keyvalue.length);
key               107 source4/heimdal/lib/hdb/hdb.c     free_Key(key);
key               108 source4/heimdal/lib/hdb/hdb.c     free(key);
key               151 source4/heimdal/lib/hdb/hdb.c 	memset (k->key.keyvalue.data, 0, k->key.keyvalue.length);
key                55 source4/heimdal/lib/hdb/keys.c 	krb5_free_keyblock_contents(context, &keys[i].key);
key                84 source4/heimdal/lib/hdb/keys.c parse_key_set(krb5_context context, const char *key,
key                96 source4/heimdal/lib/hdb/keys.c     p = key;
key               166 source4/heimdal/lib/hdb/keys.c 	krb5_set_error_message(context, EINVAL, "bad value for default_keys `%s'", key);
key               205 source4/heimdal/lib/hdb/keys.c     Key key, *tmp;
key               207 source4/heimdal/lib/hdb/keys.c     memset(&key, 0, sizeof(key));
key               215 source4/heimdal/lib/hdb/keys.c     key.key.keytype = enctype;
key               216 source4/heimdal/lib/hdb/keys.c     key.key.keyvalue.length = 0;
key               217 source4/heimdal/lib/hdb/keys.c     key.key.keyvalue.data = NULL;
key               220 source4/heimdal/lib/hdb/keys.c 	key.salt = malloc(sizeof(*key.salt));
key               221 source4/heimdal/lib/hdb/keys.c 	if (key.salt == NULL) {
key               222 source4/heimdal/lib/hdb/keys.c 	    free_Key(&key);
key               226 source4/heimdal/lib/hdb/keys.c 	key.salt->type = salt->salttype;
key               227 source4/heimdal/lib/hdb/keys.c 	krb5_data_zero (&key.salt->salt);
key               229 source4/heimdal/lib/hdb/keys.c 	ret = krb5_data_copy(&key.salt->salt,
key               233 source4/heimdal/lib/hdb/keys.c 	    free_Key(&key);
key               237 source4/heimdal/lib/hdb/keys.c 	key.salt = NULL;
key               239 source4/heimdal/lib/hdb/keys.c     (*key_set)[*nkeyset] = key;
key               315 source4/heimdal/lib/hdb/keys.c 		if (k->key.keytype == enctypes[i]) {
key               387 source4/heimdal/lib/hdb/keys.c 				       (*keys)[i].key.keytype,
key               390 source4/heimdal/lib/hdb/keys.c 				       &(*keys)[i].key);
key               241 source4/heimdal/lib/hdb/keytab.c 	    enctype = ent.entry.keys.val[0].key.keytype;
key               244 source4/heimdal/lib/hdb/keytab.c 	if(ent.entry.keys.val[i].key.keytype == enctype) {
key               248 source4/heimdal/lib/hdb/keytab.c 					&ent.entry.keys.val[i].key,
key                63 source4/heimdal/lib/hdb/mkey.c 		       int kvno, krb5_keyblock *key, krb5_enctype etype,
key                77 source4/heimdal/lib/hdb/mkey.c     ret = krb5_copy_keyblock_contents(context, key, &(*mkey)->keytab.keyblock);
key                83 source4/heimdal/lib/hdb/mkey.c     ret = krb5_crypto_init(context, key, etype, &(*mkey)->crypto);
key                94 source4/heimdal/lib/hdb/mkey.c hdb_add_master_key(krb5_context context, krb5_keyblock *key,
key               104 source4/heimdal/lib/hdb/mkey.c     ret = hdb_process_master_key(context, vno, key, 0, &p);
key               157 source4/heimdal/lib/hdb/mkey.c     krb5_keyblock key;
key               175 source4/heimdal/lib/hdb/mkey.c     ret = krb5_ret_keyblock(sp, &key);
key               184 source4/heimdal/lib/hdb/mkey.c     key.keytype = enctype;
key               185 source4/heimdal/lib/hdb/mkey.c     ret = krb5_ret_data(sp, &key.keyvalue);
key               189 source4/heimdal/lib/hdb/mkey.c     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
key               190 source4/heimdal/lib/hdb/mkey.c     krb5_free_keyblock_contents(context, &key);
key               203 source4/heimdal/lib/hdb/mkey.c     krb5_keyblock key;
key               226 source4/heimdal/lib/hdb/mkey.c     ret = decode_EncryptionKey(buf, len, &key, &ret_len);
key               236 source4/heimdal/lib/hdb/mkey.c     if(key.keytype == KEYTYPE_DES || key.keytype == ETYPE_DES_CBC_MD5)
key               237 source4/heimdal/lib/hdb/mkey.c 	key.keytype = ETYPE_DES_CFB64_NONE;
key               239 source4/heimdal/lib/hdb/mkey.c     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
key               240 source4/heimdal/lib/hdb/mkey.c     krb5_free_keyblock_contents(context, &key);
key               250 source4/heimdal/lib/hdb/mkey.c     krb5_keyblock key;
key               277 source4/heimdal/lib/hdb/mkey.c     memset(&key, 0, sizeof(key));
key               278 source4/heimdal/lib/hdb/mkey.c     key.keytype = ETYPE_DES_PCBC_NONE;
key               279 source4/heimdal/lib/hdb/mkey.c     ret = krb5_data_copy(&key.keyvalue, buf, len);
key               284 source4/heimdal/lib/hdb/mkey.c     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
key               285 source4/heimdal/lib/hdb/mkey.c     krb5_free_keyblock_contents(context, &key);
key               387 source4/heimdal/lib/hdb/mkey.c _hdb_mkey_decrypt(krb5_context context, hdb_master_key key,
key               391 source4/heimdal/lib/hdb/mkey.c     return krb5_decrypt(context, key->crypto, usage,
key               396 source4/heimdal/lib/hdb/mkey.c _hdb_mkey_encrypt(krb5_context context, hdb_master_key key,
key               400 source4/heimdal/lib/hdb/mkey.c     return krb5_encrypt(context, key->crypto, usage,
key               412 source4/heimdal/lib/hdb/mkey.c     hdb_master_key key;
key               417 source4/heimdal/lib/hdb/mkey.c     key = _hdb_find_master_key(k->mkvno, mkey);
key               419 source4/heimdal/lib/hdb/mkey.c     if (key == NULL)
key               422 source4/heimdal/lib/hdb/mkey.c     ret = _hdb_mkey_decrypt(context, key, HDB_KU_MKEY,
key               423 source4/heimdal/lib/hdb/mkey.c 			    k->key.keyvalue.data,
key               424 source4/heimdal/lib/hdb/mkey.c 			    k->key.keyvalue.length,
key               428 source4/heimdal/lib/hdb/mkey.c 	ret = _hdb_mkey_decrypt(context, key, 0,
key               429 source4/heimdal/lib/hdb/mkey.c 				k->key.keyvalue.data,
key               430 source4/heimdal/lib/hdb/mkey.c 				k->key.keyvalue.length,
key               437 source4/heimdal/lib/hdb/mkey.c     ret = krb5_enctype_keysize(context, k->key.keytype, &keysize);
key               447 source4/heimdal/lib/hdb/mkey.c     memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
key               448 source4/heimdal/lib/hdb/mkey.c     free(k->key.keyvalue.data);
key               449 source4/heimdal/lib/hdb/mkey.c     k->key.keyvalue = res;
key               450 source4/heimdal/lib/hdb/mkey.c     k->key.keyvalue.length = keysize;
key               493 source4/heimdal/lib/hdb/mkey.c     hdb_master_key key;
key               498 source4/heimdal/lib/hdb/mkey.c     key = _hdb_find_master_key(k->mkvno, mkey);
key               500 source4/heimdal/lib/hdb/mkey.c     if (key == NULL)
key               503 source4/heimdal/lib/hdb/mkey.c     ret = _hdb_mkey_encrypt(context, key, HDB_KU_MKEY,
key               504 source4/heimdal/lib/hdb/mkey.c 			    k->key.keyvalue.data,
key               505 source4/heimdal/lib/hdb/mkey.c 			    k->key.keyvalue.length,
key               510 source4/heimdal/lib/hdb/mkey.c     memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
key               511 source4/heimdal/lib/hdb/mkey.c     free(k->key.keyvalue.data);
key               512 source4/heimdal/lib/hdb/mkey.c     k->key.keyvalue = res;
key               519 source4/heimdal/lib/hdb/mkey.c     *k->mkvno = key->keytab.vno;
key               559 source4/heimdal/lib/hdb/mkey.c 		    krb5_keyblock *key)
key               564 source4/heimdal/lib/hdb/mkey.c     ret = hdb_process_master_key(context, 0, key, 0, &mkey);
key               569 source4/heimdal/lib/hdb/mkey.c     des_set_random_generator_seed(key.keyvalue.data);
key               580 source4/heimdal/lib/hdb/mkey.c     hdb_master_key key;
key               583 source4/heimdal/lib/hdb/mkey.c     ret = hdb_read_master_key(context, keyfile, &key);
key               590 source4/heimdal/lib/hdb/mkey.c     db->hdb_master_key = key;
key                84 source4/heimdal/lib/hdb/ndbm.c     datum key, value;
key                89 source4/heimdal/lib/hdb/ndbm.c 	key = dbm_firstkey(d->db);
key                91 source4/heimdal/lib/hdb/ndbm.c 	key = dbm_nextkey(d->db);
key                92 source4/heimdal/lib/hdb/ndbm.c     if(key.dptr == NULL)
key                94 source4/heimdal/lib/hdb/ndbm.c     key_data.data = key.dptr;
key                95 source4/heimdal/lib/hdb/ndbm.c     key_data.length = key.dsize;
key                98 source4/heimdal/lib/hdb/ndbm.c     value = dbm_fetch(d->db, key);
key               204 source4/heimdal/lib/hdb/ndbm.c NDBM__get(krb5_context context, HDB *db, krb5_data key, krb5_data *reply)
key               210 source4/heimdal/lib/hdb/ndbm.c     k.dptr  = key.data;
key               211 source4/heimdal/lib/hdb/ndbm.c     k.dsize = key.length;
key               226 source4/heimdal/lib/hdb/ndbm.c 	krb5_data key, krb5_data value)
key               232 source4/heimdal/lib/hdb/ndbm.c     k.dptr  = key.data;
key               233 source4/heimdal/lib/hdb/ndbm.c     k.dsize = key.length;
key               250 source4/heimdal/lib/hdb/ndbm.c NDBM__del(krb5_context context, HDB *db, krb5_data key)
key               257 source4/heimdal/lib/hdb/ndbm.c     k.dptr = key.data;
key               258 source4/heimdal/lib/hdb/ndbm.c     k.dsize = key.length;
key                54 source4/heimdal/lib/hx509/ca.c 	unsigned int key:1;
key               261 source4/heimdal/lib/hx509/ca.c 	tbs->flags.key = !ret;
key               380 source4/heimdal/lib/hx509/ca.c     tbs->flags.key = !ret;
key               993 source4/heimdal/lib/hx509/ca.c     if (tbs->flags.key == 0) {
key               358 source4/heimdal/lib/hx509/cms.c     heim_octet_string key;
key               369 source4/heimdal/lib/hx509/cms.c     memset(&key, 0, sizeof(key));
key               427 source4/heimdal/lib/hx509/cms.c 					  cert, &key);
key               485 source4/heimdal/lib/hx509/cms.c 	ret = hx509_crypto_set_key_data(crypto, key.data, key.length);
key               510 source4/heimdal/lib/hx509/cms.c     der_free_octet_string(&key);
key               556 source4/heimdal/lib/hx509/cms.c     heim_octet_string key;
key               563 source4/heimdal/lib/hx509/cms.c     memset(&key, 0, sizeof(key));
key               578 source4/heimdal/lib/hx509/cms.c     ret = hx509_crypto_set_random_key(crypto, &key);
key               652 source4/heimdal/lib/hx509/cms.c 				     &key, cert,
key               694 source4/heimdal/lib/hx509/cms.c     der_free_octet_string(&key);
key               105 source4/heimdal/lib/hx509/collector.c free_private_key(struct private_key *key)
key               107 source4/heimdal/lib/hx509/collector.c     free_AlgorithmIdentifier(&key->alg);
key               108 source4/heimdal/lib/hx509/collector.c     if (key->private_key)
key               109 source4/heimdal/lib/hx509/collector.c 	_hx509_private_key_free(&key->private_key);
key               110 source4/heimdal/lib/hx509/collector.c     der_free_octet_string(&key->localKeyId);
key               111 source4/heimdal/lib/hx509/collector.c     free(key);
key               122 source4/heimdal/lib/hx509/collector.c     struct private_key *key;
key               126 source4/heimdal/lib/hx509/collector.c     key = calloc(1, sizeof(*key));
key               127 source4/heimdal/lib/hx509/collector.c     if (key == NULL)
key               132 source4/heimdal/lib/hx509/collector.c 	free(key);
key               138 source4/heimdal/lib/hx509/collector.c     ret = copy_AlgorithmIdentifier(alg, &key->alg);
key               145 source4/heimdal/lib/hx509/collector.c 	key->private_key = private_key;
key               149 source4/heimdal/lib/hx509/collector.c 				       &key->private_key);
key               154 source4/heimdal/lib/hx509/collector.c 	ret = der_copy_octet_string(localKeyId, &key->localKeyId);
key               161 source4/heimdal/lib/hx509/collector.c 	memset(&key->localKeyId, 0, sizeof(key->localKeyId));
key               163 source4/heimdal/lib/hx509/collector.c     c->val.data[c->val.len] = key;
key               168 source4/heimdal/lib/hx509/collector.c 	free_private_key(key);
key               513 source4/heimdal/lib/hx509/crypto.c 		       const hx509_private_key key,
key               521 source4/heimdal/lib/hx509/crypto.c     ret = i2d_RSAPrivateKey(key->private_key.rsa, NULL);
key               539 source4/heimdal/lib/hx509/crypto.c 	i2d_RSAPrivateKey(key->private_key.rsa, &p);
key               546 source4/heimdal/lib/hx509/crypto.c rsa_get_internal(hx509_context context, hx509_private_key key, const char *type)
key               549 source4/heimdal/lib/hx509/crypto.c 	return BN_dup(key->private_key.rsa->n);
key               551 source4/heimdal/lib/hx509/crypto.c 	return BN_dup(key->private_key.rsa->e);
key              1579 source4/heimdal/lib/hx509/crypto.c _hx509_private_key_init(hx509_private_key *key,
key              1583 source4/heimdal/lib/hx509/crypto.c     *key = calloc(1, sizeof(**key));
key              1584 source4/heimdal/lib/hx509/crypto.c     if (*key == NULL)
key              1586 source4/heimdal/lib/hx509/crypto.c     (*key)->ref = 1;
key              1587 source4/heimdal/lib/hx509/crypto.c     (*key)->ops = ops;
key              1588 source4/heimdal/lib/hx509/crypto.c     (*key)->private_key.keydata = keydata;
key              1593 source4/heimdal/lib/hx509/crypto.c _hx509_private_key_ref(hx509_private_key key)
key              1595 source4/heimdal/lib/hx509/crypto.c     if (key->ref == 0)
key              1597 source4/heimdal/lib/hx509/crypto.c     key->ref++;
key              1598 source4/heimdal/lib/hx509/crypto.c     if (key->ref == UINT_MAX)
key              1600 source4/heimdal/lib/hx509/crypto.c     return key;
key              1604 source4/heimdal/lib/hx509/crypto.c _hx509_private_pem_name(hx509_private_key key)
key              1606 source4/heimdal/lib/hx509/crypto.c     return key->ops->pemtype;
key              1610 source4/heimdal/lib/hx509/crypto.c _hx509_private_key_free(hx509_private_key *key)
key              1612 source4/heimdal/lib/hx509/crypto.c     if (key == NULL || *key == NULL)
key              1615 source4/heimdal/lib/hx509/crypto.c     if ((*key)->ref == 0)
key              1617 source4/heimdal/lib/hx509/crypto.c     if (--(*key)->ref > 0)
key              1620 source4/heimdal/lib/hx509/crypto.c     if ((*key)->private_key.rsa)
key              1621 source4/heimdal/lib/hx509/crypto.c 	RSA_free((*key)->private_key.rsa);
key              1622 source4/heimdal/lib/hx509/crypto.c     (*key)->private_key.rsa = NULL;
key              1623 source4/heimdal/lib/hx509/crypto.c     free(*key);
key              1624 source4/heimdal/lib/hx509/crypto.c     *key = NULL;
key              1629 source4/heimdal/lib/hx509/crypto.c _hx509_private_key_assign_rsa(hx509_private_key key, void *ptr)
key              1631 source4/heimdal/lib/hx509/crypto.c     if (key->private_key.rsa)
key              1632 source4/heimdal/lib/hx509/crypto.c 	RSA_free(key->private_key.rsa);
key              1633 source4/heimdal/lib/hx509/crypto.c     key->private_key.rsa = ptr;
key              1634 source4/heimdal/lib/hx509/crypto.c     key->signature_alg = oid_id_pkcs1_sha1WithRSAEncryption();
key              1635 source4/heimdal/lib/hx509/crypto.c     key->md = &pkcs1_rsa_sha1_alg;
key              1640 source4/heimdal/lib/hx509/crypto.c 		       const hx509_private_key key,
key              1644 source4/heimdal/lib/hx509/crypto.c     ret = der_copy_oid((*key->ops->key_oid)(), data);
key              1651 source4/heimdal/lib/hx509/crypto.c _hx509_private_key_exportable(hx509_private_key key)
key              1653 source4/heimdal/lib/hx509/crypto.c     if (key->ops->export == NULL)
key              1660 source4/heimdal/lib/hx509/crypto.c 				hx509_private_key key,
key              1663 source4/heimdal/lib/hx509/crypto.c     if (key->ops->get_internal == NULL)
key              1665 source4/heimdal/lib/hx509/crypto.c     return (*key->ops->get_internal)(context, key, type);
key              1670 source4/heimdal/lib/hx509/crypto.c 			  const hx509_private_key key,
key              1673 source4/heimdal/lib/hx509/crypto.c     if (key->ops->export == NULL) {
key              1677 source4/heimdal/lib/hx509/crypto.c     return (*key->ops->export)(context, key, data);
key              1699 source4/heimdal/lib/hx509/crypto.c     heim_octet_string key;
key              2003 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data)
key              2004 source4/heimdal/lib/hx509/crypto.c 	free(crypto->key.data);
key              2024 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data) {
key              2025 source4/heimdal/lib/hx509/crypto.c 	free(crypto->key.data);
key              2026 source4/heimdal/lib/hx509/crypto.c 	crypto->key.data = NULL;
key              2027 source4/heimdal/lib/hx509/crypto.c 	crypto->key.length = 0;
key              2029 source4/heimdal/lib/hx509/crypto.c     crypto->key.data = malloc(length);
key              2030 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data == NULL)
key              2032 source4/heimdal/lib/hx509/crypto.c     memcpy(crypto->key.data, data, length);
key              2033 source4/heimdal/lib/hx509/crypto.c     crypto->key.length = length;
key              2039 source4/heimdal/lib/hx509/crypto.c hx509_crypto_set_random_key(hx509_crypto crypto, heim_octet_string *key)
key              2041 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data) {
key              2042 source4/heimdal/lib/hx509/crypto.c 	free(crypto->key.data);
key              2043 source4/heimdal/lib/hx509/crypto.c 	crypto->key.length = 0;
key              2046 source4/heimdal/lib/hx509/crypto.c     crypto->key.length = EVP_CIPHER_key_length(crypto->c);
key              2047 source4/heimdal/lib/hx509/crypto.c     crypto->key.data = malloc(crypto->key.length);
key              2048 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data == NULL) {
key              2049 source4/heimdal/lib/hx509/crypto.c 	crypto->key.length = 0;
key              2052 source4/heimdal/lib/hx509/crypto.c     if (RAND_bytes(crypto->key.data, crypto->key.length) <= 0) {
key              2053 source4/heimdal/lib/hx509/crypto.c 	free(crypto->key.data);
key              2054 source4/heimdal/lib/hx509/crypto.c 	crypto->key.data = NULL;
key              2055 source4/heimdal/lib/hx509/crypto.c 	crypto->key.length = 0;
key              2058 source4/heimdal/lib/hx509/crypto.c     if (key)
key              2059 source4/heimdal/lib/hx509/crypto.c 	return der_copy_octet_string(&crypto->key, key);
key              2119 source4/heimdal/lib/hx509/crypto.c 			    crypto->key.data, ivec->data, 1);
key              2195 source4/heimdal/lib/hx509/crypto.c     if (crypto->key.data == NULL)
key              2204 source4/heimdal/lib/hx509/crypto.c 			    crypto->key.data, idata, 0);
key              2271 source4/heimdal/lib/hx509/crypto.c 	       heim_octet_string *key, heim_octet_string *iv,
key              2300 source4/heimdal/lib/hx509/crypto.c 			 PKCS12_KEY_ID, iter, key->length, key->data, md)) {
key              2315 source4/heimdal/lib/hx509/crypto.c     ret = hx509_crypto_set_key_data(c, key->data, key->length);
key              2392 source4/heimdal/lib/hx509/crypto.c     heim_octet_string key, iv;
key              2399 source4/heimdal/lib/hx509/crypto.c     memset(&key, 0, sizeof(key));
key              2412 source4/heimdal/lib/hx509/crypto.c     key.length = EVP_CIPHER_key_length(c);
key              2413 source4/heimdal/lib/hx509/crypto.c     key.data = malloc(key.length);
key              2414 source4/heimdal/lib/hx509/crypto.c     if (key.data == NULL) {
key              2443 source4/heimdal/lib/hx509/crypto.c 		     &key, &iv, enc_oid, md);
key              2458 source4/heimdal/lib/hx509/crypto.c     if (key.data)
key              2459 source4/heimdal/lib/hx509/crypto.c 	der_free_octet_string(&key);
key              2527 source4/heimdal/lib/hx509/crypto.c find_keytype(const hx509_private_key key)
key              2531 source4/heimdal/lib/hx509/crypto.c     if (key == NULL)
key              2534 source4/heimdal/lib/hx509/crypto.c     md = find_sig_alg(key->signature_alg);
key                58 source4/heimdal/lib/hx509/env.c 	      const char *key, const char *value)
key                70 source4/heimdal/lib/hx509/env.c     n->name = strdup(key);
key               109 source4/heimdal/lib/hx509/env.c 		      const char *key, hx509_env list)
key               121 source4/heimdal/lib/hx509/env.c     n->name = strdup(key);
key               156 source4/heimdal/lib/hx509/env.c 		const char *key, size_t len)
key               159 source4/heimdal/lib/hx509/env.c 	if (strncmp(key, env->name ,len) == 0
key               180 source4/heimdal/lib/hx509/env.c hx509_env_find(hx509_context context, hx509_env env, const char *key)
key               183 source4/heimdal/lib/hx509/env.c 	if (strcmp(key, env->name) == 0 && env->type == env_string)
key               205 source4/heimdal/lib/hx509/env.c 		       const char *key)
key               208 source4/heimdal/lib/hx509/env.c 	if (strcmp(key, env->name) == 0 && env->type == env_list)
key               656 source4/heimdal/lib/hx509/keyset.c 		      hx509_private_key key)
key               665 source4/heimdal/lib/hx509/keyset.c     return (*certs->ops->addkey)(context, certs, certs->ops_data, key);
key                80 source4/heimdal/lib/hx509/ks_file.c     void *key;
key                85 source4/heimdal/lib/hx509/ks_file.c     key = malloc(keylen);
key                86 source4/heimdal/lib/hx509/ks_file.c     if (key == NULL) {
key                93 source4/heimdal/lib/hx509/ks_file.c 			 1, key, NULL);
key               112 source4/heimdal/lib/hx509/ks_file.c 	EVP_CipherInit_ex(&ctx, c, NULL, key, ivdata, 0);
key               127 source4/heimdal/lib/hx509/ks_file.c     memset(key, 0, keylen);
key               128 source4/heimdal/lib/hx509/ks_file.c     free(key);
key               501 source4/heimdal/lib/hx509/ks_file.c 	    hx509_private_key key = _hx509_cert_private_key(c);
key               502 source4/heimdal/lib/hx509/ks_file.c 	    ret = _hx509_private_key_export(context, key, &data);
key               505 source4/heimdal/lib/hx509/ks_file.c 	    hx509_pem_write(context, _hx509_private_pem_name(key), NULL, sc->f,
key               584 source4/heimdal/lib/hx509/ks_file.c 	     hx509_private_key key)
key               587 source4/heimdal/lib/hx509/ks_file.c     return _hx509_certs_keys_add(context, f->certs, key);
key               201 source4/heimdal/lib/hx509/ks_keychain.c     hx509_private_key key;
key               205 source4/heimdal/lib/hx509/ks_keychain.c     ret = _hx509_private_key_init(&key, NULL, NULL);
key               248 source4/heimdal/lib/hx509/ks_keychain.c     _hx509_private_key_assign_rsa(key, rsa);
key               249 source4/heimdal/lib/hx509/ks_keychain.c     _hx509_cert_assign_key(cert, key);
key               184 source4/heimdal/lib/hx509/ks_mem.c 	   hx509_private_key key)
key               198 source4/heimdal/lib/hx509/ks_mem.c     mem->keys[i] = _hx509_private_key_ref(key);
key               131 source4/heimdal/lib/hx509/ks_p11.c     CK_OBJECT_HANDLE key = p11rsa->private_key;
key               149 source4/heimdal/lib/hx509/ks_p11.c     ret = P11FUNC(p11rsa->p, SignInit, (session, &mechanism, key));
key               169 source4/heimdal/lib/hx509/ks_p11.c     CK_OBJECT_HANDLE key = p11rsa->private_key;
key               187 source4/heimdal/lib/hx509/ks_p11.c     ret = P11FUNC(p11rsa->p, DecryptInit, (session, &mechanism, key));
key               608 source4/heimdal/lib/hx509/ks_p11.c     hx509_private_key key;
key               617 source4/heimdal/lib/hx509/ks_p11.c     ret = _hx509_private_key_init(&key, NULL, NULL);
key               652 source4/heimdal/lib/hx509/ks_p11.c     _hx509_private_key_assign_rsa(key, rsa);
key               657 source4/heimdal/lib/hx509/ks_p11.c 					   key,
key               662 source4/heimdal/lib/hx509/ks_p11.c 	_hx509_private_key_free(&key);
key               523 source4/heimdal/lib/hx509/ks_p12.c 	hx509_private_key key = _hx509_cert_private_key(c);
key               531 source4/heimdal/lib/hx509/ks_p12.c 	ret = _hx509_private_key_oid(context, key,
key                40 source4/heimdal/lib/hx509/req.c     SubjectPublicKeyInfo key;
key                64 source4/heimdal/lib/hx509/req.c     free_SubjectPublicKeyInfo(&(*req)->key);
key               102 source4/heimdal/lib/hx509/req.c 					const SubjectPublicKeyInfo *key)
key               104 source4/heimdal/lib/hx509/req.c     free_SubjectPublicKeyInfo(&req->key);
key               105 source4/heimdal/lib/hx509/req.c     return copy_SubjectPublicKeyInfo(key, &req->key);
key               111 source4/heimdal/lib/hx509/req.c 					SubjectPublicKeyInfo *key)
key               113 source4/heimdal/lib/hx509/req.c     return copy_SubjectPublicKeyInfo(&req->key, key);
key               194 source4/heimdal/lib/hx509/req.c     ret = copy_SubjectPublicKeyInfo(&req->key,
key               324 source4/heimdal/lib/krb5/auth_context.c 				  krb5_keyblock *key)
key               329 source4/heimdal/lib/krb5/auth_context.c     ret = krb5_generate_subkey_extended (context, key,
key                56 source4/heimdal/lib/krb5/crypto.c     krb5_keyblock *key;
key                62 source4/heimdal/lib/krb5/crypto.c     struct key_data key;
key                67 source4/heimdal/lib/krb5/crypto.c     struct key_data key;
key               111 source4/heimdal/lib/krb5/crypto.c 			     struct key_data *key,
key               116 source4/heimdal/lib/krb5/crypto.c 			      struct key_data *key,
key               133 source4/heimdal/lib/krb5/crypto.c 			       struct key_data *key,
key               154 source4/heimdal/lib/krb5/crypto.c 				  struct key_data *key,
key               185 source4/heimdal/lib/krb5/crypto.c 		    krb5_keyblock *key)
key               187 source4/heimdal/lib/krb5/crypto.c     DES_cblock *k = key->keyvalue.data;
key               197 source4/heimdal/lib/krb5/crypto.c 		      struct key_data *key)
key               199 source4/heimdal/lib/krb5/crypto.c     DES_set_key_unchecked(key->key->keyvalue.data, key->schedule->data);
key               216 source4/heimdal/lib/krb5/crypto.c 				 DES_cblock *key)
key               229 source4/heimdal/lib/krb5/crypto.c     memcpy(key, crypt(password, "p1") + 2, sizeof(DES_cblock));
key               235 source4/heimdal/lib/krb5/crypto.c 	((unsigned char*)key)[i] <<= 1;
key               236 source4/heimdal/lib/krb5/crypto.c     DES_set_odd_parity (key);
key               245 source4/heimdal/lib/krb5/crypto.c 				      DES_cblock *key)
key               272 source4/heimdal/lib/krb5/crypto.c     DES_cbc_cksum ((void*)password, key, passlen, &schedule, &ivec);
key               278 source4/heimdal/lib/krb5/crypto.c     DES_set_odd_parity (key);
key               287 source4/heimdal/lib/krb5/crypto.c 		       krb5_keyblock *key)
key               294 source4/heimdal/lib/krb5/crypto.c     key->keytype = enctype;
key               295 source4/heimdal/lib/krb5/crypto.c     krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
key               296 source4/heimdal/lib/krb5/crypto.c     memset(&key, 0, sizeof(key));
key               302 source4/heimdal/lib/krb5/crypto.c DES_string_to_key_int(unsigned char *data, size_t length, DES_cblock *key)
key               311 source4/heimdal/lib/krb5/crypto.c     memset(key, 0, 8);
key               313 source4/heimdal/lib/krb5/crypto.c     p = (unsigned char*)key;
key               323 source4/heimdal/lib/krb5/crypto.c     DES_set_odd_parity(key);
key               324 source4/heimdal/lib/krb5/crypto.c     if(DES_is_weak_key(key))
key               325 source4/heimdal/lib/krb5/crypto.c 	(*key)[7] ^= 0xF0;
key               326 source4/heimdal/lib/krb5/crypto.c     DES_set_key_unchecked(key, &schedule);
key               327 source4/heimdal/lib/krb5/crypto.c     DES_cbc_cksum((void*)data, key, length, &schedule, key);
key               329 source4/heimdal/lib/krb5/crypto.c     DES_set_odd_parity(key);
key               330 source4/heimdal/lib/krb5/crypto.c     if(DES_is_weak_key(key))
key               331 source4/heimdal/lib/krb5/crypto.c 	(*key)[7] ^= 0xF0;
key               340 source4/heimdal/lib/krb5/crypto.c 		       krb5_keyblock *key)
key               352 source4/heimdal/lib/krb5/crypto.c 					  salt, opaque, key);
key               365 source4/heimdal/lib/krb5/crypto.c     key->keytype = enctype;
key               366 source4/heimdal/lib/krb5/crypto.c     krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
key               375 source4/heimdal/lib/krb5/crypto.c 		       krb5_keyblock *key,
key               379 source4/heimdal/lib/krb5/crypto.c     DES_cblock *k = key->keyvalue.data;
key               380 source4/heimdal/lib/krb5/crypto.c     memcpy(k, data, key->keyvalue.length);
key               393 source4/heimdal/lib/krb5/crypto.c 		krb5_keyblock *key)
key               395 source4/heimdal/lib/krb5/crypto.c     DES_cblock *k = key->keyvalue.data;
key               411 source4/heimdal/lib/krb5/crypto.c xor (DES_cblock *key, const unsigned char *b)
key               413 source4/heimdal/lib/krb5/crypto.c     unsigned char *a = (unsigned char*)key;
key               431 source4/heimdal/lib/krb5/crypto.c 		   krb5_keyblock *key)
key               481 source4/heimdal/lib/krb5/crypto.c     key->keytype = enctype;
key               482 source4/heimdal/lib/krb5/crypto.c     krb5_data_copy(&key->keyvalue, keys, sizeof(keys));
key               496 source4/heimdal/lib/krb5/crypto.c 			   krb5_keyblock *key)
key               513 source4/heimdal/lib/krb5/crypto.c 				     key);
key               521 source4/heimdal/lib/krb5/crypto.c 		   krb5_keyblock *key,
key               525 source4/heimdal/lib/krb5/crypto.c     unsigned char *x = key->keyvalue.data;
key               545 source4/heimdal/lib/krb5/crypto.c     k = key->keyvalue.data;
key               563 source4/heimdal/lib/krb5/crypto.c 		 kd->key->keyvalue.length, kd->key->keyvalue.data);
key               572 source4/heimdal/lib/krb5/crypto.c 		      krb5_keyblock *key)
key               619 source4/heimdal/lib/krb5/crypto.c     key->keytype = enctype;
key               620 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc (&key->keyvalue, 16);
key               625 source4/heimdal/lib/krb5/crypto.c     EVP_DigestFinal_ex (m, key->keyvalue.data, NULL);
key               647 source4/heimdal/lib/krb5/crypto.c 		  krb5_keyblock *key)
key               668 source4/heimdal/lib/krb5/crypto.c     ALLOC(kd.key, 1);
key               669 source4/heimdal/lib/krb5/crypto.c     if(kd.key == NULL) {
key               673 source4/heimdal/lib/krb5/crypto.c     kd.key->keytype = enctype;
key               674 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc(&kd.key->keyvalue, et->keytype->size);
key               683 source4/heimdal/lib/krb5/crypto.c 				 et->keytype->size, kd.key->keyvalue.data);
key               693 source4/heimdal/lib/krb5/crypto.c 	ret = krb5_copy_keyblock_contents(context, kd.key, key);
key               702 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *key = kd->schedule->data;
key               705 source4/heimdal/lib/krb5/crypto.c     EVP_CIPHER_CTX_init(&key->ectx);
key               706 source4/heimdal/lib/krb5/crypto.c     EVP_CIPHER_CTX_init(&key->dctx);
key               708 source4/heimdal/lib/krb5/crypto.c     EVP_CipherInit_ex(&key->ectx, c, NULL, kd->key->keyvalue.data, NULL, 1);
key               709 source4/heimdal/lib/krb5/crypto.c     EVP_CipherInit_ex(&key->dctx, c, NULL, kd->key->keyvalue.data, NULL, 0);
key               715 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *key = kd->schedule->data;
key               716 source4/heimdal/lib/krb5/crypto.c     EVP_CIPHER_CTX_cleanup(&key->ectx);
key               717 source4/heimdal/lib/krb5/crypto.c     EVP_CIPHER_CTX_cleanup(&key->dctx);
key               993 source4/heimdal/lib/krb5/crypto.c 			 krb5_keyblock *key)
key              1001 source4/heimdal/lib/krb5/crypto.c     ret = krb5_string_to_key_data_salt(context, enctype, password, salt, key);
key              1011 source4/heimdal/lib/krb5/crypto.c 		    krb5_keyblock *key)
key              1016 source4/heimdal/lib/krb5/crypto.c     return krb5_string_to_key_data(context, enctype, pw, principal, key);
key              1024 source4/heimdal/lib/krb5/crypto.c 			      krb5_keyblock *key)
key              1029 source4/heimdal/lib/krb5/crypto.c 					       salt, opaque, key);
key              1044 source4/heimdal/lib/krb5/crypto.c 				     krb5_keyblock *key)
key              1057 source4/heimdal/lib/krb5/crypto.c 					salt, opaque, key);
key              1075 source4/heimdal/lib/krb5/crypto.c 			 krb5_keyblock *key)
key              1080 source4/heimdal/lib/krb5/crypto.c     return krb5_string_to_key_data_salt(context, enctype, pw, salt, key);
key              1089 source4/heimdal/lib/krb5/crypto.c 				krb5_keyblock *key)
key              1095 source4/heimdal/lib/krb5/crypto.c 					       pw, salt, opaque, key);
key              1133 source4/heimdal/lib/krb5/crypto.c 			      krb5_keyblock *key)
key              1143 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
key              1146 source4/heimdal/lib/krb5/crypto.c     key->keytype = type;
key              1148 source4/heimdal/lib/krb5/crypto.c 	(*et->keytype->random_key)(context, key);
key              1150 source4/heimdal/lib/krb5/crypto.c 	krb5_generate_random_block(key->keyvalue.data,
key              1151 source4/heimdal/lib/krb5/crypto.c 				   key->keyvalue.length);
key              1157 source4/heimdal/lib/krb5/crypto.c 	      struct key_data *key)
key              1160 source4/heimdal/lib/krb5/crypto.c     struct encryption_type *et = _find_enctype(key->key->keytype);
key              1165 source4/heimdal/lib/krb5/crypto.c     if (key->schedule != NULL)
key              1167 source4/heimdal/lib/krb5/crypto.c     ALLOC(key->schedule, 1);
key              1168 source4/heimdal/lib/krb5/crypto.c     if(key->schedule == NULL) {
key              1172 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc(key->schedule, kt->schedule_size);
key              1174 source4/heimdal/lib/krb5/crypto.c 	free(key->schedule);
key              1175 source4/heimdal/lib/krb5/crypto.c 	key->schedule = NULL;
key              1178 source4/heimdal/lib/krb5/crypto.c     (*kt->schedule)(context, kt, key);
key              1188 source4/heimdal/lib/krb5/crypto.c 	      struct key_data *key,
key              1199 source4/heimdal/lib/krb5/crypto.c 	       struct key_data *key,
key              1218 source4/heimdal/lib/krb5/crypto.c 		 struct key_data *key,
key              1232 source4/heimdal/lib/krb5/crypto.c 	     struct key_data *key,
key              1237 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *ctx = key->schedule->data;
key              1265 source4/heimdal/lib/krb5/crypto.c 	   struct key_data *key,
key              1270 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *ctx = key->schedule->data;
key              1303 source4/heimdal/lib/krb5/crypto.c 		     struct key_data *key,
key              1309 source4/heimdal/lib/krb5/crypto.c     return des_checksum(context, EVP_md4(), key, data, len, cksum);
key              1314 source4/heimdal/lib/krb5/crypto.c 		   struct key_data *key,
key              1320 source4/heimdal/lib/krb5/crypto.c     return des_verify(context, EVP_md5(), key, data, len, C);
key              1325 source4/heimdal/lib/krb5/crypto.c 		 struct key_data *key,
key              1338 source4/heimdal/lib/krb5/crypto.c 		     struct key_data *key,
key              1344 source4/heimdal/lib/krb5/crypto.c     return des_checksum(context, EVP_md5(), key, data, len, C);
key              1349 source4/heimdal/lib/krb5/crypto.c 		   struct key_data *key,
key              1355 source4/heimdal/lib/krb5/crypto.c     return des_verify(context, EVP_md5(), key, data, len, C);
key              1361 source4/heimdal/lib/krb5/crypto.c 		      struct key_data *key,
key              1367 source4/heimdal/lib/krb5/crypto.c     return des_checksum(context, EVP_md5(), key, data, len, C);
key              1372 source4/heimdal/lib/krb5/crypto.c 		    struct key_data *key,
key              1378 source4/heimdal/lib/krb5/crypto.c     return des_verify(context, EVP_md5(), key, data, len, C);
key              1384 source4/heimdal/lib/krb5/crypto.c 	      struct key_data *key,
key              1406 source4/heimdal/lib/krb5/crypto.c     unsigned char *key;
key              1421 source4/heimdal/lib/krb5/crypto.c     if(keyblock->key->keyvalue.length > cm->blocksize){
key              1424 source4/heimdal/lib/krb5/crypto.c 			keyblock->key->keyvalue.data,
key              1425 source4/heimdal/lib/krb5/crypto.c 			keyblock->key->keyvalue.length,
key              1428 source4/heimdal/lib/krb5/crypto.c 	key = result->checksum.data;
key              1431 source4/heimdal/lib/krb5/crypto.c 	key = keyblock->key->keyvalue.data;
key              1432 source4/heimdal/lib/krb5/crypto.c 	key_len = keyblock->key->keyvalue.length;
key              1435 source4/heimdal/lib/krb5/crypto.c 	ipad[i] ^= key[i];
key              1436 source4/heimdal/lib/krb5/crypto.c 	opad[i] ^= key[i];
key              1459 source4/heimdal/lib/krb5/crypto.c 	  krb5_keyblock *key,
key              1473 source4/heimdal/lib/krb5/crypto.c     kd.key = key;
key              1486 source4/heimdal/lib/krb5/crypto.c 		      struct key_data *key,
key              1500 source4/heimdal/lib/krb5/crypto.c     ret = hmac(context, c, data, len, usage, key, &res);
key              1513 source4/heimdal/lib/krb5/crypto.c 		  struct key_data *key,
key              1537 source4/heimdal/lib/krb5/crypto.c     ret = hmac(context, c, signature, sizeof(signature), 0, key, &ksign_c);
key              1542 source4/heimdal/lib/krb5/crypto.c     ksign.key = &kb;
key              1708 source4/heimdal/lib/krb5/crypto.c 		 struct key_data **key)
key              1713 source4/heimdal/lib/krb5/crypto.c 	ret = _get_derived_key(context, crypto, usage, key);
key              1717 source4/heimdal/lib/krb5/crypto.c 	*key = _new_derived_key(crypto, 0xff/* KRB5_KU_RFC1510_VARIANT */);
key              1718 source4/heimdal/lib/krb5/crypto.c 	if(*key == NULL) {
key              1722 source4/heimdal/lib/krb5/crypto.c 	ret = krb5_copy_keyblock(context, crypto->key.key, &(*key)->key);
key              1725 source4/heimdal/lib/krb5/crypto.c 	for(i = 0; i < (*key)->key->keyvalue.length; i++)
key              1726 source4/heimdal/lib/krb5/crypto.c 	    ((unsigned char*)(*key)->key->keyvalue.data)[i] ^= 0xF0;
key              1728 source4/heimdal/lib/krb5/crypto.c 	*key = &crypto->key;
key              1731 source4/heimdal/lib/krb5/crypto.c 	ret = _key_schedule(context, *key);
key              1777 source4/heimdal/lib/krb5/crypto.c 	(crypto->key.key->keytype == KEYTYPE_ARCFOUR);
key              2003 source4/heimdal/lib/krb5/crypto.c 	     struct key_data *key,
key              2015 source4/heimdal/lib/krb5/crypto.c 	    struct key_data *key,
key              2022 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *ctx = key->schedule->data;
key              2045 source4/heimdal/lib/krb5/crypto.c 			  struct key_data *key,
key              2052 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *ctx = key->schedule->data;
key              2064 source4/heimdal/lib/krb5/crypto.c 			 struct key_data *key,
key              2071 source4/heimdal/lib/krb5/crypto.c     struct evp_schedule *ctx = key->schedule->data;
key              2074 source4/heimdal/lib/krb5/crypto.c     memcpy(&ivec, key->key->keyvalue.data, sizeof(ivec));
key              2083 source4/heimdal/lib/krb5/crypto.c 			    struct key_data *key,
key              2092 source4/heimdal/lib/krb5/crypto.c     DES_key_schedule *s = key->schedule->data;
key              2101 source4/heimdal/lib/krb5/crypto.c 			  struct key_data *key,
key              2109 source4/heimdal/lib/krb5/crypto.c     DES_key_schedule *s = key->schedule->data;
key              2110 source4/heimdal/lib/krb5/crypto.c     memcpy(&ivec, key->key->keyvalue.data, sizeof(ivec));
key              2125 source4/heimdal/lib/krb5/crypto.c 		   struct key_data *key,
key              2149 source4/heimdal/lib/krb5/crypto.c     ret = hmac(NULL, c, t, sizeof(t), 0, key, &k1_c);
key              2158 source4/heimdal/lib/krb5/crypto.c     ke.key = &kb;
key              2168 source4/heimdal/lib/krb5/crypto.c     ke.key = &kb;
key              2188 source4/heimdal/lib/krb5/crypto.c 		   struct key_data *key,
key              2213 source4/heimdal/lib/krb5/crypto.c     ret = hmac(NULL, c, t, sizeof(t), 0, key, &k1_c);
key              2222 source4/heimdal/lib/krb5/crypto.c     ke.key = &kb;
key              2235 source4/heimdal/lib/krb5/crypto.c     ke.key = &kb;
key              2287 source4/heimdal/lib/krb5/crypto.c 		struct key_data *key,
key              2301 source4/heimdal/lib/krb5/crypto.c 	return ARCFOUR_subencrypt (context, key, data, len, keyusage, ivec);
key              2303 source4/heimdal/lib/krb5/crypto.c 	return ARCFOUR_subdecrypt (context, key, data, len, keyusage, ivec);
key              2339 source4/heimdal/lib/krb5/crypto.c     ret = krb5_derive_key(context, crypto->key.key,
key              2882 source4/heimdal/lib/krb5/crypto.c     ret = _key_schedule(context, &crypto->key);
key              2885 source4/heimdal/lib/krb5/crypto.c     ret = (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
key              2926 source4/heimdal/lib/krb5/crypto.c     ret = (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
key              3045 source4/heimdal/lib/krb5/crypto.c     ret = _key_schedule(context, &crypto->key);
key              3050 source4/heimdal/lib/krb5/crypto.c     ret = (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
key              3107 source4/heimdal/lib/krb5/crypto.c     ret = (*et->encrypt)(context, &crypto->key, p, len, FALSE, usage, ivec);
key              3770 source4/heimdal/lib/krb5/crypto.c 	      unsigned char *k, size_t len, struct key_data *key)
key              3772 source4/heimdal/lib/krb5/crypto.c     DES3_random_to_key(context, key->key, k, len);
key              3774 source4/heimdal/lib/krb5/crypto.c     if (key->schedule) {
key              3775 source4/heimdal/lib/krb5/crypto.c 	krb5_free_data(context, key->schedule);
key              3776 source4/heimdal/lib/krb5/crypto.c 	key->schedule = NULL;
key              3783 source4/heimdal/lib/krb5/crypto.c 	   struct key_data *key,
key              3792 source4/heimdal/lib/krb5/crypto.c     ret = _key_schedule(context, key);
key              3813 source4/heimdal/lib/krb5/crypto.c 	    (*et->encrypt)(context, key, k + i * et->blocksize, et->blocksize,
key              3826 source4/heimdal/lib/krb5/crypto.c 	(*et->encrypt)(context, key, c, len, 1, 0, NULL);
key              3845 source4/heimdal/lib/krb5/crypto.c 	DES3_postproc(context, k, nblocks * et->blocksize, key);
key              3849 source4/heimdal/lib/krb5/crypto.c 	memcpy(key->key->keyvalue.data, k, key->key->keyvalue.length);
key              3858 source4/heimdal/lib/krb5/crypto.c     if (key->schedule) {
key              3859 source4/heimdal/lib/krb5/crypto.c 	krb5_free_data(context, key->schedule);
key              3860 source4/heimdal/lib/krb5/crypto.c 	key->schedule = NULL;
key              3878 source4/heimdal/lib/krb5/crypto.c     return &d->key;
key              3883 source4/heimdal/lib/krb5/crypto.c 		const krb5_keyblock *key,
key              3903 source4/heimdal/lib/krb5/crypto.c     ret = krb5_copy_keyblock(context, key, &d.key);
key              3910 source4/heimdal/lib/krb5/crypto.c 	ret = krb5_copy_keyblock(context, d.key, derived_key);
key              3919 source4/heimdal/lib/krb5/crypto.c 		 struct key_data **key)
key              3927 source4/heimdal/lib/krb5/crypto.c 	    *key = &crypto->key_usage[i].key;
key              3935 source4/heimdal/lib/krb5/crypto.c     krb5_copy_keyblock(context, crypto->key.key, &d->key);
key              3938 source4/heimdal/lib/krb5/crypto.c     *key = d;
key              3945 source4/heimdal/lib/krb5/crypto.c 		 const krb5_keyblock *key,
key              3956 source4/heimdal/lib/krb5/crypto.c 	etype = key->keytype;
key              3966 source4/heimdal/lib/krb5/crypto.c     if((*crypto)->et->keytype->size != key->keyvalue.length) {
key              3973 source4/heimdal/lib/krb5/crypto.c     ret = krb5_copy_keyblock(context, key, &(*crypto)->key.key);
key              3979 source4/heimdal/lib/krb5/crypto.c     (*crypto)->key.schedule = NULL;
key              3986 source4/heimdal/lib/krb5/crypto.c free_key_data(krb5_context context, struct key_data *key,
key              3989 source4/heimdal/lib/krb5/crypto.c     krb5_free_keyblock(context, key->key);
key              3990 source4/heimdal/lib/krb5/crypto.c     if(key->schedule) {
key              3992 source4/heimdal/lib/krb5/crypto.c 	    (*et->keytype->cleanup)(context, key);
key              3993 source4/heimdal/lib/krb5/crypto.c 	memset(key->schedule->data, 0, key->schedule->length);
key              3994 source4/heimdal/lib/krb5/crypto.c 	krb5_free_data(context, key->schedule);
key              4002 source4/heimdal/lib/krb5/crypto.c     free_key_data(context, &ku->key, et);
key              4014 source4/heimdal/lib/krb5/crypto.c     free_key_data(context, &crypto->key, crypto->et);
key              4116 source4/heimdal/lib/krb5/crypto.c 			   krb5_keyblock *key)
key              4132 source4/heimdal/lib/krb5/crypto.c     ALLOC(kd.key, 1);
key              4133 source4/heimdal/lib/krb5/crypto.c     if(kd.key == NULL) {
key              4138 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc(&kd.key->keyvalue, et->keytype->size);
key              4140 source4/heimdal/lib/krb5/crypto.c 	free(kd.key);
key              4143 source4/heimdal/lib/krb5/crypto.c     kd.key->keytype = etype;
key              4146 source4/heimdal/lib/krb5/crypto.c 	krb5_free_keyblock(context, kd.key);
key              4169 source4/heimdal/lib/krb5/crypto.c     ret = krb5_copy_keyblock_contents(context, kd.key, key);
key              4271 source4/heimdal/lib/krb5/crypto.c 		   krb5_keyblock *key)
key              4289 source4/heimdal/lib/krb5/crypto.c     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
key              4292 source4/heimdal/lib/krb5/crypto.c     key->keytype = type;
key              4294 source4/heimdal/lib/krb5/crypto.c  	(*et->keytype->random_to_key)(context, key, data, size);
key              4296 source4/heimdal/lib/krb5/crypto.c 	memcpy(key->keyvalue.data, data, et->keytype->size);
key              4308 source4/heimdal/lib/krb5/crypto.c 			 krb5_keyblock *key)
key              4354 source4/heimdal/lib/krb5/crypto.c     ret = krb5_random_to_key(context, type, keydata, keylen, key);
key              4458 source4/heimdal/lib/krb5/crypto.c 	     krb5_keyblock *key)
key              4529 source4/heimdal/lib/krb5/crypto.c     ret = krb5_random_to_key(context, enctype, keydata, keylen, key);
key                40 source4/heimdal/lib/krb5/generate_seq_number.c 			 const krb5_keyblock *key,
key                49 source4/heimdal/lib/krb5/generate_seq_number.c     ret = krb5_generate_subkey (context, key, &subkey);
key                40 source4/heimdal/lib/krb5/generate_subkey.c 		     const krb5_keyblock *key,
key                43 source4/heimdal/lib/krb5/generate_subkey.c     return krb5_generate_subkey_extended(context, key, key->keytype, subkey);
key                48 source4/heimdal/lib/krb5/generate_subkey.c 			      const krb5_keyblock *key,
key                61 source4/heimdal/lib/krb5/generate_subkey.c 	etype = key->keytype; /* use session key etype */
key                84 source4/heimdal/lib/krb5/get_cred.c 	       krb5_keyblock *key)
key               106 source4/heimdal/lib/krb5/get_cred.c 	ret = krb5_crypto_init(context, key, 0, &crypto);
key               245 source4/heimdal/lib/krb5/get_cred.c 	krb5_keyblock *key = NULL;
key               257 source4/heimdal/lib/krb5/get_cred.c 	    ret = krb5_generate_subkey (context, &krbtgt->session, &key);
key               263 source4/heimdal/lib/krb5/get_cred.c 	    ret = krb5_auth_con_setlocalsubkey(context, ac, key);
key               265 source4/heimdal/lib/krb5/get_cred.c 		if (key)
key               266 source4/heimdal/lib/krb5/get_cred.c 		    krb5_free_keyblock (context, key);
key               273 source4/heimdal/lib/krb5/get_cred.c 			     key ? key : &krbtgt->session);
key               275 source4/heimdal/lib/krb5/get_cred.c 	    if (key)
key               276 source4/heimdal/lib/krb5/get_cred.c 		krb5_free_keyblock (context, key);
key               287 source4/heimdal/lib/krb5/get_cred.c 	    if (key)
key               288 source4/heimdal/lib/krb5/get_cred.c 		krb5_free_keyblock (context, key);
key               292 source4/heimdal/lib/krb5/get_cred.c 	*subkey = key;
key               344 source4/heimdal/lib/krb5/get_cred.c 			 krb5_keyblock *key,
key               354 source4/heimdal/lib/krb5/get_cred.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               368 source4/heimdal/lib/krb5/get_for_creds.c     copy_EncryptionKey (&out_creds->session, &krb_cred_info->key);
key                81 source4/heimdal/lib/krb5/get_in_tkt.c 		      const krb5_keyblock const * key)
key               117 source4/heimdal/lib/krb5/get_in_tkt.c     ret = krb5_crypto_init(context, key, 0, &session);
key               209 source4/heimdal/lib/krb5/get_in_tkt.c 		      krb5_keyblock const * key)
key               247 source4/heimdal/lib/krb5/get_in_tkt.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               305 source4/heimdal/lib/krb5/get_in_tkt.c 	     krb5_keyblock *key,
key               315 source4/heimdal/lib/krb5/get_in_tkt.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               350 source4/heimdal/lib/krb5/get_in_tkt.c 		     krb5_keyblock *key,
key               370 source4/heimdal/lib/krb5/get_in_tkt.c     ret = (*decrypt_proc)(context, key, key_usage, decryptarg, rep);
key               378 source4/heimdal/lib/krb5/get_in_tkt.c     creds->session.keytype = rep->enc_part.key.keytype;
key               380 source4/heimdal/lib/krb5/get_in_tkt.c 			  rep->enc_part.key.keyvalue.data,
key               381 source4/heimdal/lib/krb5/get_in_tkt.c 			  rep->enc_part.key.keyvalue.length);
key               552 source4/heimdal/lib/krb5/get_in_tkt.c     memset (rep->enc_part.key.keyvalue.data, 0,
key               553 source4/heimdal/lib/krb5/get_in_tkt.c 	    rep->enc_part.key.keyvalue.length);
key               560 source4/heimdal/lib/krb5/get_in_tkt.c 		      krb5_enctype etype, krb5_keyblock *key)
key               581 source4/heimdal/lib/krb5/get_in_tkt.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               645 source4/heimdal/lib/krb5/get_in_tkt.c 	krb5_keyblock *key;
key               647 source4/heimdal/lib/krb5/get_in_tkt.c 	ret = (*key_proc)(context, enctypes[i], *salt, keyseed, &key);
key               651 source4/heimdal/lib/krb5/get_in_tkt.c 				     enctypes[i], key);
key               652 source4/heimdal/lib/krb5/get_in_tkt.c 	krb5_free_keyblock (context, key);
key               901 source4/heimdal/lib/krb5/get_in_tkt.c     krb5_keyblock *key;
key              1003 source4/heimdal/lib/krb5/get_in_tkt.c 	ret = (*key_proc)(context, etype, salt, keyseed, &key);
key              1010 source4/heimdal/lib/krb5/get_in_tkt.c 	ret = (*key_proc)(context, etype, salt, keyseed, &key);
key              1024 source4/heimdal/lib/krb5/get_in_tkt.c 				   key,
key              1033 source4/heimdal/lib/krb5/get_in_tkt.c     memset (key->keyvalue.data, 0, key->keyvalue.length);
key              1034 source4/heimdal/lib/krb5/get_in_tkt.c     krb5_free_keyblock_contents (context, key);
key              1035 source4/heimdal/lib/krb5/get_in_tkt.c     free (key);
key                43 source4/heimdal/lib/krb5/get_in_tkt_with_keytab.c 		      krb5_keyblock **key)
key                66 source4/heimdal/lib/krb5/get_in_tkt_with_keytab.c     ret = krb5_copy_keyblock (context, &entry.keyblock, key);
key                65 source4/heimdal/lib/krb5/init_creds_pw.c 		 krb5_keyblock **key)
key                78 source4/heimdal/lib/krb5/init_creds_pw.c     *key = malloc(sizeof(**key));
key                79 source4/heimdal/lib/krb5/init_creds_pw.c     if (*key == NULL)
key                82 source4/heimdal/lib/krb5/init_creds_pw.c 					      salt, opaque, *key);
key                84 source4/heimdal/lib/krb5/init_creds_pw.c 	free(*key);
key                85 source4/heimdal/lib/krb5/init_creds_pw.c 	*key = NULL;
key               483 source4/heimdal/lib/krb5/init_creds_pw.c 			krb5_keyblock **key)
key               485 source4/heimdal/lib/krb5/init_creds_pw.c     return krb5_copy_keyblock (context, keyseed, key);
key               871 source4/heimdal/lib/krb5/init_creds_pw.c 		      krb5_enctype etype, krb5_keyblock *key)
key               893 source4/heimdal/lib/krb5/init_creds_pw.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               952 source4/heimdal/lib/krb5/init_creds_pw.c 	krb5_keyblock *key;
key               955 source4/heimdal/lib/krb5/init_creds_pw.c 			  *salt, s2kparams, &key);
key               958 source4/heimdal/lib/krb5/init_creds_pw.c 	ret = make_pa_enc_timestamp (context, md, enctypes[i], key);
key               959 source4/heimdal/lib/krb5/init_creds_pw.c 	krb5_free_keyblock (context, key);
key              1011 source4/heimdal/lib/krb5/init_creds_pw.c 		     krb5_keyblock **key)
key              1016 source4/heimdal/lib/krb5/init_creds_pw.c 			   salt, s2kparams, key);
key              1142 source4/heimdal/lib/krb5/init_creds_pw.c 		       krb5_keyblock **key)
key              1191 source4/heimdal/lib/krb5/init_creds_pw.c 				   key);
key              1198 source4/heimdal/lib/krb5/init_creds_pw.c 				   paid.salt, paid.s2kparams, etype, key);
key              1349 source4/heimdal/lib/krb5/init_creds_pw.c 	krb5_keyblock *key = NULL;
key              1362 source4/heimdal/lib/krb5/init_creds_pw.c 				     &ctx->as_req, &rep, hi, &key);
key              1369 source4/heimdal/lib/krb5/init_creds_pw.c 				   key,
key              1377 source4/heimdal/lib/krb5/init_creds_pw.c 	krb5_free_keyblock(context, key);
key              1561 source4/heimdal/lib/krb5/init_creds_pw.c 			      krb5_keyblock **key)
key              1563 source4/heimdal/lib/krb5/init_creds_pw.c     return krb5_copy_keyblock (context, keyseed, key);
key              1061 source4/heimdal/lib/krb5/kcm.c 			     krb5_keyblock *key)
key              1091 source4/heimdal/lib/krb5/kcm.c     ret = krb5_store_keyblock(request, *key);
key               107 source4/heimdal/lib/krb5/keyblock.c 		   krb5_keyblock *key)
key               112 source4/heimdal/lib/krb5/keyblock.c     memset(key, 0, sizeof(*key));
key               125 source4/heimdal/lib/krb5/keyblock.c     ret = krb5_data_copy(&key->keyvalue, data, len);
key               130 source4/heimdal/lib/krb5/keyblock.c     key->keytype = type;
key               192 source4/heimdal/lib/krb5/keytab.c 			 krb5_keyblock **key)
key               210 source4/heimdal/lib/krb5/keytab.c     ret = krb5_copy_keyblock (context, &entry.keyblock, key);
key                46 source4/heimdal/lib/krb5/mit_glue.c 		     const krb5_keyblock *key,
key                54 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                66 source4/heimdal/lib/krb5/mit_glue.c krb5_c_verify_checksum(krb5_context context, const krb5_keyblock *key,
key                76 source4/heimdal/lib/krb5/mit_glue.c 			       key, usage, data, &data_cksum);
key               190 source4/heimdal/lib/krb5/mit_glue.c     krb5_keyblock key;
key               192 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_generate_random_keyblock(context, enctype, &key);
key               196 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, &key, 0, &crypto);
key               197 source4/heimdal/lib/krb5/mit_glue.c     krb5_free_keyblock_contents(context, &key);
key               208 source4/heimdal/lib/krb5/mit_glue.c 	       const krb5_keyblock key,
key               217 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, &key, input->enctype, &crypto);
key               248 source4/heimdal/lib/krb5/mit_glue.c 	       const krb5_keyblock *key,
key               257 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               296 source4/heimdal/lib/krb5/mit_glue.c     krb5_keyblock key;
key               298 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_generate_random_keyblock(context, enctype, &key);
key               302 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, &key, 0, &crypto);
key               303 source4/heimdal/lib/krb5/mit_glue.c     krb5_free_keyblock_contents(context, &key);
key               356 source4/heimdal/lib/krb5/mit_glue.c 	   const krb5_keyblock *key,
key               363 source4/heimdal/lib/krb5/mit_glue.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                53 source4/heimdal/lib/krb5/mk_priv.c     krb5_keyblock *key;
key                62 source4/heimdal/lib/krb5/mk_priv.c 	key = auth_context->local_subkey;
key                64 source4/heimdal/lib/krb5/mk_priv.c 	key = auth_context->remote_subkey;
key                66 source4/heimdal/lib/krb5/mk_priv.c 	key = auth_context->keyblock;
key               109 source4/heimdal/lib/krb5/mk_priv.c     s.enc_part.etype = key->keytype;
key               112 source4/heimdal/lib/krb5/mk_priv.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               102 source4/heimdal/lib/krb5/n-fold.c _krb5_n_fold(const void *str, size_t len, void *key, size_t size)
key               116 source4/heimdal/lib/krb5/n-fold.c     memset(key, 0, size);
key               124 source4/heimdal/lib/krb5/n-fold.c 	    add1(key, tmp, size);
key               415 source4/heimdal/lib/krb5/pac.c 		const krb5_keyblock *key)
key               457 source4/heimdal/lib/krb5/pac.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               481 source4/heimdal/lib/krb5/pac.c 		const krb5_keyblock *key,
key               489 source4/heimdal/lib/krb5/pac.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               831 source4/heimdal/lib/krb5/pac.c 	     const krb5_keyblock *key,
key               839 source4/heimdal/lib/krb5/pac.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               784 source4/heimdal/lib/krb5/pkinit.c 		  krb5_keyblock **key)
key               808 source4/heimdal/lib/krb5/pkinit.c     *key = malloc (sizeof (**key));
key               809 source4/heimdal/lib/krb5/pkinit.c     if (*key == NULL) {
key               816 source4/heimdal/lib/krb5/pkinit.c     ret = copy_EncryptionKey(&key_pack.replyKey, *key);
key               821 source4/heimdal/lib/krb5/pkinit.c 	free(*key);
key               822 source4/heimdal/lib/krb5/pkinit.c 	*key = NULL;
key               832 source4/heimdal/lib/krb5/pkinit.c 	      krb5_keyblock **key)
key               873 source4/heimdal/lib/krb5/pkinit.c     *key = malloc (sizeof (**key));
key               874 source4/heimdal/lib/krb5/pkinit.c     if (*key == NULL) {
key               881 source4/heimdal/lib/krb5/pkinit.c     ret = copy_EncryptionKey(&key_pack.replyKey, *key);
key               886 source4/heimdal/lib/krb5/pkinit.c 	free(*key);
key               887 source4/heimdal/lib/krb5/pkinit.c 	*key = NULL;
key               992 source4/heimdal/lib/krb5/pkinit.c 	       	      krb5_keyblock **key)
key              1098 source4/heimdal/lib/krb5/pkinit.c 	ret = get_reply_key(context, &content, req_buffer, key);
key              1100 source4/heimdal/lib/krb5/pkinit.c 	    ret = get_reply_key_win(context, &content, nonce, key);
key              1103 source4/heimdal/lib/krb5/pkinit.c 	ret = get_reply_key(context, &content, req_buffer, key);
key              1132 source4/heimdal/lib/krb5/pkinit.c                   krb5_keyblock **key)
key              1264 source4/heimdal/lib/krb5/pkinit.c     *key = malloc (sizeof (**key));
key              1265 source4/heimdal/lib/krb5/pkinit.c     if (*key == NULL) {
key              1276 source4/heimdal/lib/krb5/pkinit.c 				   *key);
key              1280 source4/heimdal/lib/krb5/pkinit.c 	free(*key);
key              1281 source4/heimdal/lib/krb5/pkinit.c 	*key = NULL;
key              1311 source4/heimdal/lib/krb5/pkinit.c 		     krb5_keyblock **key)
key              1367 source4/heimdal/lib/krb5/pkinit.c 				    nonce, pa, key);
key              1371 source4/heimdal/lib/krb5/pkinit.c 					ctx, etype, hi, nonce, req_buffer, pa, key);
key              1423 source4/heimdal/lib/krb5/pkinit.c 					ctx, etype, hi, nonce, req_buffer, pa, key);
key               276 source4/heimdal/lib/krb5/rd_cred.c 	copy_EncryptionKey (&kci->key, &creds->session);
key                50 source4/heimdal/lib/krb5/rd_priv.c     krb5_keyblock *key;
key                85 source4/heimdal/lib/krb5/rd_priv.c 	key = auth_context->remote_subkey;
key                87 source4/heimdal/lib/krb5/rd_priv.c 	key = auth_context->local_subkey;
key                89 source4/heimdal/lib/krb5/rd_priv.c 	key = auth_context->keyblock;
key                91 source4/heimdal/lib/krb5/rd_priv.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                40 source4/heimdal/lib/krb5/rd_req.c 		      krb5_keyblock *key,
key                49 source4/heimdal/lib/krb5/rd_req.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key                69 source4/heimdal/lib/krb5/rd_req.c 		       EncryptionKey *key,
key                79 source4/heimdal/lib/krb5/rd_req.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               222 source4/heimdal/lib/krb5/rd_req.c 		    krb5_keyblock *key,
key               228 source4/heimdal/lib/krb5/rd_req.c     ret = decrypt_tkt_enc_part (context, key, &ticket->enc_part, &t);
key               275 source4/heimdal/lib/krb5/rd_req.c     krb5_keyblock *key;
key               288 source4/heimdal/lib/krb5/rd_req.c     ret = krb5_auth_con_getkey(context, ac, &key);
key               293 source4/heimdal/lib/krb5/rd_req.c     ret = krb5_crypto_init(context, key, 0, &crypto);
key               305 source4/heimdal/lib/krb5/rd_req.c     krb5_free_keyblock(context, key);
key               393 source4/heimdal/lib/krb5/rd_req.c 				 &t->ticket.key,
key               478 source4/heimdal/lib/krb5/rd_req.c     ret = krb5_copy_keyblock(context, &t->ticket.key, &ac->keyblock);
key               292 source4/heimdal/lib/krb5/ticket.c 			  &ticket->ticket.key, ad, 0);
key               321 source4/heimdal/lib/krb5/v4_glue.c decrypt_etext(krb5_context context, const krb5_keyblock *key,
key               327 source4/heimdal/lib/krb5/v4_glue.c     ret = krb5_crypto_init(context, key, ETYPE_DES_PCBC_NONE, &crypto);
key               347 source4/heimdal/lib/krb5/v4_glue.c 		 const krb5_keyblock *key,
key               370 source4/heimdal/lib/krb5/v4_glue.c     ret = krb5_crypto_init(context, key, ETYPE_DES_PCBC_NONE, &crypto);
key               419 source4/heimdal/lib/krb5/v4_glue.c 			const krb5_keyblock *key,
key               451 source4/heimdal/lib/krb5/v4_glue.c     ret = storage_to_etext(context, sp, key, enc_data);
key               476 source4/heimdal/lib/krb5/v4_glue.c 		      const krb5_keyblock *key,
key               511 source4/heimdal/lib/krb5/v4_glue.c     ret = storage_to_etext(context, sp, key, enc_data);
key               649 source4/heimdal/lib/krb5/v4_glue.c 			const krb5_keyblock *key,
key               667 source4/heimdal/lib/krb5/v4_glue.c     RCHECK(ret, decrypt_etext(context, key, enc_ticket, &ticket), error);
key               747 source4/heimdal/lib/krb5/v4_glue.c 		 const krb5_keyblock *key,
key               828 source4/heimdal/lib/krb5/v4_glue.c     ret = _krb5_krb_decomp_ticket(context, &ticket, key, local_realm,
key               877 source4/heimdal/lib/ntlm/ntlm.c     DES_cblock key;
key               880 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[0] =  hash[0];
key               881 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[1] = (hash[0] << 7) | (hash[1] >> 1);
key               882 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[2] = (hash[1] << 6) | (hash[2] >> 2);
key               883 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[3] = (hash[2] << 5) | (hash[3] >> 3);
key               884 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[4] = (hash[3] << 4) | (hash[4] >> 4);
key               885 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[5] = (hash[4] << 3) | (hash[5] >> 5);
key               886 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[6] = (hash[5] << 2) | (hash[6] >> 6);
key               887 source4/heimdal/lib/ntlm/ntlm.c     ((unsigned char*)key)[7] = (hash[6] << 1);
key               889 source4/heimdal/lib/ntlm/ntlm.c     DES_set_odd_parity(&key);
key               890 source4/heimdal/lib/ntlm/ntlm.c     DES_set_key_unchecked(&key, &sched);
key               893 source4/heimdal/lib/ntlm/ntlm.c     memset(key, 0, sizeof(key));
key               909 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_nt_key(const char *password, struct ntlm_buf *key)
key               915 source4/heimdal/lib/ntlm/ntlm.c     key->data = malloc(MD5_DIGEST_LENGTH);
key               916 source4/heimdal/lib/ntlm/ntlm.c     if (key->data == NULL)
key               918 source4/heimdal/lib/ntlm/ntlm.c     key->length = MD5_DIGEST_LENGTH;
key               922 source4/heimdal/lib/ntlm/ntlm.c 	heim_ntlm_free_buf(key);
key               927 source4/heimdal/lib/ntlm/ntlm.c     MD4_Final(key->data, &ctx);
key               947 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_calculate_ntlm1(void *key, size_t len,
key               956 source4/heimdal/lib/ntlm/ntlm.c     memcpy(res, key, len);
key               986 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_build_ntlm1_master(void *key, size_t len,
key              1017 source4/heimdal/lib/ntlm/ntlm.c 	MD4_Update(&ctx, key, len);
key              1048 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_ntlmv2_key(const void *key, size_t len,
key              1057 source4/heimdal/lib/ntlm/ntlm.c     HMAC_Init_ex(&c, key, len, EVP_md5(), NULL);
key              1117 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_calculate_ntlm2(const void *key, size_t len,
key              1141 source4/heimdal/lib/ntlm/ntlm.c     heim_ntlm_ntlmv2_key(key, len, username, target, ntlmv2);
key              1220 source4/heimdal/lib/ntlm/ntlm.c heim_ntlm_verify_ntlm2(const void *key, size_t len,
key              1251 source4/heimdal/lib/ntlm/ntlm.c     heim_ntlm_ntlmv2_key(key, len, username, target, ntlmv2);
key                70 source4/heimdal/lib/roken/resolve.c     DECL(key),
key               259 source4/heimdal/lib/roken/resolve.c 	rr->u.key = malloc (sizeof(*rr->u.key) + key_len - 1);
key               260 source4/heimdal/lib/roken/resolve.c 	if (rr->u.key == NULL) {
key               265 source4/heimdal/lib/roken/resolve.c 	rr->u.key->flags     = (p[0] << 8) | p[1];
key               266 source4/heimdal/lib/roken/resolve.c 	rr->u.key->protocol  = p[2];
key               267 source4/heimdal/lib/roken/resolve.c 	rr->u.key->algorithm = p[3];
key               268 source4/heimdal/lib/roken/resolve.c 	rr->u.key->key_len   = key_len;
key               269 source4/heimdal/lib/roken/resolve.c 	memcpy (rr->u.key->key_data, p + 4, key_len);
key               251 source4/heimdal/lib/roken/resolve.h 	struct key_record *key;
key                41 source4/heimdal/lib/wind/combining.c translation_cmp(const void *key, const void *data)
key                43 source4/heimdal/lib/wind/combining.c     const struct translation *t1 = (const struct translation *)key;
key                46 source4/heimdal/lib/wind/combining.c     return t1->key - t2->key;
key                46 source4/heimdal/lib/wind/map.c translation_cmp(const void *key, const void *data)
key                48 source4/heimdal/lib/wind/map.c     const struct translation *t1 = (const struct translation *)key;
key                51 source4/heimdal/lib/wind/map.c     return t1->key - t2->key;
key                48 source4/heimdal/lib/wind/normalize.c translation_cmp(const void *key, const void *data)
key                50 source4/heimdal/lib/wind/normalize.c     const struct translation *t1 = (const struct translation *)key;
key                53 source4/heimdal/lib/wind/normalize.c     return t1->key - t2->key;
key               335 source4/kdc/hdb-samba4.c 		Key key;
key               337 source4/kdc/hdb-samba4.c 		key.mkvno = 0;
key               338 source4/kdc/hdb-samba4.c 		key.salt = NULL; /* No salt for this enc type */
key               343 source4/kdc/hdb-samba4.c 					 &key.key);
key               348 source4/kdc/hdb-samba4.c 		entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
key               355 source4/kdc/hdb-samba4.c 			Key key;
key               372 source4/kdc/hdb-samba4.c 			key.mkvno = 0;
key               373 source4/kdc/hdb-samba4.c 			key.salt = NULL;
key               380 source4/kdc/hdb-samba4.c 				key.salt = calloc(1, sizeof(*key.salt));
key               381 source4/kdc/hdb-samba4.c 				if (key.salt == NULL) {
key               386 source4/kdc/hdb-samba4.c 				key.salt->type = hdb_pw_salt;
key               388 source4/kdc/hdb-samba4.c 				ret = krb5_data_copy(&key.salt->salt, salt.data, salt.length);
key               390 source4/kdc/hdb-samba4.c 					free(key.salt);
key               391 source4/kdc/hdb-samba4.c 					key.salt = NULL;
key               402 source4/kdc/hdb-samba4.c 						 &key.key);
key               404 source4/kdc/hdb-samba4.c 				if (key.salt) {
key               405 source4/kdc/hdb-samba4.c 					free_Salt(key.salt);
key               406 source4/kdc/hdb-samba4.c 					free(key.salt);
key               407 source4/kdc/hdb-samba4.c 					key.salt = NULL;
key               412 source4/kdc/hdb-samba4.c 			entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
key               418 source4/kdc/hdb-samba4.c 			Key key;
key               435 source4/kdc/hdb-samba4.c 			key.mkvno = 0;
key               436 source4/kdc/hdb-samba4.c 			key.salt = NULL;
key               443 source4/kdc/hdb-samba4.c 				key.salt = calloc(1, sizeof(*key.salt));
key               444 source4/kdc/hdb-samba4.c 				if (key.salt == NULL) {
key               449 source4/kdc/hdb-samba4.c 				key.salt->type = hdb_pw_salt;
key               451 source4/kdc/hdb-samba4.c 				ret = krb5_data_copy(&key.salt->salt, salt.data, salt.length);
key               453 source4/kdc/hdb-samba4.c 					free(key.salt);
key               454 source4/kdc/hdb-samba4.c 					key.salt = NULL;
key               463 source4/kdc/hdb-samba4.c 						 &key.key);
key               465 source4/kdc/hdb-samba4.c 				if (key.salt) {
key               466 source4/kdc/hdb-samba4.c 					free_Salt(key.salt);
key               467 source4/kdc/hdb-samba4.c 					free(key.salt);
key               468 source4/kdc/hdb-samba4.c 					key.salt = NULL;
key               473 source4/kdc/hdb-samba4.c 			entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
key               678 source4/kdc/hdb-samba4.c 		entry_ex->entry.etypes->val[i] = entry_ex->entry.keys.val[i].key.keytype;
key               794 source4/kdc/hdb-samba4.c 		Key key;
key               798 source4/kdc/hdb-samba4.c 		key.mkvno = 0;
key               799 source4/kdc/hdb-samba4.c 		key.salt = NULL; /* No salt for this enc type */
key               809 source4/kdc/hdb-samba4.c 					 &key.key);
key               811 source4/kdc/hdb-samba4.c 		entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
key               867 source4/kdc/hdb-samba4.c 		entry_ex->entry.etypes->val[i] = entry_ex->entry.keys.val[i].key.keytype;
key               576 source4/kdc/kdc.c 	Key *key;
key               635 source4/kdc/kdc.c 	ret = hdb_enctype2key(kdc->smb_krb5_context->krb5_context, &ent.entry, etype, &key);
key               643 source4/kdc/kdc.c 	keyblock = key->key;
key               475 source4/lib/ldb/ldb_tdb/ldb_index.c 			    unsigned int *v_idx, const char *key)
key               479 source4/lib/ldb/ldb_tdb/ldb_index.c 		if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
key               869 source4/lib/ldb/ldb_tdb/ldb_index.c 	struct ldb_dn *key;
key               885 source4/lib/ldb/ldb_tdb/ldb_index.c 	key = ltdb_index_key(ldb, LTDB_IDXONE, &val);
key               886 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (!key) {
key               897 source4/lib/ldb/ldb_tdb/ldb_index.c 	ret = ltdb_search_dn1_index(module, key, msg);
key               898 source4/lib/ldb/ldb_tdb/ldb_index.c 	talloc_free(key);
key              1505 source4/lib/ldb/ldb_tdb/ldb_index.c static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key              1508 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
key              1509 source4/lib/ldb/ldb_tdb/ldb_index.c 		return tdb_delete(tdb, key);
key              1517 source4/lib/ldb/ldb_tdb/ldb_index.c static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key              1528 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, "DN=@", 4) == 0 ||
key              1529 source4/lib/ldb/ldb_tdb/ldb_index.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
key              1554 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strcmp((char *)key2.dptr, (char *)key.dptr) != 0) {
key              1555 source4/lib/ldb/ldb_tdb/ldb_index.c 		tdb_delete(tdb, key);
key              1561 source4/lib/ldb/ldb_tdb/ldb_index.c 		dn = (char *)key.dptr + 3;
key               374 source4/lib/ldb/ldb_tdb/ldb_search.c static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
key               384 source4/lib/ldb/ldb_tdb/ldb_search.c 	if (key.dsize < 4 || 
key               385 source4/lib/ldb/ldb_tdb/ldb_search.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
key               403 source4/lib/ldb/ldb_tdb/ldb_search.c 				     (char *)key.dptr + 3);
key               117 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	TDB_DATA key;
key               148 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = (uint8_t *)key_str;
key               149 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dsize = strlen(key_str) + 1;
key               151 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	return key;
key               155 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = NULL;
key               156 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dsize = 0;
key               157 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	return key;
key               604 source4/lib/ldb/pyldb.c 	PyObject *key, *value;
key               625 source4/lib/ldb/pyldb.c 		while (PyDict_Next(py_msg, &dict_pos, &key, &value)) {
key               626 source4/lib/ldb/pyldb.c 			char *key_str = PyString_AsString(key);
key                26 source4/lib/registry/dir.c 	struct hive_key key;
key                45 source4/lib/registry/dir.c 		struct dir_key *key = talloc(mem_ctx, struct dir_key);
key                46 source4/lib/registry/dir.c 		key->key.ops = &reg_backend_dir;
key                47 source4/lib/registry/dir.c 		key->path = talloc_steal(key, path);
key                48 source4/lib/registry/dir.c 		*result = (struct hive_key *)key;
key               148 source4/lib/registry/dir.c 	ret->key.ops = &reg_backend_dir;
key               206 source4/lib/registry/dir.c 			  const char *location, struct hive_key **key)
key               214 source4/lib/registry/dir.c 	dk->key.ops = &reg_backend_dir;
key               216 source4/lib/registry/dir.c 	*key = (struct hive_key *)dk;
key               221 source4/lib/registry/dir.c 			    const char *location, struct hive_key **key)
key               224 source4/lib/registry/dir.c 		*key = NULL;
key               228 source4/lib/registry/dir.c 	return reg_open_directory(parent_ctx, location, key);
key               231 source4/lib/registry/dir.c static WERROR reg_dir_get_info(TALLOC_CTX *ctx, const struct hive_key *key,
key               241 source4/lib/registry/dir.c 	const struct dir_key *dk = talloc_get_type(key, struct dir_key);
key               245 source4/lib/registry/dir.c 	SMB_ASSERT(key != NULL);
key               307 source4/lib/registry/dir.c static WERROR reg_dir_set_value(struct hive_key *key, const char *name,
key               310 source4/lib/registry/dir.c 	const struct dir_key *dk = talloc_get_type(key, struct dir_key);
key               322 source4/lib/registry/dir.c 				struct hive_key *key, const char *name,
key               325 source4/lib/registry/dir.c 	const struct dir_key *dk = talloc_get_type(key, struct dir_key);
key               345 source4/lib/registry/dir.c 				 struct hive_key *key, int idx,
key               349 source4/lib/registry/dir.c 	const struct dir_key *dk = talloc_get_type(key, struct dir_key);
key               369 source4/lib/registry/dir.c 			W_ERROR_NOT_OK_RETURN(reg_dir_get_value(mem_ctx, key,
key               383 source4/lib/registry/dir.c static WERROR reg_dir_del_value (struct hive_key *key, const char *name)
key               385 source4/lib/registry/dir.c 	const struct dir_key *dk = talloc_get_type(key, struct dir_key);
key               386 source4/lib/registry/dir.c 	char *path = talloc_asprintf(key, "%s/%s", dk->path, name);
key                68 source4/lib/registry/hive.c 				  const struct hive_key *key,
key                76 source4/lib/registry/hive.c 	return key->ops->get_key_info(mem_ctx, key, classname, num_subkeys,
key                86 source4/lib/registry/hive.c 				  struct hive_key **key)
key                91 source4/lib/registry/hive.c 					desc, key);
key                94 source4/lib/registry/hive.c _PUBLIC_ WERROR hive_key_del(const struct hive_key *key, const char *name)
key                96 source4/lib/registry/hive.c 	return key->ops->del_key(key, name);
key               100 source4/lib/registry/hive.c 				     const struct hive_key *key,
key               104 source4/lib/registry/hive.c 	return key->ops->get_key_by_name(mem_ctx, key, name, subkey);
key               108 source4/lib/registry/hive.c 		     const struct hive_key *key, uint32_t idx,
key               113 source4/lib/registry/hive.c 	return key->ops->enum_key(mem_ctx, key, idx, name, classname,
key               117 source4/lib/registry/hive.c WERROR hive_key_set_value(struct hive_key *key, const char *name, uint32_t type,
key               120 source4/lib/registry/hive.c 	if (key->ops->set_value == NULL)
key               123 source4/lib/registry/hive.c 	return key->ops->set_value(key, name, type, data);
key               127 source4/lib/registry/hive.c 		      struct hive_key *key, const char *name,
key               130 source4/lib/registry/hive.c 	if (key->ops->get_value_by_name == NULL)
key               133 source4/lib/registry/hive.c 	return key->ops->get_value_by_name(mem_ctx, key, name, type, data);
key               137 source4/lib/registry/hive.c 			       struct hive_key *key, uint32_t idx,
key               141 source4/lib/registry/hive.c 	if (key->ops->enum_value == NULL)
key               144 source4/lib/registry/hive.c 	return key->ops->enum_value(mem_ctx, key, idx, name, type, data);
key               148 source4/lib/registry/hive.c 			 struct hive_key *key, 
key               151 source4/lib/registry/hive.c 	if (key->ops->get_sec_desc == NULL)
key               154 source4/lib/registry/hive.c 	return key->ops->get_sec_desc(mem_ctx, key, security);
key               157 source4/lib/registry/hive.c WERROR hive_set_sec_desc(struct hive_key *key, 
key               160 source4/lib/registry/hive.c 	if (key->ops->set_sec_desc == NULL)
key               163 source4/lib/registry/hive.c 	return key->ops->set_sec_desc(key, security);
key               166 source4/lib/registry/hive.c WERROR hive_key_del_value(struct hive_key *key, const char *name)
key               168 source4/lib/registry/hive.c 	if (key->ops->delete_value == NULL)
key               171 source4/lib/registry/hive.c 	return key->ops->delete_value(key, name);
key               174 source4/lib/registry/hive.c WERROR hive_key_flush(struct hive_key *key)
key               176 source4/lib/registry/hive.c 	if (key->ops->flush_key == NULL)
key               179 source4/lib/registry/hive.c 	return key->ops->flush_key(key);
key                59 source4/lib/registry/interface.c 					       struct registry_key **key)
key                67 source4/lib/registry/interface.c 						      key);
key                77 source4/lib/registry/interface.c 				       uint32_t hkey, struct registry_key **key)
key                79 source4/lib/registry/interface.c 	return ctx->ops->get_predefined_key(ctx, hkey, key);
key               108 source4/lib/registry/interface.c 					   const struct registry_key *key,
key               112 source4/lib/registry/interface.c 	if (key == NULL)
key               115 source4/lib/registry/interface.c 	if (key->context->ops->enum_value == NULL)
key               118 source4/lib/registry/interface.c 	return key->context->ops->enum_value(mem_ctx, key, idx, name,
key               126 source4/lib/registry/interface.c 				 const struct registry_key *key,
key               135 source4/lib/registry/interface.c 	if (key == NULL)
key               138 source4/lib/registry/interface.c 	if (key->context->ops->get_key_info == NULL)
key               141 source4/lib/registry/interface.c 	return key->context->ops->get_key_info(mem_ctx,
key               142 source4/lib/registry/interface.c 					       key, classname, num_subkeys,
key               152 source4/lib/registry/interface.c 					    const struct registry_key *key,
key               157 source4/lib/registry/interface.c 	if (key == NULL)
key               160 source4/lib/registry/interface.c 	if (key->context->ops->enum_key == NULL)
key               163 source4/lib/registry/interface.c 	return key->context->ops->enum_key(mem_ctx, key, idx, name,
key               171 source4/lib/registry/interface.c 					  const struct registry_key *key,
key               176 source4/lib/registry/interface.c 	if (key == NULL)
key               179 source4/lib/registry/interface.c 	if (key->context->ops->get_value == NULL)
key               182 source4/lib/registry/interface.c 	return key->context->ops->get_value(mem_ctx, key, name, type, data);
key               224 source4/lib/registry/interface.c _PUBLIC_ WERROR reg_val_set(struct registry_key *key, const char *value,
key               227 source4/lib/registry/interface.c 	if (key == NULL)
key               231 source4/lib/registry/interface.c 	if (key->context->ops->set_value == NULL) {
key               233 source4/lib/registry/interface.c 				  key->context->ops->name));
key               237 source4/lib/registry/interface.c 	return key->context->ops->set_value(key, value, type, data);
key               244 source4/lib/registry/interface.c 				 const struct registry_key *key,
key               247 source4/lib/registry/interface.c 	if (key == NULL)
key               251 source4/lib/registry/interface.c 	if (key->context->ops->get_sec_desc == NULL)
key               254 source4/lib/registry/interface.c 	return key->context->ops->get_sec_desc(ctx, key, secdesc);
key               260 source4/lib/registry/interface.c _PUBLIC_ WERROR reg_del_value(struct registry_key *key, const char *valname)
key               262 source4/lib/registry/interface.c 	if (key == NULL)
key               265 source4/lib/registry/interface.c 	if (key->context->ops->delete_value == NULL)
key               268 source4/lib/registry/interface.c 	return key->context->ops->delete_value(key, valname);
key               274 source4/lib/registry/interface.c _PUBLIC_ WERROR reg_key_flush(struct registry_key *key)
key               276 source4/lib/registry/interface.c 	if (key == NULL)
key               279 source4/lib/registry/interface.c 	if (key->context->ops->flush_key == NULL)
key               282 source4/lib/registry/interface.c 	return key->context->ops->flush_key(key);
key               285 source4/lib/registry/interface.c _PUBLIC_ WERROR reg_set_sec_desc(struct registry_key *key,
key               288 source4/lib/registry/interface.c 	if (key == NULL)
key               291 source4/lib/registry/interface.c 	if (key->context->ops->set_sec_desc == NULL)
key               294 source4/lib/registry/interface.c 	return key->context->ops->set_sec_desc(key, security);
key                33 source4/lib/registry/ldb.c 	struct hive_key key;
key               151 source4/lib/registry/ldb.c static int reg_close_ldb_key(struct ldb_key_data *key)
key               153 source4/lib/registry/ldb.c 	if (key->subkeys != NULL) {
key               154 source4/lib/registry/ldb.c 		talloc_free(key->subkeys);
key               155 source4/lib/registry/ldb.c 		key->subkeys = NULL;
key               158 source4/lib/registry/ldb.c 	if (key->values != NULL) {
key               159 source4/lib/registry/ldb.c 		talloc_free(key->values);
key               160 source4/lib/registry/ldb.c 		key->values = NULL;
key               395 source4/lib/registry/ldb.c 			   const char *name, struct hive_key **key)
key               420 source4/lib/registry/ldb.c 	newkd->key.ops = &reg_backend_ldb;
key               424 source4/lib/registry/ldb.c 	*key = (struct hive_key *)newkd;
key               463 source4/lib/registry/ldb.c 	kd->key.ops = &reg_backend_ldb;
key               506 source4/lib/registry/ldb.c 	newkd->key.ops = &reg_backend_ldb;
key               518 source4/lib/registry/ldb.c static WERROR ldb_del_value (struct hive_key *key, const char *child)
key               521 source4/lib/registry/ldb.c 	struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
key               572 source4/lib/registry/ldb.c static WERROR ldb_del_key(const struct hive_key *key, const char *name)
key               575 source4/lib/registry/ldb.c 	struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data);
key               585 source4/lib/registry/ldb.c 	werr = ldb_open_key(mem_ctx, key, name, &hk);
key               591 source4/lib/registry/ldb.c 	ldap_path = reg_path_to_ldb(mem_ctx, key, name, NULL);
key               736 source4/lib/registry/ldb.c 			       const struct hive_key *key,
key               745 source4/lib/registry/ldb.c 	struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
key                36 source4/lib/registry/local.c 		struct hive_key *key;
key               126 source4/lib/registry/local.c 				uint32_t key_id, struct registry_key **key)
key               141 source4/lib/registry/local.c 	*key = reg_import_hive_key(ctx, mp->key,
key               149 source4/lib/registry/local.c 			     const struct registry_key *key, uint32_t idx,
key               154 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               165 source4/lib/registry/local.c 			       struct registry_key **key)
key               203 source4/lib/registry/local.c 	*key = reg_import_hive_key(local_parent->global.context, hivekey,
key               210 source4/lib/registry/local.c static WERROR local_set_value(struct registry_key *key, const char *name,
key               213 source4/lib/registry/local.c 	struct local_key *local = (struct local_key *)key;
key               219 source4/lib/registry/local.c 			      const struct registry_key *key,
key               222 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               228 source4/lib/registry/local.c 			       const struct registry_key *key, uint32_t idx,
key               233 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               239 source4/lib/registry/local.c static WERROR local_delete_key(struct registry_key *key, const char *name)
key               241 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               246 source4/lib/registry/local.c static WERROR local_delete_value(struct registry_key *key, const char *name)
key               248 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               253 source4/lib/registry/local.c static WERROR local_flush_key(struct registry_key *key)
key               255 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               261 source4/lib/registry/local.c 				 const struct registry_key *key,
key               270 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               278 source4/lib/registry/local.c 				 const struct registry_key *key, 
key               281 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               285 source4/lib/registry/local.c static WERROR local_set_sec_desc(struct registry_key *key, 
key               288 source4/lib/registry/local.c 	const struct local_key *local = (const struct local_key *)key;
key               335 source4/lib/registry/local.c 	mp->key = hive_key;
key               452 source4/lib/registry/patchfile.c 	struct registry_key *key;
key               456 source4/lib/registry/patchfile.c 	error = reg_open_key_abs(ctx, ctx, key_name, &key);
key               463 source4/lib/registry/patchfile.c 	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key, NULL,
key               467 source4/lib/registry/patchfile.c 			ctx, key, 0, &value_name, NULL, NULL))) {
key               468 source4/lib/registry/patchfile.c 		error = reg_del_value(key, value_name);
key               203 source4/lib/registry/patchfile_preg.c 	char *key = NULL;
key               247 source4/lib/registry/patchfile_preg.c 		key = talloc_strdup(mem_ctx, buf);
key               307 source4/lib/registry/patchfile_preg.c 			callbacks->del_all_values(callback_data, key);
key               311 source4/lib/registry/patchfile_preg.c 			callbacks->del_value(callback_data, key, p);
key               321 source4/lib/registry/patchfile_preg.c 				callbacks->del_value(callback_data, key, p);
key               325 source4/lib/registry/patchfile_preg.c 			callbacks->del_value(callback_data, key, p);
key               336 source4/lib/registry/patchfile_preg.c 							   key, p);
key               342 source4/lib/registry/patchfile_preg.c 			full_key = talloc_asprintf(mem_ctx, "%s\\%s", key, p);
key               346 source4/lib/registry/patchfile_preg.c 			callbacks->add_key(callback_data, key);
key               347 source4/lib/registry/patchfile_preg.c 			callbacks->set_value(callback_data, key, value_name,
key               354 source4/lib/registry/patchfile_preg.c 	talloc_free(key);
key                48 source4/lib/registry/pyregistry.c 	struct registry_key *key;
key                53 source4/lib/registry/pyregistry.c 	result = reg_get_predefined_key_by_name(ctx, name, &key);
key                56 source4/lib/registry/pyregistry.c 	return py_talloc_import(&PyRegistryKey, key);
key                79 source4/lib/registry/pyregistry.c 	struct registry_key *key;
key                84 source4/lib/registry/pyregistry.c 	result = reg_get_predefined_key(ctx, hkey, &key);
key                87 source4/lib/registry/pyregistry.c 	return py_talloc_import(&PyRegistryKey, key);
key               173 source4/lib/registry/pyregistry.c 	struct hive_key *key = PyHiveKey_AsHiveKey(self);
key               179 source4/lib/registry/pyregistry.c 	result = hive_key_del(key, name);
key               189 source4/lib/registry/pyregistry.c 	struct hive_key *key = PyHiveKey_AsHiveKey(self);
key               191 source4/lib/registry/pyregistry.c 	result = hive_key_flush(key);
key               201 source4/lib/registry/pyregistry.c 	struct hive_key *key = PyHiveKey_AsHiveKey(self);
key               206 source4/lib/registry/pyregistry.c 	result = hive_key_del_value(key, name);
key               219 source4/lib/registry/pyregistry.c 	struct hive_key *key = PyHiveKey_AsHiveKey(self);
key               225 source4/lib/registry/pyregistry.c 		result = hive_key_set_value(key, name, type, value);
key               227 source4/lib/registry/pyregistry.c 		result = hive_key_del_value(key, name);
key               309 source4/lib/registry/pyregistry.c 	struct hive_key *key;
key               314 source4/lib/registry/pyregistry.c 	result = reg_open_directory(NULL, location, &key);
key               317 source4/lib/registry/pyregistry.c 	return py_talloc_import(&PyHiveKey, key);
key               324 source4/lib/registry/pyregistry.c 	struct hive_key *key;
key               329 source4/lib/registry/pyregistry.c 	result = reg_create_directory(NULL, location, &key);
key               332 source4/lib/registry/pyregistry.c 	return py_talloc_import(&PyHiveKey, key);
key               343 source4/lib/registry/pyregistry.c 	struct hive_key *key;
key               368 source4/lib/registry/pyregistry.c 							   tevent_context_init(NULL), lp_ctx, &key);
key               371 source4/lib/registry/pyregistry.c 	return py_talloc_import(&PyHiveKey, key);
key                58 source4/lib/registry/regf.c 	struct hive_key key;
key               428 source4/lib/registry/regf.c 			    const struct hive_key *key,
key               438 source4/lib/registry/regf.c 		(const struct regf_key_data *)key;
key               476 source4/lib/registry/regf.c 	ret->key.ops = &reg_backend_regf;
key               501 source4/lib/registry/regf.c static WERROR regf_get_value(TALLOC_CTX *ctx, struct hive_key *key,
key               506 source4/lib/registry/regf.c 			(const struct regf_key_data *)key;
key               562 source4/lib/registry/regf.c 				     struct hive_key *key, const char *name,
key               571 source4/lib/registry/regf.c 	for (i = 0; W_ERROR_IS_OK(error = regf_get_value(mem_ctx, key, i,
key               586 source4/lib/registry/regf.c 				       const struct hive_key *key,
key               593 source4/lib/registry/regf.c 	const struct regf_key_data *private_data = (const struct regf_key_data *)key;
key               787 source4/lib/registry/regf.c 					const struct hive_key *key,
key               795 source4/lib/registry/regf.c 		(const struct regf_key_data *)key;
key               828 source4/lib/registry/regf.c 				      const struct hive_key *key,
key               834 source4/lib/registry/regf.c 		(const struct regf_key_data *)key;
key               866 source4/lib/registry/regf.c 			W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
key               901 source4/lib/registry/regf.c 									key,
key               938 source4/lib/registry/regf.c 									key,
key               988 source4/lib/registry/regf.c 					W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
key              1013 source4/lib/registry/regf.c 					W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
key              1037 source4/lib/registry/regf.c static WERROR regf_set_sec_desc(struct hive_key *key,
key              1041 source4/lib/registry/regf.c 		(const struct regf_key_data *)key;
key              1182 source4/lib/registry/regf.c static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, const struct hive_key *key,
key              1186 source4/lib/registry/regf.c 		(const struct regf_key_data *)key;
key              1540 source4/lib/registry/regf.c static WERROR regf_del_value (struct hive_key *key, const char *name)
key              1542 source4/lib/registry/regf.c 	struct regf_key_data *private_data = (struct regf_key_data *)key;
key              1602 source4/lib/registry/regf.c 	struct regf_key_data *key;
key              1617 source4/lib/registry/regf.c 						   (struct hive_key **)&key))) {
key              1622 source4/lib/registry/regf.c 	if (key->nk->subkeys_offset != -1) {
key              1624 source4/lib/registry/regf.c 		struct hive_key *sk = (struct hive_key *)key;
key              1625 source4/lib/registry/regf.c 		int i = key->nk->num_subkeys;
key              1647 source4/lib/registry/regf.c 	if (key->nk->values_offset != -1) {
key              1649 source4/lib/registry/regf.c 		struct hive_key *sk = (struct hive_key *)key;
key              1651 source4/lib/registry/regf.c 		int i = key->nk->num_values;
key              1675 source4/lib/registry/regf.c 				  key->offset, &parent_nk->subkeys_offset);
key              1687 source4/lib/registry/regf.c 	if (key->nk->clsname_offset != -1) {
key              1688 source4/lib/registry/regf.c 		hbin_free(private_data->hive, key->nk->clsname_offset);
key              1690 source4/lib/registry/regf.c 	hbin_free(private_data->hive, key->offset);
key              1757 source4/lib/registry/regf.c static WERROR regf_set_value(struct hive_key *key, const char *name,
key              1760 source4/lib/registry/regf.c 	struct regf_key_data *private_data = (struct regf_key_data *)key;
key              1915 source4/lib/registry/regf.c 			    int minor_version, struct hive_key **key)
key              2026 source4/lib/registry/regf.c 	*key = (struct hive_key *)regf_get_key(parent_ctx, regf,
key              2041 source4/lib/registry/regf.c 			  struct smb_iconv_convenience *iconv_convenience, struct hive_key **key)
key              2142 source4/lib/registry/regf.c 	*key = (struct hive_key *)regf_get_key(parent_ctx, regf,
key                57 source4/lib/registry/registry.h 			    const struct hive_key *key, uint32_t idx,
key                66 source4/lib/registry/registry.h 				   const struct hive_key *key, const char *name,
key                76 source4/lib/registry/registry.h 			   struct hive_key **key);
key                80 source4/lib/registry/registry.h 	WERROR (*del_key) (const struct hive_key *key, const char *name);
key                85 source4/lib/registry/registry.h 	WERROR (*flush_key) (struct hive_key *key);
key                91 source4/lib/registry/registry.h 			      struct hive_key *key, int idx,
key                99 source4/lib/registry/registry.h 				     struct hive_key *key, const char *name,
key               105 source4/lib/registry/registry.h 	WERROR (*set_value) (struct hive_key *key, const char *name,
key               111 source4/lib/registry/registry.h 	WERROR (*delete_value) (struct hive_key *key, const char *name);
key               122 source4/lib/registry/registry.h 	WERROR (*set_sec_desc) (struct hive_key *key,
key               133 source4/lib/registry/registry.h 				const struct hive_key *key,
key               140 source4/lib/registry/registry.h 				const struct hive_key *key,
key               160 source4/lib/registry/registry.h WERROR hive_key_get_info(TALLOC_CTX *mem_ctx, const struct hive_key *key,
key               168 source4/lib/registry/registry.h 			 struct hive_key **key);
key               169 source4/lib/registry/registry.h WERROR hive_key_del(const struct hive_key *key, const char *name);
key               171 source4/lib/registry/registry.h 			    const struct hive_key *key, const char *name,
key               174 source4/lib/registry/registry.h 		     const struct hive_key *key, uint32_t idx,
key               179 source4/lib/registry/registry.h WERROR hive_key_set_value(struct hive_key *key, const char *name,
key               183 source4/lib/registry/registry.h 		      struct hive_key *key, const char *name,
key               186 source4/lib/registry/registry.h 			       struct hive_key *key, uint32_t idx,
key               190 source4/lib/registry/registry.h 			 struct hive_key *key,
key               193 source4/lib/registry/registry.h WERROR hive_set_sec_desc(struct hive_key *key, 
key               196 source4/lib/registry/registry.h WERROR hive_key_del_value(struct hive_key *key, const char *name);
key               198 source4/lib/registry/registry.h WERROR hive_key_flush(struct hive_key *key);
key               203 source4/lib/registry/registry.h 			  const char *location, struct hive_key **key);
key               206 source4/lib/registry/registry.h 			  struct hive_key **key);
key               216 source4/lib/registry/registry.h 			    const char *location, struct hive_key **key);
key               221 source4/lib/registry/registry.h 			    struct hive_key **key);
key               280 source4/lib/registry/registry.h 				const struct registry_key *key,
key               289 source4/lib/registry/registry.h 	WERROR (*flush_key) (struct registry_key *key);
key               293 source4/lib/registry/registry.h 				      struct registry_key **key);
key               298 source4/lib/registry/registry.h 			    struct registry_key **key);
key               305 source4/lib/registry/registry.h 			      struct registry_key **key);
key               307 source4/lib/registry/registry.h 	WERROR (*delete_key) (struct registry_key *key, const char *name);
key               309 source4/lib/registry/registry.h 	WERROR (*delete_value) (struct registry_key *key, const char *name);
key               312 source4/lib/registry/registry.h 			    const struct registry_key *key, uint32_t idx,
key               318 source4/lib/registry/registry.h 			      const struct registry_key *key, uint32_t idx,
key               324 source4/lib/registry/registry.h 				const struct registry_key *key,
key               327 source4/lib/registry/registry.h 	WERROR (*set_sec_desc) (struct registry_key *key,
key               330 source4/lib/registry/registry.h 	WERROR (*load_key) (struct registry_key *key,
key               334 source4/lib/registry/registry.h 	WERROR (*unload_key) (struct registry_key *key, const char *name);
key               336 source4/lib/registry/registry.h 	WERROR (*notify_value_change) (struct registry_key *key,
key               340 source4/lib/registry/registry.h 			     const struct registry_key *key,
key               345 source4/lib/registry/registry.h 	WERROR (*set_value) (struct registry_key *key,
key               390 source4/lib/registry/registry.h 				      struct registry_key **key);
key               393 source4/lib/registry/registry.h 			      struct registry_key **key);
key               399 source4/lib/registry/registry.h 				  const struct registry_key *key, uint32_t idx,
key               404 source4/lib/registry/registry.h 			const struct registry_key *key,
key               413 source4/lib/registry/registry.h 				   const struct registry_key *key,
key               419 source4/lib/registry/registry.h 				  const struct registry_key *key,
key               423 source4/lib/registry/registry.h 				 const struct registry_key *key,
key               433 source4/lib/registry/registry.h WERROR reg_val_set(struct registry_key *key, const char *value,
key               435 source4/lib/registry/registry.h WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
key               437 source4/lib/registry/registry.h WERROR reg_del_value(struct registry_key *key, const char *valname);
key               438 source4/lib/registry/registry.h WERROR reg_key_flush(struct registry_key *key);
key               444 source4/lib/registry/registry.h 		      struct registry_key **key);
key               460 source4/lib/registry/registry.h WERROR reg_load_key(struct registry_context *ctx, struct registry_key *key,
key               472 source4/lib/registry/registry.h WERROR reg_set_sec_desc(struct registry_key *key,
key               523 source4/lib/registry/registry.h 				uint32_t key_id, struct registry_key **key);
key                28 source4/lib/registry/rpc.c 	struct registry_key key;
key               120 source4/lib/registry/rpc.c 	mykeydata->key.context = ctx;
key               155 source4/lib/registry/rpc.c 			   const char *name, struct registry_key **key)
key               163 source4/lib/registry/rpc.c 	mykeydata->key.context = parentkeydata->key.context;
key               167 source4/lib/registry/rpc.c 	*key = (struct registry_key *)mykeydata;
key               335 source4/lib/registry/rpc.c 			  struct registry_key **key)
key               363 source4/lib/registry/rpc.c 	*key = (struct registry_key *)rpck;
key               411 source4/lib/registry/rpc.c 	r.in.key.name = name;
key               425 source4/lib/registry/rpc.c static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key,
key               434 source4/lib/registry/rpc.c 	struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key);
key               438 source4/lib/registry/rpc.c 		error = rpc_query_key(mem_ctx, key);
key                71 source4/lib/registry/tests/diff.c 	struct registry_key *key;
key                77 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->get_predefined_key(td->r1_ctx, HKEY_LOCAL_MACHINE, &key);
key                82 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "Software", &key);
key                84 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "Microsoft", &key);
key                86 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "Windows", &key);
key                88 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "CurrentVersion", &key);
key                90 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "Policies", &key);
key                92 source4/lib/registry/tests/diff.c 	error = td->r1_ctx->ops->open_key(td->r1_ctx, key, "Explorer", &key);
key               162 source4/lib/registry/tests/diff.c 	struct registry_key *key, *newkey;
key               208 source4/lib/registry/tests/diff.c 	error = r1_ctx->ops->get_predefined_key(r1_ctx, HKEY_CURRENT_USER, &key);
key               210 source4/lib/registry/tests/diff.c 	error = r1_ctx->ops->create_key(r1_ctx, key, "Network", NULL, NULL, &newkey);
key               215 source4/lib/registry/tests/diff.c 	error = r2_ctx->ops->get_predefined_key(r2_ctx, HKEY_LOCAL_MACHINE, &key);
key               217 source4/lib/registry/tests/diff.c 	error = r2_ctx->ops->create_key(r2_ctx, key, "Software", NULL, NULL, &newkey);
key               393 source4/lib/registry/tests/hive.c 	struct hive_key *key;
key               404 source4/lib/registry/tests/hive.c 	error = reg_create_directory(tctx, dirname, &key);
key               410 source4/lib/registry/tests/hive.c 	*data = key;
key               417 source4/lib/registry/tests/hive.c 	struct hive_key *key;
key               428 source4/lib/registry/tests/hive.c 	error = reg_open_ldb_file(tctx, dirname, NULL, NULL, tctx->ev, tctx->lp_ctx, &key);
key               434 source4/lib/registry/tests/hive.c 	*data = key;
key               441 source4/lib/registry/tests/hive.c 	struct hive_key *key;
key               453 source4/lib/registry/tests/hive.c 				     dirname, 5, &key);
key               459 source4/lib/registry/tests/hive.c 	*data = key;
key                24 source4/lib/registry/wine.c static WERROR wine_open_reg (struct registry_hive *h, struct registry_key **key)
key                45 source4/lib/tls/tlscert.c 	gnutls_x509_privkey key, cakey;
key                78 source4/lib/tls/tlscert.c 	TLSCHECK(gnutls_x509_privkey_init(&key));
key                79 source4/lib/tls/tlscert.c 	TLSCHECK(gnutls_x509_privkey_generate(key,   GNUTLS_PK_RSA, DH_BITS, 0));
key               122 source4/lib/tls/tlscert.c 	TLSCHECK(gnutls_x509_crt_set_key(crt, key));
key               135 source4/lib/tls/tlscert.c 	TLSCHECK(gnutls_x509_crt_sign(crt, crt, key));
key               148 source4/lib/tls/tlscert.c 	TLSCHECK(gnutls_x509_privkey_export(key, GNUTLS_X509_FMT_PEM, buf, &bufsize));
key               151 source4/lib/tls/tlscert.c 	gnutls_x509_privkey_deinit(key);
key              2134 source4/lib/wmi/wmi_wrap.c       PyObject *key = SWIG_This();
key              2135 source4/lib/wmi/wmi_wrap.c       PyObject_SetAttr(inst, key, swig_this);
key              2343 source4/lib/wmi/wmi_wrap.c   PyObject *key = PyString_FromString(type); 
key              2344 source4/lib/wmi/wmi_wrap.c   PyObject *obj = PyDict_GetItem(cache, key);
key              2353 source4/lib/wmi/wmi_wrap.c       PyDict_SetItem(cache, key, obj);
key              2357 source4/lib/wmi/wmi_wrap.c   Py_DECREF(key);
key               134 source4/libcli/auth/credentials.c void creds_des_encrypt_LMKey(struct creds_CredentialState *creds, struct netr_LMSessionKey *key)
key               137 source4/libcli/auth/credentials.c 	des_crypt56(tmp.key, key->key, creds->session_key, 1);
key               138 source4/libcli/auth/credentials.c 	*key = tmp;
key               144 source4/libcli/auth/credentials.c void creds_des_decrypt_LMKey(struct creds_CredentialState *creds, struct netr_LMSessionKey *key)
key               147 source4/libcli/auth/credentials.c 	des_crypt56(tmp.key, key->key, creds->session_key, 0);
key               148 source4/libcli/auth/credentials.c 	*key = tmp;
key               355 source4/libcli/auth/credentials.c 		if (memcmp(base->key.key, zeros,  
key               356 source4/libcli/auth/credentials.c 			   sizeof(base->key.key)) != 0) {
key               358 source4/libcli/auth/credentials.c 					    base->key.key, 
key               359 source4/libcli/auth/credentials.c 					    sizeof(base->key.key));
key               362 source4/libcli/auth/credentials.c 		if (memcmp(base->LMSessKey.key, zeros,  
key               363 source4/libcli/auth/credentials.c 			   sizeof(base->LMSessKey.key)) != 0) {
key               365 source4/libcli/auth/credentials.c 					    base->LMSessKey.key, 
key               366 source4/libcli/auth/credentials.c 					    sizeof(base->LMSessKey.key));
key               369 source4/libcli/auth/credentials.c 		if (memcmp(base->LMSessKey.key, zeros,  
key               370 source4/libcli/auth/credentials.c 			   sizeof(base->LMSessKey.key)) != 0) {
key                40 source4/libcli/auth/session.c 		uint8_t bin[8], bout[8], key[7];
key                48 source4/libcli/auth/session.c 		memcpy(key, &session_key->data[k], 7);
key                50 source4/libcli/auth/session.c 		des_crypt56(bout, bin, key, forward?1:0);
key               180 source4/libcli/auth/smbdes.c static void dohash(char *out, char *in, char *key, int forw)
key               192 source4/libcli/auth/smbdes.c 	permute(pk1, key, perm1, 56);
key               259 source4/libcli/auth/smbdes.c static void str_to_key(const uint8_t *str,uint8_t *key)
key               263 source4/libcli/auth/smbdes.c 	key[0] = str[0]>>1;
key               264 source4/libcli/auth/smbdes.c 	key[1] = ((str[0]&0x01)<<6) | (str[1]>>2);
key               265 source4/libcli/auth/smbdes.c 	key[2] = ((str[1]&0x03)<<5) | (str[2]>>3);
key               266 source4/libcli/auth/smbdes.c 	key[3] = ((str[2]&0x07)<<4) | (str[3]>>4);
key               267 source4/libcli/auth/smbdes.c 	key[4] = ((str[3]&0x0F)<<3) | (str[4]>>5);
key               268 source4/libcli/auth/smbdes.c 	key[5] = ((str[4]&0x1F)<<2) | (str[5]>>6);
key               269 source4/libcli/auth/smbdes.c 	key[6] = ((str[5]&0x3F)<<1) | (str[6]>>7);
key               270 source4/libcli/auth/smbdes.c 	key[7] = str[6]&0x7F;
key               272 source4/libcli/auth/smbdes.c 		key[i] = (key[i]<<1);
key               279 source4/libcli/auth/smbdes.c void des_crypt56(uint8_t out[8], const uint8_t in[8], const uint8_t key[7], int forw)
key               287 source4/libcli/auth/smbdes.c 	str_to_key(key, key2);
key               334 source4/libcli/auth/smbdes.c void des_crypt128(uint8_t out[8], const uint8_t in[8], const uint8_t key[16])
key               337 source4/libcli/auth/smbdes.c 	des_crypt56(buf, in, key, 1);
key               338 source4/libcli/auth/smbdes.c 	des_crypt56(out, buf, key+9, 1);
key               342 source4/libcli/auth/smbdes.c void des_crypt64(uint8_t out[8], const uint8_t in[8], const uint8_t key[8], int forw)
key               347 source4/libcli/auth/smbdes.c 	des_crypt56(buf, in, key, forw);
key               348 source4/libcli/auth/smbdes.c 	key2[0] = key[7];
key               353 source4/libcli/auth/smbdes.c void des_crypt112(uint8_t out[8], const uint8_t in[8], const uint8_t key[14], int forw)
key               356 source4/libcli/auth/smbdes.c 	des_crypt56(buf, in, key, forw);
key               357 source4/libcli/auth/smbdes.c 	des_crypt56(out, buf, key+7, forw);
key               361 source4/libcli/auth/smbdes.c void des_crypt112_16(uint8_t out[16], uint8_t in[16], const uint8_t key[14], int forw)
key               363 source4/libcli/auth/smbdes.c         des_crypt56(out, in, key, forw);
key               364 source4/libcli/auth/smbdes.c         des_crypt56(out + 8, in + 8, key+7, forw);
key                78 source4/ntvfs/common/brlock_tdb.c 	DATA_BLOB key;
key               121 source4/ntvfs/common/brlock_tdb.c 	brlh->key = *file_key;
key               299 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
key               300 source4/ntvfs/common/brlock_tdb.c 	kbuf.dsize = brlh->key.length;
key               449 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
key               450 source4/ntvfs/common/brlock_tdb.c 	kbuf.dsize = brlh->key.length;
key               549 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
key               550 source4/ntvfs/common/brlock_tdb.c 	kbuf.dsize = brlh->key.length;
key               620 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
key               621 source4/ntvfs/common/brlock_tdb.c 	kbuf.dsize = brlh->key.length;
key               663 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
key               664 source4/ntvfs/common/brlock_tdb.c 	kbuf.dsize = brlh->key.length;
key               172 source4/ntvfs/common/opendb.c NTSTATUS odb_get_file_infos(struct odb_context *odb, DATA_BLOB *key,
key               175 source4/ntvfs/common/opendb.c 	return ops->odb_get_file_infos(odb, key, del_on_close, write_time);
key                42 source4/ntvfs/common/opendb.h 	NTSTATUS (*odb_get_file_infos)(struct odb_context *odb, DATA_BLOB *key,
key                67 source4/ntvfs/common/opendb_tdb.c 	TDB_DATA key;
key               119 source4/ntvfs/common/opendb_tdb.c 	tdb_chainunlock(lck->odb->w->tdb, lck->key);
key               141 source4/ntvfs/common/opendb_tdb.c 	lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
key               142 source4/ntvfs/common/opendb_tdb.c 	lck->key.dsize = file_key->length;
key               143 source4/ntvfs/common/opendb_tdb.c 	if (lck->key.dptr == NULL) {
key               148 source4/ntvfs/common/opendb_tdb.c 	if (tdb_chainlock(odb->w->tdb, lck->key) != 0) {
key               171 source4/ntvfs/common/opendb_tdb.c 	return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
key               241 source4/ntvfs/common/opendb_tdb.c 	dbuf = tdb_fetch(odb->w->tdb, lck->key);
key               270 source4/ntvfs/common/opendb_tdb.c 		ret = tdb_delete(odb->w->tdb, lck->key);
key               285 source4/ntvfs/common/opendb_tdb.c 	ret = tdb_store(odb->w->tdb, lck->key, dbuf, TDB_REPLACE);
key               815 source4/ntvfs/common/opendb_tdb.c static NTSTATUS odb_tdb_get_file_infos(struct odb_context *odb, DATA_BLOB *key,
key               827 source4/ntvfs/common/opendb_tdb.c 	lck = odb_lock(odb, odb, key);
key                76 source4/ntvfs/ipc/vfs_ipc.c static struct pipe_state *pipe_state_find_key(struct ipc_private *ipriv, struct ntvfs_request *req, const DATA_BLOB *key)
key                80 source4/ntvfs/ipc/vfs_ipc.c 	h = ntvfs_handle_search_by_wire_key(ipriv->ntvfs, req, key);
key                58 source4/ntvfs/nbench/vfs_nbench.c 	DATA_BLOB key;
key                61 source4/ntvfs/nbench/vfs_nbench.c 	key = ntvfs_handle_get_wire_key(h, req);
key                63 source4/ntvfs/nbench/vfs_nbench.c 	switch (key.length) {
key                65 source4/ntvfs/nbench/vfs_nbench.c 		fnum = SVAL(key.data, 0);
key                69 source4/ntvfs/nbench/vfs_nbench.c 			__FUNCTION__, (unsigned)key.length));
key               222 source4/ntvfs/ntvfs.h 		struct ntvfs_handle *(*search_by_wire_key)(void *private_data,  struct ntvfs_request *req, const DATA_BLOB *key);
key               174 source4/ntvfs/ntvfs_util.c 							      const DATA_BLOB *key)
key               179 source4/ntvfs/ntvfs_util.c 	return ntvfs->ctx->handles.search_by_wire_key(ntvfs->ctx->handles.private_data, req, key);
key               191 source4/ntvfs/ntvfs_util.c 					     struct ntvfs_handle *(*search_by_wire_key)(void *private_data, struct ntvfs_request *req, const DATA_BLOB *key),
key               150 source4/ntvfs/posix/pvfs_open.c 			  TALLOC_CTX *mem_ctx, DATA_BLOB *key)
key               161 source4/ntvfs/posix/pvfs_open.c 	*key = data_blob_talloc(mem_ctx, &lock_context, sizeof(lock_context));
key               162 source4/ntvfs/posix/pvfs_open.c 	if (key->data == NULL) {
key               571 source4/ntvfs/posix/pvfs_open.c 	DATA_BLOB odb_key, key;
key               579 source4/ntvfs/posix/pvfs_open.c 		key = odb_key;
key               581 source4/ntvfs/posix/pvfs_open.c 		key = data_blob_talloc(mem_ctx, NULL, 
key               583 source4/ntvfs/posix/pvfs_open.c 		NT_STATUS_HAVE_NO_MEMORY(key.data);
key               584 source4/ntvfs/posix/pvfs_open.c 		memcpy(key.data, odb_key.data, odb_key.length);
key               585 source4/ntvfs/posix/pvfs_open.c 		memcpy(key.data + odb_key.length, 
key               590 source4/ntvfs/posix/pvfs_open.c 	h = brl_create_handle(mem_ctx, ntvfs, &key);
key              1778 source4/ntvfs/posix/pvfs_open.c 	DATA_BLOB key;
key              1784 source4/ntvfs/posix/pvfs_open.c 	status = pvfs_locking_key(name, name, &key);
key              1789 source4/ntvfs/posix/pvfs_open.c 	lck = odb_lock(req, pvfs->odb_context, &key);
key              1843 source4/ntvfs/posix/pvfs_open.c 	DATA_BLOB key;
key              1849 source4/ntvfs/posix/pvfs_open.c 	status = pvfs_locking_key(name, name, &key);
key              1854 source4/ntvfs/posix/pvfs_open.c 	lck = odb_lock(req, pvfs->odb_context, &key);
key              1903 source4/ntvfs/posix/pvfs_open.c 	DATA_BLOB key;
key              1910 source4/ntvfs/posix/pvfs_open.c 	status = pvfs_locking_key(name, name, &key);
key              1915 source4/ntvfs/posix/pvfs_open.c 	lck = odb_lock(req, pvfs->odb_context, &key);
key              1974 source4/ntvfs/posix/pvfs_open.c 	DATA_BLOB key;
key              1980 source4/ntvfs/posix/pvfs_open.c 	status = pvfs_locking_key(name, name, &key);
key              1985 source4/ntvfs/posix/pvfs_open.c 	lck = odb_lock(req, pvfs->odb_context, &key);
key               119 source4/ntvfs/posix/pvfs_shortname.c 			    const char *key, size_t length)
key               121 source4/ntvfs/posix/pvfs_shortname.c 	return pvfs_name_hash(key, length) % ctx->mangle_modulus;
key               176 source4/ntvfs/posix/pvfs_util.c uint32_t pvfs_name_hash(const char *key, size_t length)
key               182 source4/ntvfs/posix/pvfs_util.c 	while (*key && length--) {
key               184 source4/ntvfs/posix/pvfs_util.c 		codepoint_t c = next_codepoint(key, &c_size);
key               188 source4/ntvfs/posix/pvfs_util.c 		key += c_size;
key                83 source4/ntvfs/posix/xattr_tdb.c 			      TDB_DATA *key)
key                98 source4/ntvfs/posix/xattr_tdb.c 	key->dptr = talloc_array(mem_ctx, uint8_t, 16 + len);
key                99 source4/ntvfs/posix/xattr_tdb.c 	if (key->dptr == NULL) {
key               102 source4/ntvfs/posix/xattr_tdb.c 	key->dsize = 16 + len;
key               104 source4/ntvfs/posix/xattr_tdb.c 	SBVAL(key->dptr, 0, st.st_dev);
key               105 source4/ntvfs/posix/xattr_tdb.c 	SBVAL(key->dptr, 8, st.st_ino);
key               106 source4/ntvfs/posix/xattr_tdb.c 	memcpy(key->dptr+16, attr_name, len);
key                46 source4/param/generic.c 		if (strcasecmp_m(p->key, name) == 0) 
key                95 source4/param/generic.c 		p->key = talloc_strdup(p, name);
key               214 source4/param/generic.c 		p->key = talloc_strdup(p, name);
key               254 source4/param/generic.c 				lp_do_global_parameter(lp_ctx, param->key,
key               261 source4/param/generic.c 				lp_do_service_parameter(lp_ctx, service, param->key, param->value);
key               286 source4/param/generic.c 			fdprintf(file, "\t%s = %s\n", param->key, param->value);
key               763 source4/param/loadparm.c 		if (strcmp(data->key, vfskey) == 0) {
key               775 source4/param/loadparm.c 			if (strcmp(data->key, vfskey) == 0) {
key              1321 source4/param/loadparm.c 			if (strcmp(pdata->key, data->key) == 0) {
key              1334 source4/param/loadparm.c 			paramo->key = talloc_reference(paramo, data->key);
key              1572 source4/param/loadparm.c 		if (strcmp(paramo->key, name) == 0) {
key              1589 source4/param/loadparm.c 	paramo->key = talloc_strdup(paramo, name);
key              2068 source4/param/loadparm.c 			fprintf(f, "\t%s = %s\n", data->key, data->value);
key              2110 source4/param/loadparm.c 			fprintf(f, "\t%s = %s\n", data->key, data->value);
key                25 source4/param/param.h 	char *key;
key               631 source4/rpc_server/netlogon/dcerpc_netlogon.c 	    memcmp(sam->key.key, zeros, sizeof(sam->key.key)) != 0) {
key               635 source4/rpc_server/netlogon/dcerpc_netlogon.c 					    sam->key.key, 
key               636 source4/rpc_server/netlogon/dcerpc_netlogon.c 					    sizeof(sam->key.key));
key               643 source4/rpc_server/netlogon/dcerpc_netlogon.c 	    memcmp(sam->LMSessKey.key, zeros, sizeof(sam->LMSessKey.key)) != 0) {
key               646 source4/rpc_server/netlogon/dcerpc_netlogon.c 					    sam->LMSessKey.key, 
key               647 source4/rpc_server/netlogon/dcerpc_netlogon.c 					    sizeof(sam->LMSessKey.key));
key               118 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               122 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               146 source4/rpc_server/winreg/rpc_winreg.c 		result = reg_key_add_name(newh, key, r->in.name.name, NULL,
key               169 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               172 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               178 source4/rpc_server/winreg/rpc_winreg.c 		return reg_key_del(key, r->in.key.name);
key               193 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               196 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               202 source4/rpc_server/winreg/rpc_winreg.c 		return reg_del_value(key, r->in.value.name);
key               217 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               223 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               226 source4/rpc_server/winreg/rpc_winreg.c 		key, r->in.enum_index, &name, &classname, &last_mod);
key               266 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               273 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               275 source4/rpc_server/winreg/rpc_winreg.c 	result = reg_key_get_value_by_index(mem_ctx, key,
key               336 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               339 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               345 source4/rpc_server/winreg/rpc_winreg.c 		return reg_key_flush(key);
key               397 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               401 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               413 source4/rpc_server/winreg/rpc_winreg.c 			result = reg_open_key(newh, key, r->in.keyname.name,
key               438 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               443 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               450 source4/rpc_server/winreg/rpc_winreg.c 		result = reg_key_get_info(mem_ctx, key, &classname,
key               479 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               485 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               492 source4/rpc_server/winreg/rpc_winreg.c 		result = reg_key_get_value_by_name(mem_ctx, key, 
key               578 source4/rpc_server/winreg/rpc_winreg.c 	struct registry_key *key;
key               583 source4/rpc_server/winreg/rpc_winreg.c 	key = h->data;
key               591 source4/rpc_server/winreg/rpc_winreg.c 		result = reg_val_set(key, r->in.name.name, r->in.type, data);
key               761 source4/smb_server/smb/request.c struct ntvfs_handle *smbsrv_handle_search_by_wire_key(void *private_data, struct ntvfs_request *ntvfs, const DATA_BLOB *key)
key               766 source4/smb_server/smb/request.c 	if (key->length != 2) return NULL;
key               768 source4/smb_server/smb/request.c 	return smbsrv_pull_fnum(req, key->data, 0);
key               773 source4/smb_server/smb/request.c 	uint8_t key[2];
key               775 source4/smb_server/smb/request.c 	smbsrv_push_fnum(key, 0, handle);
key               777 source4/smb_server/smb/request.c 	return data_blob_talloc(mem_ctx, key, sizeof(key));
key               230 source4/smb_server/smb2/tcon.c static struct ntvfs_handle *smb2srv_handle_search_by_wire_key(void *private_data, struct ntvfs_request *ntvfs, const DATA_BLOB *key)
key                37 source4/torture/local/dbspeed.c 	TDB_DATA key, data;
key                39 source4/torture/local/dbspeed.c 	key.dptr = (uint8_t *)talloc_asprintf(tdbw, fmt1, i);
key                40 source4/torture/local/dbspeed.c 	key.dsize = strlen((char *)key.dptr)+1;
key                44 source4/torture/local/dbspeed.c 	ret = tdb_store(tdbw->tdb, key, data, TDB_INSERT);
key                46 source4/torture/local/dbspeed.c 	talloc_free(key.dptr);
key                96 source4/torture/local/dbspeed.c 		TDB_DATA key, data;
key                98 source4/torture/local/dbspeed.c 		key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "S-1-5-21-53173311-3623041448-2049097239-%u", i);
key                99 source4/torture/local/dbspeed.c 		key.dsize = strlen((char *)key.dptr)+1;
key               100 source4/torture/local/dbspeed.c 		data = tdb_fetch(tdbw->tdb, key);
key               101 source4/torture/local/dbspeed.c 		talloc_free(key.dptr);
key               107 source4/torture/local/dbspeed.c 		key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "UID %u", i);
key               108 source4/torture/local/dbspeed.c 		key.dsize = strlen((char *)key.dptr)+1;
key               109 source4/torture/local/dbspeed.c 		data = tdb_fetch(tdbw->tdb, key);
key               110 source4/torture/local/dbspeed.c 		talloc_free(key.dptr);
key               357 source4/torture/ndr/winreg.c 	torture_assert_str_equal(tctx, r->in.key.name, "spottyfoot", "key name");
key              3410 source4/torture/rpc/samba3rpc.c 	d.in.key.name = talloc_asprintf(
key              3412 source4/torture/rpc/samba3rpc.c 	if (d.in.key.name == NULL) {
key               256 source4/torture/rpc/samlogon.c 		memcpy(user_session_key, base->key.key, 16);
key               259 source4/torture/rpc/samlogon.c 		memcpy(lm_key, base->LMSessKey.key, 8);
key               382 source4/torture/rpc/spoolss_win.c 				const char* key,
key               390 source4/torture/rpc/spoolss_win.c 	torture_comment(tctx, "Testing EnumPrinterKey(%s)\n", key);
key               393 source4/torture/rpc/spoolss_win.c 	epk.in.key_name = talloc_strdup(tctx, key);
key               419 source4/torture/rpc/spoolss_win.c 					const char *key,
key               429 source4/torture/rpc/spoolss_win.c 	torture_comment(tctx, "Testing EnumPrinterDataEx(%s)\n", key);
key               432 source4/torture/rpc/spoolss_win.c 	epde.in.key_name = talloc_strdup(tctx, key);
key               389 source4/torture/rpc/winreg.c 			 struct policy_handle *handle, const char *key)
key               396 source4/torture/rpc/winreg.c 	init_winreg_String(&r.in.key, key);
key               424 source4/torture/rpc/winreg.c 				    const char *key)
key               431 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               451 source4/torture/rpc/winreg.c 				     const char *key,
key               460 source4/torture/rpc/winreg.c 	if (!_test_OpenKey(p, tctx, handle, key, access_mask, &new_handle,
key               509 source4/torture/rpc/winreg.c 				       const char *key,
key               515 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               555 source4/torture/rpc/winreg.c 				       const char *key,
key               561 source4/torture/rpc/winreg.c 	if (!_test_OpenKey(p, tctx, handle, key, SEC_FLAG_SYSTEM_SECURITY,
key               595 source4/torture/rpc/winreg.c 				const char *key,
key               601 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               634 source4/torture/rpc/winreg.c 				const char *key,
key               640 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               706 source4/torture/rpc/winreg.c 				 const char *key,
key               712 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               730 source4/torture/rpc/winreg.c 				const char *key,
key               736 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               754 source4/torture/rpc/winreg.c 					       const char *key)
key               781 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               859 source4/torture/rpc/winreg.c 	test_RestoreSecurity(p, tctx, handle, key, sd_orig);
key               867 source4/torture/rpc/winreg.c 						    const char *key)
key               893 source4/torture/rpc/winreg.c 	if (!test_OpenKey(p, tctx, handle, key, &new_handle)) {
key               981 source4/torture/rpc/winreg.c 	test_RestoreSecurity(p, tctx, handle, key, sd_orig);
key               989 source4/torture/rpc/winreg.c 					  const char *key)
key              1029 source4/torture/rpc/winreg.c 					     sd_mask_tests[i].access_mask, key,
key              1049 source4/torture/rpc/winreg.c 					       const char *key,
key              1070 source4/torture/rpc/winreg.c 	if (!_test_OpenKey(p, tctx, handle, key,
key              1099 source4/torture/rpc/winreg.c 		present = fn(p, tctx, handle, key, sid);
key              1120 source4/torture/rpc/winreg.c 					    const char *key)
key              1236 source4/torture/rpc/winreg.c 	if (!test_BackupSecurity(p, tctx, handle, key, &sd_orig)) {
key              1247 source4/torture/rpc/winreg.c 					key,
key              1271 source4/torture/rpc/winreg.c 					key,
key              1295 source4/torture/rpc/winreg.c 					key,
key              1319 source4/torture/rpc/winreg.c 					key,
key              1337 source4/torture/rpc/winreg.c 	test_RestoreSecurity(p, tctx, handle, key, sd_orig);
key              1345 source4/torture/rpc/winreg.c 				     const char *key)
key              1349 source4/torture/rpc/winreg.c 	if (!test_SecurityDescriptor(p, tctx, handle, key)) {
key              1354 source4/torture/rpc/winreg.c 	if (!test_SecurityDescriptorInheritance(p, tctx, handle, key)) {
key              1359 source4/torture/rpc/winreg.c 	if (!test_SecurityDescriptorBlockInheritance(p, tctx, handle, key)) {
key              1364 source4/torture/rpc/winreg.c 	if (!test_SecurityDescriptorsSecInfo(p, tctx, handle, key)) {
key              1369 source4/torture/rpc/winreg.c 	if (!test_SecurityDescriptorsMasks(p, tctx, handle, key)) {
key              1378 source4/torture/rpc/winreg.c 			   struct policy_handle *handle, const char *key)
key              1384 source4/torture/rpc/winreg.c 	init_winreg_String(&r.in.key, key);
key               165 source4/winbind/wb_pam_auth.c 	state->user_session_key = base->key;
key               537 source4/winbind/wb_samba3_cmd.c 		       &user_session_key.key,
key               548 source4/winbind/wb_samba3_cmd.c 		       lm_key.key,