--- /dev/null
+/*
+ * Copyright (c) 2005-2006,2010 Apple Inc. All Rights Reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ *
+ * 01DL_CreateReleation.c
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <Security/cssmapi.h>
+#include <Security/cssmapple.h>
+
+#include "testmore.h"
+#include "testenv.h"
+#include "testcssm.h"
+#include "testleaks.h"
+
+#define DBNAME "testdl"
+
+CSSM_APPLEDL_OPEN_PARAMETERS openParameters =
+{
+ sizeof(CSSM_APPLEDL_OPEN_PARAMETERS),
+ CSSM_APPLEDL_OPEN_PARAMETERS_VERSION,
+ CSSM_FALSE,
+ kCSSM_APPLEDL_MASK_MODE,
+ 0600
+};
+CSSM_DBINFO dbInfo =
+{
+ 0 /* NumberOfRecordTypes */,
+ NULL,
+ NULL,
+ NULL,
+ CSSM_TRUE /* IsLocal */,
+ NULL, /* AccessPath - URL, dir path, etc. */
+ NULL /* reserved */
+};
+CSSM_DB_SCHEMA_ATTRIBUTE_INFO attributeInfo[] =
+{
+ {
+ 1,
+ "string-1",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_STRING
+ },
+ {
+ 2,
+ "sint32-2",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_SINT32
+ },
+ {
+ 3,
+ "uint32-3",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_UINT32
+ },
+ {
+ 4,
+ "big_num-4",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM
+ },
+ {
+ 5,
+ "real-5",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_REAL
+ },
+ {
+ 6,
+ "time-date-6",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE
+ },
+ {
+ 7,
+ "blob-7",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_BLOB
+ },
+ {
+ 8,
+ "multi-uint32-8",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32
+ },
+#if 0
+ /* @@@ DL bug if you create a relation with a
+ CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX type attribute it succeeds but
+ subsequent inserts in that table fail. */
+ {
+ 9,
+ "complex-9",
+ {},
+ CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX
+ }
+#endif
+};
+CSSM_DB_SCHEMA_INDEX_INFO indexInfo[] =
+{
+ {
+ 1,
+ 0,
+ CSSM_DB_INDEX_UNIQUE,
+ CSSM_DB_INDEX_ON_ATTRIBUTE
+ },
+ {
+ 1,
+ 1,
+ CSSM_DB_INDEX_NONUNIQUE,
+ CSSM_DB_INDEX_ON_ATTRIBUTE
+ },
+ {
+ 2,
+ 2,
+ CSSM_DB_INDEX_NONUNIQUE,
+ CSSM_DB_INDEX_ON_ATTRIBUTE
+ }
+};
+CSSM_DATA values_str_1[] =
+{
+ { 7, (uint8 *)"value-1" }
+};
+CSSM_DATA values_str_2[] =
+{
+ { 7, (uint8 *)"value-2" }
+};
+CSSM_DATA values_sint32_1[] =
+{
+ { sizeof(sint32), (uint8 *)"1111" }
+};
+CSSM_DATA values_sint32_2[] =
+{
+ { sizeof(sint32), (uint8 *)"2222" }
+};
+
+CSSM_DB_ATTRIBUTE_DATA attributeData[] =
+{
+ {
+ {
+ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER,
+ { (char *)((uint64_t)1<<32|1) },
+ CSSM_DB_ATTRIBUTE_FORMAT_STRING
+ },
+ sizeof(values_str_1) / sizeof(CSSM_DATA),
+ values_str_1
+ },
+ {
+ {
+ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER,
+ { (char *)((uint64_t)2<<32|2) },
+ CSSM_DB_ATTRIBUTE_FORMAT_SINT32
+ },
+ sizeof(values_sint32_1) / sizeof(CSSM_DATA),
+ values_sint32_1
+ }
+};
+CSSM_DB_RECORD_ATTRIBUTE_DATA attributes =
+{
+ 42,
+ 0x00008000,
+ sizeof(attributeData) / sizeof(CSSM_DB_ATTRIBUTE_DATA),
+ attributeData
+};
+
+CSSM_DB_ATTRIBUTE_DATA newAttributeData[] =
+{
+ {
+ {
+ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER,
+ { (char *)((uint64_t)1<<32|1) },
+ CSSM_DB_ATTRIBUTE_FORMAT_STRING
+ },
+ sizeof(values_str_2) / sizeof(CSSM_DATA),
+ values_str_2
+ },
+ {
+ {
+ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER,
+ { (char *)((uint64_t)2<<32|2) },
+ CSSM_DB_ATTRIBUTE_FORMAT_SINT32
+ },
+ sizeof(values_sint32_2) / sizeof(CSSM_DATA),
+ values_sint32_2
+ }
+};
+CSSM_DB_RECORD_ATTRIBUTE_DATA newAttributes =
+{
+ 42,
+ 0x80000001, /* Semantic Information. */
+ sizeof(newAttributeData) / sizeof(CSSM_DB_ATTRIBUTE_DATA),
+ newAttributeData
+};
+
+static void free_attributes_data(const CSSM_API_MEMORY_FUNCS *memfuncs,
+ CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR attributes, CSSM_DATA_PTR data)
+{
+ if (data && data->Data)
+ {
+ memfuncs->free_func(data->Data, memfuncs->AllocRef);
+ data->Data = NULL;
+ }
+
+ if (attributes && attributes->AttributeData)
+ {
+ uint32 aix;
+ for (aix = 0; aix < attributes->NumberOfAttributes; ++aix)
+ {
+ if (attributes->AttributeData[aix].Value)
+ {
+ uint32 vix;
+ for (vix = 0;
+ vix < attributes->AttributeData[aix].NumberOfValues; ++vix)
+ {
+ if (attributes->AttributeData[aix].Value[vix].Data)
+ {
+ memfuncs->free_func(
+ attributes->AttributeData[aix].Value[vix].Data,
+ memfuncs->AllocRef);
+ }
+ }
+
+ memfuncs->free_func(attributes->AttributeData[aix].Value,
+ memfuncs->AllocRef);
+ attributes->AttributeData[aix].NumberOfValues = 0;
+ attributes->AttributeData[aix].Value = NULL;
+ }
+ }
+ }
+}
+
+static int test_is_attributes_data(
+ const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes1, const CSSM_DATA *data1,
+ const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes2, const CSSM_DATA *data2,
+ const char *description, const char *directive,
+ const char *reason, const char *file, unsigned line)
+{
+ if (attributes1 || attributes2)
+ {
+ if (!attributes1 || !attributes2)
+ return test_ok(0, description, directive, reason, file, line,
+ "# got CSSM_DB_RECORD_ATTRIBUTE_DATA %p\n"
+ "# expected CSSM_DB_RECORD_ATTRIBUTE_DATA %p\n",
+ attributes1, attributes2);
+
+ if (attributes1->DataRecordType != attributes2->DataRecordType ||
+ attributes1->SemanticInformation !=
+ attributes2->SemanticInformation ||
+ attributes1->NumberOfAttributes != attributes2->NumberOfAttributes)
+ return test_ok(0, description, directive, reason, file, line,
+ "# got CSSM_DB_RECORD_ATTRIBUTE_DATA:\n"
+ "# DataRecordType: %08x\n"
+ "# SemanticInformation: %08x\n"
+ "# NumberOfAttributes: %lu\n"
+ "# expected CSSM_DB_RECORD_ATTRIBUTE_DATA:\n"
+ "# DataRecordType: %08x\n"
+ "# SemanticInformation: %08x\n"
+ "# NumberOfAttributes: %lu\n",
+ attributes1->DataRecordType,
+ attributes1->SemanticInformation,
+ attributes1->NumberOfAttributes,
+ attributes2->DataRecordType,
+ attributes2->SemanticInformation,
+ attributes2->NumberOfAttributes);
+ uint32 ai;
+ for (ai = 0; ai < attributes1->NumberOfAttributes; ++ai)
+ {
+ const CSSM_DB_ATTRIBUTE_DATA *a1 = &attributes1->AttributeData[ai];
+ const CSSM_DB_ATTRIBUTE_DATA *a2 = &attributes2->AttributeData[ai];
+ if (a1->Info.AttributeFormat != a2->Info.AttributeFormat ||
+ a1->NumberOfValues != a2->NumberOfValues)
+ return test_ok(0, description, directive, reason, file, line,
+ "# got AttributeData[%lu]:\n"
+ "# AttributeFormat: %08x\n"
+ "# NumberOfValues: %lu\n"
+ "# expected AttributeData[%lu]:\n"
+ "# AttributeFormat: %08x\n"
+ "# NumberOfValues: %lu\n",
+ ai, a1->Info.AttributeFormat, a1->NumberOfValues,
+ ai, a2->Info.AttributeFormat, a2->NumberOfValues);
+ uint32 vi;
+ for (vi = 0; vi < a1->NumberOfValues; ++vi)
+ {
+ const CSSM_DATA *d1 = &a1->Value[vi];
+ const CSSM_DATA *d2 = &a2->Value[vi];
+ if (d1->Length != d2->Length || !d1->Data || !d2->Data ||
+ memcmp(d1->Data, d2->Data, d1->Length))
+ return test_ok(d1->Data == d2->Data, description,
+ directive, reason, file, line,
+ "# got AttributeData[%lu].Value[%lu]:\n"
+ "# length: %lu\n"
+ "# data: '%.*s'\n"
+ "# expected AttributeData[%lu].Value[%lu]:\n"
+ "# length: %lu\n"
+ "# data: '%.*s'\n",
+ ai, vi, d1->Length, (int)d1->Length, d1->Data,
+ ai, vi, d2->Length, (int)d2->Length, d2->Data);
+ }
+ }
+ }
+ if (data1 || data2)
+ {
+ if (!data1 || !data2)
+ return test_ok(0, description, directive, reason, file, line,
+ "# got CSSM_DATA %p\n"
+ "# expected CSSM_DATA %p\n", data1, data2);
+ if (data1->Length != data2->Length || !data1->Data || !data2->Data ||
+ memcmp(data1->Data, data2->Data, data1->Length))
+ return test_ok(data1->Data == data2->Data, description, directive,
+ reason, file, line,
+ "# got CSSM_DATA:\n"
+ "# length: %lu\n"
+ "# data: '%.*s'\n"
+ "# expected CSSM_DATA:\n"
+ "# length: %lu\n"
+ "# data: '%.*s'\n",
+ data1->Length, (int)data1->Length, data1->Data,
+ data2->Length, (int)data2->Length, data2->Data);
+ }
+
+ return test_ok(1, description, directive, reason, file, line, NULL);
+}
+
+#define is_attributes_data(A1, D1, A2, D2, TESTNAME) \
+( \
+ test_is_attributes_data((A1), (D1), (A2), (D2), \
+ TESTNAME, test_directive, test_reason, __FILE__, __LINE__) \
+)
+
+static void test1(CSSM_DL_HANDLE dl)
+{
+ CSSM_DL_DB_HANDLE dldb = { dl };
+ CSSM_DB_UNIQUE_RECORD_PTR uniqueId;
+
+ CSSM_DATA data = { 4, (uint8 *)"test" };
+ ok_status(CSSM_DL_DbCreate(dl, DBNAME, NULL /* DbLocation */,
+ &dbInfo,
+ CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE,
+ NULL /* CredAndAclEntry */,
+ NULL /* &openParameters */,
+ &dldb.DBHandle),
+ "CSSM_DL_DbCreate");
+
+ is_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ &data,
+ &uniqueId),
+ CSSMERR_DL_INVALID_RECORDTYPE, "CSSM_DL_DataInsert no table");
+
+ ok_status(CSSM_DL_CreateRelation(dldb,
+ 42,
+ "Fourty Two",
+ sizeof(attributeInfo) / sizeof(CSSM_DB_SCHEMA_ATTRIBUTE_INFO),
+ attributeInfo,
+ sizeof(indexInfo) / sizeof(CSSM_DB_SCHEMA_INDEX_INFO),
+ indexInfo), "CSSM_DL_CreateRelation");
+
+ ok_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ &data,
+ &uniqueId), "CSSM_DL_DataInsert");
+
+ is_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ &data,
+ &uniqueId),
+ CSSMERR_DL_INVALID_UNIQUE_INDEX_DATA, "CSSM_DL_DataInsert dupe");
+
+ ok_status(CSSM_DL_DataModify(dldb,
+ attributes.DataRecordType,
+ uniqueId,
+ &newAttributes,
+ &data,
+ CSSM_DB_MODIFY_ATTRIBUTE_REPLACE), "CSSM_DL_DataModify");
+
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+
+ ok_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ &data,
+ &uniqueId), "CSSM_DL_DataInsert old one again");
+
+ CSSM_API_MEMORY_FUNCS memfuncs = {};
+ ok_status(CSSM_GetAPIMemoryFunctions(dldb.DLHandle, &memfuncs),
+ "CSSM_GetAPIMemoryFunctions");
+
+ ok_status(CSSM_DL_DataGetFromUniqueRecordId(dldb, uniqueId, NULL, NULL),
+ "CSSM_DL_DataGetFromUniqueRecordId get nothing");
+
+ CSSM_DATA resultData = {};
+ ok_status(CSSM_DL_DataGetFromUniqueRecordId(dldb, uniqueId,
+ NULL, &resultData),
+ "CSSM_DL_DataGetFromUniqueRecordId get data");
+ is_attributes_data(NULL, &resultData, NULL, &data, "Does data match?");
+ free_attributes_data(&memfuncs, NULL, &resultData);
+
+ CSSM_DB_RECORD_ATTRIBUTE_DATA baseNoAttrs = attributes;
+ baseNoAttrs.NumberOfAttributes = 0;
+ baseNoAttrs.AttributeData = NULL;
+ CSSM_DB_RECORD_ATTRIBUTE_DATA resultNoAttrs = {};
+ ok_status(CSSM_DL_DataGetFromUniqueRecordId(dldb, uniqueId,
+ &resultNoAttrs, NULL),
+ "CSSM_DL_DataGetFromUniqueRecordId get 0 attributes");
+ is_attributes_data(&resultNoAttrs, NULL, &baseNoAttrs, NULL,
+ "Do attrs match?");
+ free_attributes_data(&memfuncs, &resultNoAttrs, NULL);
+
+ ok_status(CSSM_DL_DataGetFromUniqueRecordId(dldb, uniqueId,
+ &resultNoAttrs, &resultData),
+ "CSSM_DL_DataGetFromUniqueRecordId get data and 0 attributes");
+ is_attributes_data(&resultNoAttrs, &resultData, &baseNoAttrs, &data,
+ "Do attrs and data match?");
+ free_attributes_data(&memfuncs, &resultNoAttrs, &resultData);
+
+ CSSM_DB_ATTRIBUTE_DATA resultAttributeData[] =
+ {
+ {{ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER, { (char *)((uint64_t)1<<32|1) } }},
+ {{ CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER, { (char *)((uint64_t)2<<32|2) } }}
+ };
+ CSSM_DB_RECORD_ATTRIBUTE_DATA resultAttrs =
+ {
+ 0, 0,
+ sizeof(resultAttributeData) / sizeof(*resultAttributeData),
+ resultAttributeData
+ };
+ ok_status(CSSM_DL_DataGetFromUniqueRecordId(dldb, uniqueId,
+ &resultAttrs, &resultData),
+ "CSSM_DL_DataGetFromUniqueRecordId get data and 2 attributes");
+ is_attributes_data(&resultAttrs, &resultData, &attributes, &data,
+ "Do attrs and data match?");
+ free_attributes_data(&memfuncs, &resultAttrs, &resultData);
+
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+
+ CSSM_SELECTION_PREDICATE predicates[] =
+ {
+ {
+ CSSM_DB_EQUAL,
+ {
+ { CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER, { (char *)((uint64_t)1<<32|1) } },
+ 1, values_str_1
+ }
+ }
+ };
+ CSSM_QUERY query =
+ {
+ attributes.DataRecordType,
+ CSSM_DB_AND,
+ sizeof(predicates) / sizeof(*predicates),
+ predicates,
+ { CSSM_QUERY_TIMELIMIT_NONE, CSSM_QUERY_SIZELIMIT_NONE },
+ 0 /* CSSM_QUERY_RETURN_DATA -- for keys only to return raw key bits */
+ };
+ CSSM_HANDLE search = CSSM_INVALID_HANDLE;
+ is_status(CSSM_DL_DataGetFirst(dldb, &query, NULL,
+ NULL, NULL, NULL), CSSM_ERRCODE_INVALID_POINTER,
+ "CSSM_DL_DataGetFirst no search handle, no unique_record");
+ is_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ NULL, NULL, NULL), CSSM_ERRCODE_INVALID_POINTER,
+ "CSSM_DL_DataGetFirst no unique_record");
+ is_status(CSSM_DL_DataGetFirst(dldb, &query, NULL,
+ NULL, NULL, &uniqueId), CSSM_ERRCODE_INVALID_POINTER,
+ "CSSM_DL_DataGetFirst no search handle");
+
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ NULL, NULL, &uniqueId),
+ "CSSM_DL_DataGetFirst no data no attrs");
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ &resultNoAttrs, NULL, &uniqueId),
+ "CSSM_DL_DataGetFirst 0 attrs");
+ is_attributes_data(&resultNoAttrs, NULL, &baseNoAttrs, NULL,
+ "Do attrs match?");
+ free_attributes_data(&memfuncs, &resultNoAttrs, NULL);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ NULL, &resultData, &uniqueId),
+ "CSSM_DL_DataGetFirst data");
+ is_attributes_data(NULL, &resultData, NULL, &data, "Does data match?");
+ free_attributes_data(&memfuncs, NULL, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ &resultNoAttrs, &resultData, &uniqueId),
+ "CSSM_DL_DataGetFirst 0 attrs and data");
+ is_attributes_data(&resultNoAttrs, &resultData, &baseNoAttrs, &data,
+ "Do attrs and data match?");
+ free_attributes_data(&memfuncs, &resultNoAttrs, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ &resultAttrs, &resultData, &uniqueId),
+ "CSSM_DL_DataGetFirst 2 attrs and data");
+ is_attributes_data(&resultAttrs, &resultData, &attributes, &data,
+ "Do attrs and data match?");
+ free_attributes_data(&memfuncs, &resultAttrs, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ SKIP: {
+ skip("nothing to free", 2,
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query, &search,
+ &resultAttrs, &resultData, &uniqueId),
+ "CSSM_DL_DataGetFirst 2 attrs and data"));
+ is_attributes_data(&resultAttrs, &resultData, &attributes, &data,
+ "Do attrs and data match?");
+ free_attributes_data(&memfuncs, &resultAttrs, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ }
+
+ is_status(CSSM_DL_DataGetNext(dldb, search,
+ &resultAttrs, &resultData, &uniqueId),
+ CSSMERR_DL_ENDOFDATA, "CSSM_DL_DataGetNext returns eod");
+
+ CSSM_QUERY query2 =
+ {
+ attributes.DataRecordType,
+ CSSM_DB_NONE,
+ 0,
+ NULL,
+ { CSSM_QUERY_TIMELIMIT_NONE, CSSM_QUERY_SIZELIMIT_NONE },
+ 0 /* CSSM_QUERY_RETURN_DATA -- for keys only to return raw key bits */
+ };
+ ok_status(CSSM_DL_DataGetFirst(dldb, &query2, &search,
+ &resultAttrs, &resultData, &uniqueId),
+ "CSSM_DL_DataGetFirst 2 attrs and data");
+ free_attributes_data(&memfuncs, &resultAttrs, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataGetNext(dldb, search,
+ &resultAttrs, &resultData, &uniqueId),
+ "CSSM_DL_DataGetNext 2 attrs and data");
+ free_attributes_data(&memfuncs, &resultAttrs, &resultData);
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+ ok_status(CSSM_DL_DataAbortQuery(dldb, search),
+ "CSSM_DL_DataAbortQuery");
+
+ ok_status(CSSM_DL_DbClose(dldb),
+ "CSSM_DL_DbClose");
+}
+
+static void test2(CSSM_DL_HANDLE dl)
+{
+ CSSM_DL_DB_HANDLE dldb = { dl };
+ CSSM_DB_UNIQUE_RECORD_PTR uniqueId;
+
+ ok_status(CSSM_DL_DbCreate(dl, DBNAME, NULL /* DbLocation */,
+ &dbInfo,
+ CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE,
+ NULL /* CredAndAclEntry */,
+ NULL,
+ &dldb.DBHandle),
+ "CSSM_DL_DbCreate");
+
+ ok_status(CSSM_DL_DbClose(dldb),
+ "CSSM_DL_DbClose");
+
+ ok_status(CSSM_DL_DbOpen(dl, DBNAME, NULL /* DbLocation */,
+ CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE,
+ NULL /* CredAndAclEntry */,
+ &openParameters,
+ &dldb.DBHandle),
+ "CSSM_DL_DbOpen");
+
+ is_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ NULL,
+ &uniqueId),
+ CSSMERR_DL_INVALID_RECORDTYPE, "CSSM_DL_DataInsert no table");
+
+ ok_status(CSSM_DL_CreateRelation(dldb,
+ 42,
+ "Fourty Two",
+ sizeof(attributeInfo) / sizeof(CSSM_DB_SCHEMA_ATTRIBUTE_INFO),
+ attributeInfo,
+ sizeof(indexInfo) / sizeof(CSSM_DB_SCHEMA_INDEX_INFO),
+ indexInfo), "CSSM_DL_CreateRelation");
+
+ ok_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ NULL,
+ &uniqueId), "CSSM_DL_DataInsert fails unless 4039735 is fixed");
+
+ is_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ NULL,
+ &uniqueId),
+ CSSMERR_DL_INVALID_UNIQUE_INDEX_DATA,
+ "CSSM_DL_DataInsert dupe");
+
+ ok_status(CSSM_DL_DataDelete(dldb, uniqueId),
+ "CSSM_DL_Delete");
+
+ is_status(CSSM_DL_DataDelete(dldb, uniqueId),
+ CSSMERR_DL_RECORD_NOT_FOUND, "delete again should fail");
+
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+
+ ok_status(CSSM_DL_DataInsert(dldb,
+ attributes.DataRecordType,
+ &attributes,
+ NULL,
+ &uniqueId), "Insert again after delete");
+
+ ok_status(CSSM_DL_FreeUniqueRecord(dldb, uniqueId),
+ "CSSM_DL_FreeUniqueRecord");
+
+ ok_status(CSSM_DL_DbClose(dldb),
+ "CSSM_DL_DbDelete");
+}
+
+int
+main(int argc, char * const *argv)
+{
+ int guid_alt = argc > 1 && !strcmp(argv[1], "-g");
+ /* {2cb56191-ee6f-432d-a377-853d3c6b949e} */
+ CSSM_GUID s3dl_guid =
+ {
+ 0x2cb56191, 0xee6f, 0x432d,
+ { 0xa3, 0x77, 0x85, 0x3d, 0x3c, 0x6b, 0x94, 0x9e }
+ };
+ const CSSM_GUID *guid = guid_alt ? & s3dl_guid : &gGuidAppleFileDL;
+
+ plan_tests(70);
+
+ CSSM_DL_HANDLE dl;
+ ok(cssm_attach(guid, &dl), "cssm_attach");
+ ok(tests_begin(argc, argv), "tests_begin");
+
+ test1(dl);
+ ok_status(CSSM_DL_DbDelete(dl, DBNAME, NULL /* DbLocation */,
+ NULL /* AccessCred */), "CSSM_DL_DbDelete");
+ test2(dl);
+ ok_status(CSSM_DL_DbDelete(dl, DBNAME, NULL /* DbLocation */,
+ NULL /* AccessCred */), "CSSM_DL_DbDelete");
+ ok(cssm_detach(guid, dl), "cssm_detach");
+ ok_leaks("no leaks");
+
+ return !tests_end(1);
+}
projects / apple / security.git / blobdiff