Ignore:
Timestamp:
Dec 20, 1999, 11:12:06 AM (26 years ago)
Author:
sandervl
Message:

Event log changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/advapi32/ADVAPI32.CPP

    r2143 r2152  
    1 /* $Id: ADVAPI32.CPP,v 1.10 1999-12-19 19:53:36 sandervl Exp $ */
     1/* $Id: ADVAPI32.CPP,v 1.11 1999-12-20 10:12:04 sandervl Exp $ */
    22
    33/*
    … …  
    3030#include "unicode.h"
    3131#include "winreg.h"
     32#include <heapstring.h>
    3233
    3334ODINDEBUGCHANNEL(ADVAPI32-ADVAPI32)
    … …  
    112113//******************************************************************************
    113114
    114 
    115 
    116 BOOL WIN32API ReportEventA(     /*PLF Sat  98-03-07 00:36:43*/
    117      HANDLE     hEventLog,
    118      WORD       wType,
    119      WORD       wCategory,
    120      DWORD      dwEventID,
    121      PSID       lpUserSid,
    122      WORD       wNumStrings,
    123      DWORD      dwDataSize,
    124      LPCSTR   *lpStrings,
    125      LPVOID     lpRawData
    126     )
    127 {
    128     dprintf(("ReportEventA(): NIY\n"));
    129     return TRUE;
    130 }
    131 
    132 
    133 BOOL WIN32API ReportEventW(     /*PLF Sat  98-03-07 00:36:43*/
    134      HANDLE     hEventLog,
    135      WORD       wType,
    136      WORD       wCategory,
    137      DWORD      dwEventID,
    138      PSID       lpUserSid,
    139      WORD       wNumStrings,
    140      DWORD      dwDataSize,
    141      LPCWSTR   *lpStrings,
    142      LPVOID     lpRawData
    143     )
    144 {
    145     dprintf(("ReportEventW(): NIY\n"));
    146     return TRUE;
    147 }
    148 
    149 
    150 /*PLF Sat  98-03-07 02:59:20*/
    151 HANDLE WIN32API RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName)
    152 {
    153     dprintf(("ADVAPI32: RegisterEventSourceA() NIY\n"));
    154     return FALSE;
    155 }
    156 
    157 /*PLF Sat  98-03-07 02:59:20*/
    158 HANDLE WIN32API RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName)
    159 {
    160     dprintf(("ADVAPI32: RegisterEventSourceW() NIY\n"));
    161     return FALSE;
    162 }
    163 
    164 
    165 /*PLF Sat  98-03-07 02:59:20*/
    166 BOOL WIN32API DeregisterEventSource(HANDLE hEventLog)
    167 {
    168     dprintf(("DeregisterEventSource() NIY\n"));
    169     return FALSE;
    170 }
    171115
    172116
    … …  
    582526  return (TRUE); /* grant all access */
    583527}
    584 
    585 
    586 /*****************************************************************************
    587  * Name      : BackupEventLogA
    588  * Purpose   : The BackupEventLog function saves the specified event log to a
    589  *             backup file. The function does not clear the event log.
    590  * Parameters: HANDLE  hEventLog        handle to event log
    591  *             LPCSTR lpBackupFileName  name of backup file
    592  * Variables :
    593  * Result    :
    594  * Remark    :
    595  * Status    : UNTESTED STUB
    596  *
    597  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    598  *****************************************************************************/
    599 
    600 BOOL WIN32API BackupEventLogA(HANDLE  hEventLog,
    601                                  LPCSTR lpBackupFileName)
    602 {
    603   dprintf(("ADVAPI32: BackupEventLogA(%08xh,%s) not implemented.\n",
    604            hEventLog,
    605            lpBackupFileName));
    606 
    607   return (FALSE); /* signal failure */
    608 }
    609 
    610 
    611 /*****************************************************************************
    612  * Name      : BackupEventLogW
    613  * Purpose   : The BackupEventLog function saves the specified event log to a
    614  *             backup file. The function does not clear the event log.
    615  * Parameters: HANDLE  hEventLog        handle to event log
    616  *             LPCWSTR lpBackupFileName  name of backup file
    617  * Variables :
    618  * Result    :
    619  * Remark    :
    620  * Status    : UNTESTED STUB
    621  *
    622  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    623  *****************************************************************************/
    624 
    625 BOOL WIN32API BackupEventLogW(HANDLE  hEventLog,
    626                                  LPCWSTR lpBackupFileName)
    627 {
    628   dprintf(("ADVAPI32: BackupEventLogW() not implemented.\n",
    629            hEventLog,
    630            lpBackupFileName));
    631 
    632   return (FALSE); /* signal failure */
    633 }
    634 
    635 
    636 /*****************************************************************************
    637  * Name      : ClearEventLogA
    638  * Purpose   : The ClearEventLog function clears the specified event log, and
    639  *             optionally saves the current copy of the logfile to a backup file.
    640  * Parameters: HANDLE  hEventLog         handle to event log
    641  *             LPCSTR lpBackupFileName  name of backup file
    642  * Variables :
    643  * Result    :
    644  * Remark    :
    645  * Status    : UNTESTED STUB
    646  *
    647  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    648  *****************************************************************************/
    649 
    650 BOOL WIN32API ClearEventLogA(HANDLE  hEventLog,
    651                                 LPCSTR lpBackupFileName)
    652 {
    653   dprintf(("ADVAPI32: ClearEventLogA(%08xh,%s) not implemented.\n",
    654            hEventLog,
    655            lpBackupFileName));
    656 
    657   return (FALSE); /* signal failure */
    658 }
    659 
    660 
    661 /*****************************************************************************
    662  * Name      : ClearEventLogW
    663  * Purpose   : The ClearEventLog function clears the specified event log, and
    664  *             optionally saves the current copy of the logfile to a backup file.
    665  * Parameters: HANDLE  hEventLog         handle to event log
    666  *             LPCSTR lpBackupFileName  name of backup file
    667  * Variables :
    668  * Result    :
    669  * Remark    :
    670  * Status    : UNTESTED STUB
    671  *
    672  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    673  *****************************************************************************/
    674 
    675 BOOL WIN32API ClearEventLogW(HANDLE  hEventLog,
    676                                 LPCWSTR lpBackupFileName)
    677 {
    678   dprintf(("ADVAPI32: ClearEventLogW(%08xh,%s) not implemented.\n",
    679            hEventLog,
    680            lpBackupFileName));
    681 
    682   return (FALSE); /* signal failure */
    683 }
    684 
    685 
    686 /*****************************************************************************
    687  * Name      : CloseEventLog
    688  * Purpose   : The CloseEventLog function closes the specified event log.
    689  * Parameters: HANDLE  hEventLog  handle to event log
    690  * Variables :
    691  * Result    :
    692  * Remark    :
    693  * Status    : UNTESTED STUB
    694  *
    695  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    696  *****************************************************************************/
    697 
    698 BOOL WIN32API CloseEventLog(HANDLE hEventLog)
    699 {
    700   dprintf(("ADVAPI32: CloseEventLog(%08xh) not implemented.\n",
    701            hEventLog));
    702 
    703   return (FALSE); /* signal failure */
    704 }
    705 
    706 
    707 
    708 
    709528
    710529/*****************************************************************************
    … …  
    1057876
    1058877
    1059 /*****************************************************************************
    1060  * Name      : GetNumberOfEventLogRecords
    1061  * Purpose   : The GetNumberOfEventLogRecords function retrieves the number of
    1062  *             records in the specified event log.
    1063  * Parameters: HANDLE  hEventLog        handle to event log
    1064  *             LPDWORD  NumberOfRecords  buffer for number of records
    1065  * Variables :
    1066  * Result    :
    1067  * Remark    :
    1068  * Status    : UNTESTED STUB
    1069  *
    1070  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1071  *****************************************************************************/
    1072 
    1073 BOOL WIN32API GetNumberOfEventLogRecords(HANDLE hEventLog,
    1074                                             LPDWORD NumberOfRecords)
    1075 {
    1076   dprintf(("ADVAPI32: GetNumberOfEventLogRecords(%08xh,%08xh) not implemented.\n",
    1077            hEventLog,
    1078            NumberOfRecords));
    1079 
    1080   return (FALSE); /* signal failure */
    1081 }
    1082 
    1083 
    1084 /*****************************************************************************
    1085  * Name      : GetOldestEventLogRecord
    1086  * Purpose   : The GetOldestEventLogRecord function retrieves the absolute
    1087  *             record number of the oldest record in the specified event log.
    1088  * Parameters: HANDLE  hEventLog     handle to event log
    1089  *             LPDWORD  OldestRecord  buffer for number of oldest record
    1090  * Variables :
    1091  * Result    :
    1092  * Remark    :
    1093  * Status    : UNTESTED STUB
    1094  *
    1095  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1096  *****************************************************************************/
    1097 
    1098 BOOL WIN32API GetOldestEventLogRecord(HANDLE hEventLog,
    1099                                          LPDWORD OldestRecord)
    1100 {
    1101   dprintf(("ADVAPI32: GetOldestEventLogRecord(%08xh,%08xh) not implemented.\n",
    1102            hEventLog,
    1103            OldestRecord));
    1104 
    1105   return (FALSE); /* signal failure */
    1106 }
    1107 
    1108878
    1109879/*****************************************************************************
    … …  
    17221492
    17231493
    1724 
    1725 /*****************************************************************************
    1726  * Name      : NotifyChangeEventLog
    1727  * Purpose   : The NotifyChangeEventLog function lets an application receive
    1728  *             notification when an event is written to the event log file
    1729  *             specified by hEventLog. When the event is written to the event
    1730  *             log file, the function causes the event object specified by
    1731  *             hEvent to become signaled.
    1732  * Parameters: HANDLE  hEventLog  special default locale value to be converted
    1733  *             HANDLE  hEvent     special default locale value to be converted
    1734  * Variables :
    1735  * Result    :
    1736  * Remark    :
    1737  * Status    : UNTESTED STUB
    1738  *
    1739  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1740  *****************************************************************************/
    1741 
    1742 BOOL WIN32API NotifyChangeEventLog(HANDLE  hEventLog,
    1743                                       HANDLE  hEvent)
    1744 {
    1745   dprintf(("ADVAPI32: NotifyChangeEventLog(%08xh,%08xh) not implemented.\n",
    1746            hEventLog,
    1747            hEvent));
    1748 
    1749   return (FALSE); /* signal failure */
    1750 }
    17511494
    17521495
    … …  
    20011744}
    20021745
    2003 
    2004 /*****************************************************************************
    2005  * Name      : OpenBackupEventLogA
    2006  * Purpose   : The OpenBackupEventLog function opens a handle of a backup event
    2007  *             log. This handle can be used with the BackupEventLog function.
    2008  * Parameters: LPCSTR  lpszUNCServerName  backup file server name
    2009  *             LPCSTR  lpszFileName       backup filename
    2010  * Variables :
    2011  * Result    :
    2012  * Remark    :
    2013  * Status    : UNTESTED STUB
    2014  *
    2015  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2016  *****************************************************************************/
    2017 
    2018 HANDLE WIN32API OpenBackupEventLogA(LPCSTR  lpszUNCServerName,
    2019                                        LPCSTR  lpszFileName)
    2020 {
    2021   dprintf(("ADVAPI32: OpenBackupEventLogA(%s,%s) not implemented.\n",
    2022            lpszUNCServerName,
    2023            lpszFileName));
    2024 
    2025   return (NULL); /* signal failure */
    2026 }
    2027 
    2028 
    2029 /*****************************************************************************
    2030  * Name      : OpenBackupEventLogW
    2031  * Purpose   : The OpenBackupEventLog function opens a handle of a backup event
    2032  *             log. This handle can be used with the BackupEventLog function.
    2033  * Parameters: LPCWSTR  lpszUNCServerName  backup file server name
    2034  *             LPCWSTR  lpszFileName       backup filename
    2035  * Variables :
    2036  * Result    :
    2037  * Remark    :
    2038  * Status    : UNTESTED STUB
    2039  *
    2040  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2041  *****************************************************************************/
    2042 
    2043 HANDLE WIN32API OpenBackupEventLogW(LPCWSTR  lpszUNCServerName,
    2044                                        LPCWSTR  lpszFileName)
    2045 {
    2046   dprintf(("ADVAPI32: OpenBackupEventLogW(%s,%s) not implemented.\n",
    2047            lpszUNCServerName,
    2048            lpszFileName));
    2049 
    2050   return (NULL); /* signal failure */
    2051 }
    2052 
    2053 
    2054 /*****************************************************************************
    2055  * Name      : OpenEventLogA
    2056  * Purpose   : The OpenEventLog function opens a handle of an event log.
    2057  * Parameters: LPCSTR  lpszUNCServerName
    2058  *             LPCSTR  lpszSourceName
    2059  * Variables :
    2060  * Result    :
    2061  * Remark    :
    2062  * Status    : UNTESTED STUB
    2063  *
    2064  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2065  *****************************************************************************/
    2066 
    2067 HANDLE WIN32API OpenEventLogA(LPCSTR  lpszUNCServerName,
    2068                                  LPCSTR  lpszSourceName)
    2069 {
    2070   dprintf(("ADVAPI32: OpenEventLogA(%s,%s) not implemented.\n",
    2071            lpszUNCServerName,
    2072            lpszSourceName));
    2073 
    2074   return (NULL); /* signal failure */
    2075 }
    2076 
    2077 
    2078 /*****************************************************************************
    2079  * Name      : OpenEventLogW
    2080  * Purpose   : The OpenEventLog function opens a handle of an event log.
    2081  * Parameters: LPCWSTR  lpszUNCServerName
    2082  *             LPCWSTR  lpszSourceName
    2083  * Variables :
    2084  * Result    :
    2085  * Remark    :
    2086  * Status    : UNTESTED STUB
    2087  *
    2088  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2089  *****************************************************************************/
    2090 
    2091 HANDLE WIN32API OpenEventLogW(LPCWSTR  lpszUNCServerName,
    2092                                  LPCWSTR  lpszSourceName)
    2093 {
    2094   dprintf(("ADVAPI32: OpenEventLogW(%s,%s) not implemented.\n",
    2095            lpszUNCServerName,
    2096            lpszSourceName));
    2097 
    2098   return (NULL); /* signal failure */
    2099 }
    2100 
    2101 
    2102 
    21031746/*****************************************************************************
    21041747 * Name      : PrivilegeCheck
    … …  
    22011844
    22021845
    2203 
    2204 
    2205 /*****************************************************************************
    2206  * Name      : ReadEventLogW
    2207  * Purpose   : The ReadEventLog function reads a whole number of entries from
    2208  *             the specified event log. The function can be used to read log
    2209  *             entries in forward or reverse chronological order.
    2210  * Parameters: HANDLE hEventLog                 handle of event log
    2211  *             DWORD  dwReadFlags               specifies how to read log
    2212  *             DWORD  dwRecordOffset            number of first record
    2213  *             LPVOID lpBuffer                  address of buffer for read data
    2214  *             DWORD  nNumberOfBytesToRead      number of bytes to read
    2215  *             DWORD  *pnBytesRea               number of bytes read
    2216  *             DWORD  *pnMinNumberOfBytesNeeded number of bytes required for next record
    2217  * Variables :
    2218  * Result    :
    2219  * Remark    :
    2220  * Status    : UNTESTED STUB
    2221  *
    2222  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2223  *****************************************************************************/
    2224 
    2225 BOOL WIN32API ReadEventLogW(HANDLE hEventLog,
    2226                                DWORD  dwReadFlags,
    2227                                DWORD  dwRecordOffset,
    2228                                LPVOID lpBuffer,
    2229                                DWORD  nNumberOfBytesToRead,
    2230                                DWORD  *pnBytesRead,
    2231                                DWORD  *pnMinNumberOfBytesNeeded)
    2232 {
    2233   dprintf(("ADVAPI32: ReadEventLogW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    2234            hEventLog,
    2235            dwReadFlags,
    2236            dwRecordOffset,
    2237            lpBuffer,
    2238            nNumberOfBytesToRead,
    2239            pnBytesRead,
    2240            pnMinNumberOfBytesNeeded));
    2241 
    2242   return (FALSE); /* signal failure */
    2243 }
    2244 
    2245 
    2246 /*****************************************************************************
    2247  * Name      : ReadEventLogA
    2248  * Purpose   : The ReadEventLog function reads a whole number of entries from
    2249  *             the specified event log. The function can be used to read log
    2250  *             entries in forward or reverse chronological order.
    2251  * Parameters: HANDLE hEventLog                 handle of event log
    2252  *             DWORD  dwReadFlags               specifies how to read log
    2253  *             DWORD  dwRecordOffset            number of first record
    2254  *             LPVOID lpBuffer                  address of buffer for read data
    2255  *             DWORD  nNumberOfBytesToRead      number of bytes to read
    2256  *             DWORD  *pnBytesRea               number of bytes read
    2257  *             DWORD  *pnMinNumberOfBytesNeeded number of bytes required for next record
    2258  * Variables :
    2259  * Result    :
    2260  * Remark    :
    2261  * Status    : UNTESTED STUB
    2262  *
    2263  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    2264  *****************************************************************************/
    2265 
    2266 BOOL WIN32API ReadEventLogA(HANDLE hEventLog,
    2267                                DWORD  dwReadFlags,
    2268                                DWORD  dwRecordOffset,
    2269                                LPVOID lpBuffer,
    2270                                DWORD  nNumberOfBytesToRead,
    2271                                DWORD  *pnBytesRead,
    2272                                DWORD  *pnMinNumberOfBytesNeeded)
    2273 {
    2274   dprintf(("ADVAPI32: ReadEventLogA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    2275            hEventLog,
    2276            dwReadFlags,
    2277            dwRecordOffset,
    2278            lpBuffer,
    2279            nNumberOfBytesToRead,
    2280            pnBytesRead,
    2281            pnMinNumberOfBytesNeeded));
    2282 
    2283   return (FALSE); /* signal failure */
    2284 }
    22851846
    22861847
Note: See TracChangeset for help on using the changeset viewer.