Ignore:
Timestamp:
Jun 11, 1999, 3:00:21 PM (26 years ago)
Author:
phaller
Message:

Fix: added more debug info, beautified source.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/advapi32/ADVAPI32.CPP

    r91 r102  
    1 /* $Id: ADVAPI32.CPP,v 1.3 1999-06-10 14:23:33 phaller Exp $ */
     1/* $Id: ADVAPI32.CPP,v 1.4 1999-06-11 13:00:21 phaller Exp $ */
    22
    33/*
    … …  
    5555DWORD WIN32API RegCloseKey( HKEY arg1)
    5656{
    57     dprintf(("RegCloseKey %X\n", arg1));
     57    dprintf(("ADVAPI32: RegCloseKey %X\n", arg1));
    5858    return O32_RegCloseKey(ConvertKey(arg1));
    5959}
    … …  
    6262DWORD WIN32API RegCreateKeyA( HKEY arg1, LPCSTR arg2, PHKEY  arg3)
    6363{
    64 #ifdef DEBUG
    65     WriteLog("RegCreateKey\n");
    66 #endif
    67     return O32_RegCreateKey(ConvertKey(arg1), arg2, arg3);
     64  dprintf(("ADVAPI32: RegCreateKey(%08xh,%s,%08xh)\n",
     65           arg1,
     66           arg2,
     67           arg3));
     68
     69  return O32_RegCreateKey(ConvertKey(arg1),
     70                          arg2,
     71                          arg3);
    6872}
    6973//******************************************************************************
    … …  
    7175DWORD WIN32API RegCreateKeyW(HKEY arg1, LPCWSTR arg2, PHKEY  arg3)
    7276{
    73  char *astring = UnicodeToAsciiString((LPWSTR)arg2);
    74  LONG  rc;
    75 
    76 #ifdef DEBUG
    77     WriteLog("RegCreateKeyW %s\n", astring);
    78 #endif
    79     rc = O32_RegCreateKey(ConvertKey(arg1), astring, arg3);
    80     FreeAsciiString(astring);
    81     return(rc);
    82 }
    83 //******************************************************************************
    84 //******************************************************************************
    85 DWORD WIN32API RegCreateKeyExA( HKEY arg1, LPCSTR arg2, DWORD arg3, LPSTR arg4, DWORD arg5, REGSAM arg6, LPSECURITY_ATTRIBUTES arg7, PHKEY arg8, LPDWORD  arg9)
    86 {
    87 #ifdef DEBUG
    88     WriteLog("RegCreateKeyEx\n");
    89 #endif
    90     return O32_RegCreateKeyEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6 | KEY_READ, arg7, arg8, arg9);
    91 }
    92 //******************************************************************************
    93 //******************************************************************************
    94 DWORD WIN32API RegCreateKeyExW( HKEY arg1, LPCWSTR arg2, DWORD arg3, LPWSTR arg4, DWORD arg5, REGSAM arg6, LPSECURITY_ATTRIBUTES arg7, PHKEY arg8, LPDWORD  arg9)
     77  char *astring = UnicodeToAsciiString((LPWSTR)arg2);
     78  LONG  rc;
     79
     80  dprintf(("ADVAPI32: RegCreateKeyW(%08xh,%s,%08xh)\n",
     81           arg1,
     82           astring,
     83           arg3));
     84
     85  rc = O32_RegCreateKey(ConvertKey(arg1),
     86                        astring,
     87                        arg3);
     88  FreeAsciiString(astring);
     89  return(rc);
     90}
     91//******************************************************************************
     92//******************************************************************************
     93DWORD WIN32API RegCreateKeyExA(HKEY   arg1,
     94                               LPCSTR arg2,
     95                               DWORD  arg3,
     96                               LPSTR  arg4,
     97                               DWORD  arg5,
     98                               REGSAM arg6,
     99                               LPSECURITY_ATTRIBUTES arg7,
     100                               PHKEY   arg8,
     101                               LPDWORD arg9)
     102{
     103  dprintf(("ADVAPI32: RegCreateKeyExA(%08xh,%s,%08xh,%s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     104           arg1,
     105           arg2,
     106           arg3,
     107           arg4,
     108           arg5,
     109           arg6,
     110           arg7,
     111           arg8,
     112           arg9));
     113
     114    return O32_RegCreateKeyEx(ConvertKey(arg1),
     115                              arg2,
     116                              arg3,
     117                              arg4,
     118                              arg5,
     119                              arg6 | KEY_READ,
     120                              arg7,
     121                              arg8,
     122                              arg9);
     123}
     124//******************************************************************************
     125//******************************************************************************
     126DWORD WIN32API RegCreateKeyExW(HKEY    arg1,
     127                               LPCWSTR arg2,
     128                               DWORD   arg3,
     129                               LPWSTR  arg4,
     130                               DWORD   arg5,
     131                               REGSAM  arg6,
     132                               LPSECURITY_ATTRIBUTES arg7,
     133                               PHKEY   arg8,
     134                               LPDWORD arg9)
    95135{
    96136 char *astring1 = UnicodeToAsciiString((LPWSTR)arg2);
    … …  
    98138 LONG  rc;
    99139
    100 #ifdef DEBUG
    101     WriteLog("RegCreateKeyExW\n");
    102 #endif
    103     rc = O32_RegCreateKeyEx(ConvertKey(arg1), astring1, arg3, astring2, arg5, arg6 | KEY_READ, arg7, arg8, arg9);
    104     FreeAsciiString(astring1);
    105     FreeAsciiString(astring2);
    106     return(rc);
    107 }
    108 //******************************************************************************
    109 //******************************************************************************
    110 DWORD WIN32API RegDeleteKeyW(HKEY arg1, LPWSTR  arg2)
    111 {
    112  char *astring = UnicodeToAsciiString(arg2);
    113  LONG  rc;
    114 
    115 #ifdef DEBUG
    116     WriteLog("RegDeleteKeyW\n");
    117 #endif
    118     rc = O32_RegDeleteKey(ConvertKey(arg1), astring);
    119     FreeAsciiString(astring);
    120     return(rc);
    121 }
    122 //******************************************************************************
    123 //******************************************************************************
    124 DWORD WIN32API RegDeleteKeyA(HKEY arg1, LPCSTR  arg2)
    125 {
    126 #ifdef DEBUG
    127     WriteLog("RegDeleteKey\n");
    128 #endif
    129     return O32_RegDeleteKey(ConvertKey(arg1), arg2);
    130 }
    131 //******************************************************************************
    132 //******************************************************************************
    133 DWORD WIN32API RegDeleteValueA(HKEY arg1, LPSTR arg2)
    134 {
    135 #ifdef DEBUG
    136     WriteLog("RegDeleteValue\n");
    137 #endif
    138     return O32_RegDeleteValue(ConvertKey(arg1), arg2);
    139 }
    140 //******************************************************************************
    141 //******************************************************************************
    142 DWORD WIN32API RegDeleteValueW(HKEY arg1, LPWSTR arg2)
    143 {
    144  char *astring = UnicodeToAsciiString(arg2);
    145  LONG  rc;
    146 
    147 #ifdef DEBUG
    148     WriteLog("RegDeleteValueW\n");
    149 #endif
    150     rc = O32_RegDeleteValue(ConvertKey(arg1), astring);
    151     FreeAsciiString(astring);
    152     return(rc);
    153 }
    154 //******************************************************************************
    155 //******************************************************************************
    156 DWORD WIN32API RegEnumKeyA(HKEY arg1, DWORD arg2, LPSTR arg3, DWORD  arg4)
    157 {
    158 #ifdef DEBUG
    159     WriteLog("RegEnumKey\n");
    160 #endif
    161     return O32_RegEnumKey(ConvertKey(arg1), arg2, arg3, arg4);
     140  dprintf(("ADVAPI32: RegCreateKeyExW(%08xh,%s,%08xh,%s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     141           arg1,
     142           astring1,
     143           arg3,
     144           astring2,
     145           arg5,
     146           arg6,
     147           arg7,
     148           arg8,
     149           arg9));
     150
     151  rc = O32_RegCreateKeyEx(ConvertKey(arg1),
     152                          astring1,
     153                          arg3,
     154                          astring2,
     155                          arg5,
     156                          arg6 | KEY_READ,
     157                          arg7,
     158                          arg8,
     159                          arg9);
     160
     161  FreeAsciiString(astring1);
     162  FreeAsciiString(astring2);
     163  return(rc);
     164}
     165//******************************************************************************
     166//******************************************************************************
     167DWORD WIN32API RegDeleteKeyW(HKEY   arg1,
     168                             LPWSTR arg2)
     169{
     170  char *astring = UnicodeToAsciiString(arg2);
     171  LONG  rc;
     172
     173  dprintf(("ADVAPI32: RegDeleteKeyW(%08xh,%s)\n",
     174           arg1,
     175           astring));
     176
     177  rc = O32_RegDeleteKey(ConvertKey(arg1), astring);
     178  FreeAsciiString(astring);
     179  return(rc);
     180}
     181//******************************************************************************
     182//******************************************************************************
     183DWORD WIN32API RegDeleteKeyA(HKEY   arg1,
     184                             LPCSTR arg2)
     185{
     186  dprintf(("ADVAPI32: RegDeleteKeyA(%08xh,%s)\n",
     187           arg1,
     188           arg2));
     189
     190  return O32_RegDeleteKey(ConvertKey(arg1), arg2);
     191}
     192//******************************************************************************
     193//******************************************************************************
     194DWORD WIN32API RegDeleteValueA(HKEY  arg1,
     195                               LPSTR arg2)
     196{
     197  dprintf(("ADVAPI32: RegDeleteValueA(%08xh,%s)\n";
     198           arg1,
     199           arg2));
     200
     201  return O32_RegDeleteValue(ConvertKey(arg1),
     202                            arg2);
     203}
     204//******************************************************************************
     205//******************************************************************************
     206DWORD WIN32API RegDeleteValueW(HKEY   arg1,
     207                               LPWSTR arg2)
     208{
     209  char *astring = UnicodeToAsciiString(arg2);
     210  LONG  rc;
     211
     212  dprintf(("ADVAPI32: RegDeleteValueW(%08xh,%s)\n",
     213           arg1,
     214           astring));
     215
     216  rc = O32_RegDeleteValue(ConvertKey(arg1),
     217                          astring);
     218  FreeAsciiString(astring);
     219  return(rc);
     220}
     221//******************************************************************************
     222//******************************************************************************
     223DWORD WIN32API RegEnumKeyA(HKEY  arg1,
     224                           DWORD arg2,
     225                           LPSTR arg3,
     226                           DWORD arg4)
     227{
     228  dprintf(("ADVAPI32: RegEnumKeyA(%08xh,%08xh,%08xh,%08xh)\n",
     229           arg1,
     230           arg2,
     231           arg3,
     232           arg4));
     233
     234  return O32_RegEnumKey(ConvertKey(arg1),
     235                        arg2,
     236                        arg3,
     237                        arg4);
    162238}
    163239//******************************************************************************
    … …  
    169245
    170246#ifdef DEBUG
    171     WriteLog("RegEnumKeyW\n");
     247    WriteLog("ADVAPI32: RegEnumKeyW\n");
    172248#endif
    173249    rc = O32_RegEnumKey(ConvertKey(arg1), arg2, (char *)arg3, arg4);
    174250    if(rc == ERROR_SUCCESS) {
    175         astring = (char *)malloc(arg4);
    176         strcpy(astring, (char *)arg3);
    177         AsciiToUnicode(astring, arg3);
    178         free(astring);
     251      astring = (char *)malloc(arg4);
     252      strcpy(astring, (char *)arg3);
     253      AsciiToUnicode(astring, arg3);
     254      free(astring);
    179255    }
    180256    return(rc);
    … …  
    185261{
    186262#ifdef DEBUG
    187     WriteLog("RegEnumKeyEx\n");
     263    WriteLog("ADVAPI32: RegEnumKeyEx\n");
    188264#endif
    189265    return O32_RegEnumKeyEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    … …  
    197273
    198274#ifdef DEBUG
    199     WriteLog("RegEnumKeyExW\n");
     275    WriteLog("ADVAPI32: RegEnumKeyExW\n");
    200276#endif
    201277    rc = O32_RegEnumKeyEx(ConvertKey(arg1), arg2, (char *)arg3, arg4, arg5, (char *)arg6, arg7, arg8);
    202278    if(rc == ERROR_SUCCESS) {
    203         astring = (char *)malloc(max(*arg4, *arg7));   //class & keyname
    204         strcpy(astring, (char *)arg3);
    205         AsciiToUnicode(astring, arg3);
    206         if(arg6 != NULL) {
    207                 strcpy(astring, (char *)arg6);
    208                 AsciiToUnicode(astring, arg6);
    209         }
    210         free(astring);
     279      astring = (char *)malloc(max(*arg4, *arg7));   //class & keyname
     280      strcpy(astring, (char *)arg3);
     281      AsciiToUnicode(astring, arg3);
     282      if(arg6 != NULL) {
     283            strcpy(astring, (char *)arg6);
     284            AsciiToUnicode(astring, arg6);
     285      }
     286      free(astring);
    211287    }
    212288    return(rc);
    … …  
    217293{
    218294#ifdef DEBUG
    219     WriteLog("RegEnumValue\n");
     295    WriteLog("ADVAPI32: RegEnumValue\n");
    220296#endif
    221297    return O32_RegEnumValue(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    … …  
    229305
    230306#ifdef DEBUG
    231     WriteLog("RegEnumValueW\n");
     307    WriteLog("ADVAPI32: RegEnumValueW\n");
    232308#endif
    233309    rc = O32_RegEnumValue(ConvertKey(arg1), arg2, (char *)arg3, arg4, arg5, arg6, arg7, arg8);
    234310    if(rc == ERROR_SUCCESS) {
    235         astring = (char *)malloc(*arg4);
    236         strcpy(astring, (char *)arg3);
    237         AsciiToUnicode(astring, arg3);
    238         free(astring);
     311      astring = (char *)malloc(*arg4);
     312      strcpy(astring, (char *)arg3);
     313      AsciiToUnicode(astring, arg3);
     314      free(astring);
    239315    }
    240316    return(rc);
    … …  
    250326    rc = O32_RegOpenKey(ConvertKey(arg1), arg2, arg3);
    251327    if(rc) {
    252         *arg3 = 0;
     328      *arg3 = 0;
    253329    }
    254330
    255331#ifdef DEBUG
    256     WriteLog("RegOpenKey 0x%x\\%s returned %d (%d)\n", arg1, arg2, *arg3, rc);
     332    WriteLog("ADVAPI32: RegOpenKey 0x%x\\%s returned %d (%d)\n", arg1, arg2, *arg3, rc);
    257333#endif
    258334    return(rc);
    … …  
    266342
    267343#ifdef DEBUG
    268     WriteLog("RegOpenKeyW\n");
     344    WriteLog("ADVAPI32: RegOpenKeyW\n");
    269345#endif
    270346    rc = O32_RegOpenKey(ConvertKey(arg1), astring, arg3);
    271347    if(rc) {
    272         *arg3 = 0;
     348      *arg3 = 0;
    273349    }
    274350
    … …  
    284360    rc = O32_RegOpenKeyEx(ConvertKey(arg1), arg2, arg3, arg4, arg5);
    285361#ifdef DEBUG
    286     WriteLog("RegOpenKeyExA %X %s returned %X (%d)\n", arg1, arg2, *arg5, rc);
     362    WriteLog("ADVAPI32: RegOpenKeyExA %X %s returned %X (%d)\n", arg1, arg2, *arg5, rc);
    287363#endif
    288364    //SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
    289365    //     return value and uses the whatever *arg5 contains)
    290366    if(rc) {
    291         *arg5 = 0;
     367      *arg5 = 0;
    292368    }
    293369    return(rc);
    … …  
    301377
    302378#ifdef DEBUG
    303     WriteLog("RegOpenKeyExW %X %s\n", arg1, astring);
     379    WriteLog("ADVAPI32: RegOpenKeyExW %X %s\n", arg1, astring);
    304380#endif
    305381    rc = O32_RegOpenKeyEx(ConvertKey(arg1), astring, arg3, arg4, arg5);
    … …  
    307383    //     return value and uses the whatever *arg5 contains)
    308384    if(rc) {
    309         *arg5 = 0;
     385      *arg5 = 0;
    310386    }
    311387    FreeAsciiString(astring);
    … …  
    317393{
    318394#ifdef DEBUG
    319     WriteLog("RegQueryInfoKey\n");
     395    WriteLog("ADVAPI32: RegQueryInfoKey\n");
    320396#endif
    321397    return O32_RegQueryInfoKey(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
    … …  
    329405
    330406#ifdef DEBUG
    331     WriteLog("RegQueryInfoKeyW\n");
     407    WriteLog("ADVAPI32: RegQueryInfoKeyW\n");
    332408#endif
    333409    rc = O32_RegQueryInfoKey(ConvertKey(arg1), (char *)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
    334410    if(rc == ERROR_SUCCESS) {
    335         astring = (char *)malloc(*arg3);
    336         strcpy(astring, (char *)arg2);
    337         AsciiToUnicode(astring, arg2);
    338         free(astring);
     411      astring = (char *)malloc(*arg3);
     412   strcpy(astring, (char *)arg2);
     413   AsciiToUnicode(astring, arg2);
     414   free(astring);
    339415    }
    340416    return(rc);
    … …  
    345421{
    346422#ifdef DEBUG
    347     WriteLog("RegQueryValue\n");
     423    WriteLog("ADVAPI32: RegQueryValue\n");
    348424#endif
    349425    return O32_RegQueryValue(ConvertKey(arg1), arg2, arg3, arg4);
    … …  
    358434
    359435#ifdef DEBUG
    360     WriteLog("RegQueryValueW\n");
     436    WriteLog("ADVAPI32: RegQueryValueW\n");
    361437#endif
    362438    rc = O32_RegQueryValue(ConvertKey(hkey), astring1, (char *)lpszValue, pcbValue);
    … …  
    374450{
    375451#ifdef DEBUG
    376     WriteLog("RegQueryValueEx %s\n", arg2);
     452    WriteLog("ADVAPI32: RegQueryValueEx %s\n", arg2);
    377453#endif
    378454    return O32_RegQueryValueEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6);
    … …  
    387463
    388464#ifdef DEBUG
    389     WriteLog("RegQueryValueExW %s\n", astring);
     465    WriteLog("ADVAPI32: RegQueryValueExW %s\n", astring);
    390466#endif
    391467    rc = O32_RegQueryValueEx(ConvertKey(arg1), astring, arg3, arg4, arg5, arg6);
    … …  
    398474{
    399475#ifdef DEBUG
    400    WriteLog("RegSetValueA %d, %s, %d, %s, %d\n", hkey, lpSubKey, dwType, lpData, cbData);
     476   WriteLog("ADVAPI32: RegSetValueA %d, %s, %d, %s, %d\n", hkey, lpSubKey, dwType, lpData, cbData);
    401477#endif
    402478   //SvL: 8-11-'97: Bugfix: crash in pmwinx if size == 0 and string is large
    … …  
    415491
    416492#ifdef DEBUG
    417     WriteLog("RegSetValue\n");
     493    WriteLog("ADVAPI32: RegSetValue\n");
    418494#endif
    419495   //SvL: 8-11-'97: Bugfix: crash in pmwinx if size == 0 and string is large
    … …  
    432508{
    433509#ifdef DEBUG
    434     WriteLog("RegSetValueEx\n");
     510    WriteLog("ADVAPI32: RegSetValueEx\n");
    435511#endif
    436512    return O32_RegSetValueEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6);
    … …  
    445521
    446522#ifdef DEBUG
    447     WriteLog("RegSetValueExW, NOT COMPLETE!!\n");
     523    WriteLog("ADVAPI32: RegSetValueExW, NOT COMPLETE!!\n");
    448524#endif
    449525    rc = O32_RegSetValueEx(ConvertKey(arg1), astring, arg3, arg4, arg5, arg6);
    … …  
    490566//******************************************************************************
    491567BOOL WIN32API SetFileSecurityA(LPCSTR lpFileName,
    492                                SECURITY_INFORMATION RequestedInformation,
    493                                PSECURITY_DESCRIPTOR pSecurityDescriptor)
     568                     SECURITY_INFORMATION RequestedInformation,
     569                         PSECURITY_DESCRIPTOR pSecurityDescriptor)
    494570{
    495571#ifdef DEBUG
    … …  
    501577//******************************************************************************
    502578BOOL WIN32API SetFileSecurityW(LPCWSTR lpFileName,
    503                                 SECURITY_INFORMATION RequestedInformation,
    504                                 PSECURITY_DESCRIPTOR pSecurityDescriptor)
     579                                         SECURITY_INFORMATION RequestedInformation,
     580                                         PSECURITY_DESCRIPTOR pSecurityDescriptor)
    505581{
    506582#ifdef DEBUG
    … …  
    598674/*PLF Sat  98-03-07 02:59:20*/
    599675BOOL WIN32API InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor,
    600                                            DWORD dwRevision)
     676                  DWORD dwRevision)
    601677{
    602678    dprintf(("InitializeSecurityDescriptor() NIY\n"));
    … …  
    607683HANDLE WIN32API RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName)
    608684{
    609     dprintf(("RegisterEventSourceA() NIY\n"));
     685    dprintf(("ADVAPI32: RegisterEventSourceA() NIY\n"));
    610686    return FALSE;
    611687}
    … …  
    614690HANDLE WIN32API RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName)
    615691{
    616     dprintf(("RegisterEventSourceW() NIY\n"));
     692    dprintf(("ADVAPI32: RegisterEventSourceW() NIY\n"));
    617693    return FALSE;
    618694}
    … …  
    661737/*PLF Sat  98-03-07 02:59:20*/
    662738BOOL WIN32API OpenProcessToken(HANDLE ProcessHandle,
    663                                DWORD DesiredAccess,
    664                                PHANDLE TokenHandle
     739                DWORD DesiredAccess,
     740                PHANDLE TokenHandle
    665741)
    666742{
    … …  
    682758                        )
    683759{
    684    dprintf(("RegNotifyChangeKeyValue() NIY\n"));
     760   dprintf(("ADVAPI32: RegNotifyChangeKeyValue() NIY\n"));
    685761   return FALSE;
    686762}
Note: See TracChangeset for help on using the changeset viewer.