Changeset 21494 for trunk/src/rsaenh

Timestamp:

Dec 2, 2010, 1:19:12 AM (15 years ago)

Author:

dmik

Message:

Fixed broken build after r21492 by sorting out a huuuuge wagon of duplicates, wrong include order and other dirty mess.

Location:

trunk/src/rsaenh

Files:

• handle.c (modified) (14 diffs)
• handle.h (modified) (1 diff)
• rsaenh.c (modified) (1 diff)
• rsaenh.def (modified) (1 diff)
• tomcrypt.h (modified) (1 diff)

trunk/src/rsaenh/handle.c

@@ -39 +39 @@
  *  init_handle_table
  *
- * Initializes the HANDLETABLE structure pointed to by lpTable
- *
- * PARAMS
- *  lpTable [I] Pointer to the HANDLETABLE structure, which is to be initalized.
+ * Initializes the HANDLETBL structure pointed to by lpTable
+ *
+ * PARAMS
+ *  lpTable [I] Pointer to the HANDLETBL structure, which is to be initalized.
  *
  * NOTES
  *  Note that alloc_handle_table calls init_handle_table on it's own, which 
  *  means that you only have to call init_handle_table, if you use a global
- *  variable of type HANDLETABLE for your handle table. However, in this
+ *  variable of type HANDLETBL for your handle table. However, in this
  *  case you have to call destroy_handle_table when you don't need the table
  *  any more.
  */
-void init_handle_table(HANDLETABLE *lpTable)
+void init_handle_table(HANDLETBL *lpTable)
 {
     TRACE("(lpTable=%p)\n", lpTable);
@@ -59 +59 @@
     lpTable->iFirstFree = 0;
     InitializeCriticalSection(&lpTable->mutex);
-    //lpTable->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": HANDLETABLE.mutex");
+    //lpTable->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": HANDLETBL.mutex");
 }
 
@@ -73 +73 @@
  *  Note that release_handle_table takes care of this.
  */
-void destroy_handle_table(HANDLETABLE *lpTable)
+void destroy_handle_table(HANDLETBL *lpTable)
 {
     TRACE("(lpTable=%p)\n", lpTable);
@@ -97 +97 @@
  *  zero,      if handle is not valid.
  */
-int is_valid_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType)
+int is_valid_handle(HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType)
 {
     unsigned int index = HANDLE2INDEX(handle);
@@ -133 +133 @@
  *  lpTable [I] The table of which all valid handles shall be released.
  */
-static void release_all_handles(HANDLETABLE *lpTable)
+static void release_all_handles(HANDLETBL *lpTable)
 {
     unsigned int i;
@@ -160 +160 @@
  * NOTES
  *  If all you need is a single handle table, you may as well declare a global 
- *  variable of type HANDLETABLE and call init_handle_table on your own. 
- */
-int alloc_handle_table(HANDLETABLE **lplpTable)
+ *  variable of type HANDLETBL and call init_handle_table on your own. 
+ */
+int alloc_handle_table(HANDLETBL **lplpTable)
 {
     TRACE("(lplpTable=%p)\n", lplpTable);
         
-    *lplpTable = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETABLE));
+    *lplpTable = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETBL));
     if (*lplpTable) 
     {
@@ -191 +191 @@
  *   All valid handles still in the table are released also.
  */
-int release_handle_table(HANDLETABLE *lpTable) 
+int release_handle_table(HANDLETBL *lpTable) 
 {
     TRACE("(lpTable=%p)\n", lpTable);
@@ -215 +215 @@
  *  This is a support function for alloc_handle. Do not call!
  */
-static int grow_handle_table(HANDLETABLE *lpTable) 
-{
-    HANDLETABLEENTRY *newEntries;
+static int grow_handle_table(HANDLETBL *lpTable) 
+{
+    HANDLETBLENTRY *newEntries;
     unsigned int i, newIEntries;
 
     newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 
-    newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETABLEENTRY)*newIEntries);
+    newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLETBLENTRY)*newIEntries);
     if (!newEntries) 
         return 0;
@@ -228 +228 @@
     if (lpTable->paEntries)
     {
-        memcpy(newEntries, lpTable->paEntries, sizeof(HANDLETABLEENTRY)*lpTable->iEntries);
+        memcpy(newEntries, lpTable->paEntries, sizeof(HANDLETBLENTRY)*lpTable->iEntries);
         HeapFree(GetProcessHeap(), 0, lpTable->paEntries);
     }
@@ -260 +260 @@
  *  zero,      if not successful (no free handle)
  */
-static int alloc_handle(HANDLETABLE *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
+static int alloc_handle(HANDLETBL *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
 {
     int ret = 0;
@@ -307 +307 @@
  *  zero,      if not successful (invalid handle)
  */
-int release_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType)
+int release_handle(HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType)
 {
     unsigned int index = HANDLE2INDEX(handle);
@@ -352 +352 @@
  *  zero,      if not successful (invalid handle)
  */
-int lookup_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
+int lookup_handle(HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
 {
     int ret = 0;
@@ -387 +387 @@
  *  zero,      if not successful (invalid handle or out of memory)
  */
-int copy_handle(HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
+int copy_handle(HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
 {
     OBJECTHDR *pObject;
@@ -430 +430 @@
  *  a handle to the new object,  if successful. 
  */
-HCRYPTKEY new_object(HANDLETABLE *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
+HCRYPTKEY new_object(HANDLETBL *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
                         OBJECTHDR **ppObject)
 {

trunk/src/rsaenh/handle.h

@@ -43 +43 @@
 };
 
-typedef struct tagHANDLETABLEENTRY
+typedef struct tagHANDLETBLENTRY
 {
     OBJECTHDR    *pObject;
     unsigned int iNextFree;
-} HANDLETABLEENTRY;
+} HANDLETBLENTRY;
 
-typedef struct tagHANDLETABLE
+typedef struct tagHANDLETBL
 {
     unsigned int     iEntries;
     unsigned int     iFirstFree;
-    HANDLETABLEENTRY *paEntries;
+    HANDLETBLENTRY *paEntries;
     CRITICAL_SECTION mutex;
-} HANDLETABLE;
+} HANDLETBL;
 
-int  alloc_handle_table  (HANDLETABLE **lplpTable);
-void init_handle_table   (HANDLETABLE *lpTable);
-int  release_handle_table(HANDLETABLE *lpTable);
-void destroy_handle_table(HANDLETABLE *lpTable);
-int  release_handle      (HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType);
-int  copy_handle         (HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy);
-int  lookup_handle       (HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject);
-int  is_valid_handle     (HANDLETABLE *lpTable, HCRYPTKEY handle, DWORD dwType);
+int  alloc_handle_table  (HANDLETBL **lplpTable);
+void init_handle_table   (HANDLETBL *lpTable);
+int  release_handle_table(HANDLETBL *lpTable);
+void destroy_handle_table(HANDLETBL *lpTable);
+int  release_handle      (HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType);
+int  copy_handle         (HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy);
+int  lookup_handle       (HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject);
+int  is_valid_handle     (HANDLETBL *lpTable, HCRYPTKEY handle, DWORD dwType);
 
-HCRYPTKEY new_object     (HANDLETABLE *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
-                           OBJECTHDR **ppObject);
-        
+HCRYPTKEY new_object     (HANDLETBL *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
+                          OBJECTHDR **ppObject);
+
 #ifdef __cplusplus
 }

trunk/src/rsaenh/rsaenh.c

@@ -348 +348 @@
  * CSP's handle table (used by all acquired key containers)
  */
-static HANDLETABLE handle_table;
+static HANDLETBL handle_table;
 
 /******************************************************************************

trunk/src/rsaenh/rsaenh.def

@@ -44 +44 @@
 _MD4Init@4 = ADVAPI32.504
 _MD5Init@4 = ADVAPI32.507
-wsnprintfA = USER32.2100
+_wsnprintfA = USER32.2100
 _SystemFunction036@8 = ADVAPI32.402

trunk/src/rsaenh/tomcrypt.h

@@ -46 +46 @@
     int hi;
 } __long_long;
+
+#ifdef __int64
+#undef __int64
+#endif
 #define __int64 __long_long