![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to system.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon|
Return to system.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 root 1: //
2: // Foreign computer support needs more work (a-robw)
3: //
4: #ifdef FOREIGN_COMPUTER_SUPPORT
5: #undef FOREIGN_COMPUTER_SUPPORT
6: #endif
7:
8: #include "perfmon.h"
9: #include "system.h" // external declarations for this file
10:
11: #include "perfdata.h"
12: #include "perfmops.h"
13: #include "playback.h" // for PlayingBackLog
14: #include "pmemory.h"
15: #include "utils.h" // for strsame, et al
16: #include "sizes.h"
17:
18: DWORD
19: SystemCount(
20: PPERFSYSTEM pSystemFirst
21: )
22: {
23: PPERFSYSTEM pSystem ;
24: DWORD iNumSystems ;
25:
26: iNumSystems = 0 ;
27:
28: for (pSystem = pSystemFirst ;
29: pSystem ;
30: pSystem = pSystem->pSystemNext) {
31: iNumSystems++ ;
32: }
33:
34: return iNumSystems ;
35: }
36:
37: PPERFSYSTEM
38: SystemCreate (
39: LPCTSTR lpszSystemName
40: )
41: {
42: PPERFSYSTEM pSystem ;
43: PPERFDATA pLocalPerfData;
44: DWORD Status ;
45: DWORD dwMemSize;
46: TCHAR GlobalValueBuffer[] = L"Global" ;
47: TCHAR ForeignValueBuffer[8+MAX_COMPUTERNAME_LENGTH+1] =
48: L"Foreign " ;
49:
50: // attempt to allocate system data structure
51:
52: pSystem = MemoryAllocate (sizeof (PERFSYSTEM)) ;
53: if (!pSystem) {
54: SetLastError (ERROR_OUTOFMEMORY);
55: return (NULL) ;
56: }
57:
58: // initialize name and help table pointers
59:
60: pSystem->CounterInfo.pNextTable = NULL;
61: pSystem->CounterInfo.dwLangId = 0;
62: pSystem->CounterInfo.dwLastId = 0;
63: pSystem->CounterInfo.TextString = NULL;
64:
65: lstrcpy (pSystem->sysName, lpszSystemName) ;
66:
67: // try to open key to registry, error code is in GetLastError()
68:
69: pSystem->sysDataKey = OpenSystemPerfData(lpszSystemName);
70:
71: // if a Null Key was returned then:
72: // a) there's no such computer
73: // b) the system is a foreign computer
74: //
75: // before giving up, then see if it's a foreign computer
76:
77: if (!pSystem->sysDataKey) {
78:
79: // build foreign computer string
80:
81: lstrcat(ForeignValueBuffer, lpszSystemName) ;
82:
83: // assign System value name pointer to the local variable for trial
84:
85: pSystem->lpszValue = ForeignValueBuffer;
86:
87: // try to get data from the computer to see if it's for real
88: // otherwise, give up and return NULL
89:
90: pLocalPerfData = MemoryAllocate (STARTING_SYSINFO_SIZE);
91: if (pLocalPerfData == NULL) { // no mem so give up
92: SetLastError (ERROR_OUTOFMEMORY);
93: SystemFree (pSystem, TRUE);
94: return (NULL);
95: } else {
96: pSystem->sysDataKey = HKEY_PERFORMANCE_DATA; // local machine
97:
98: dwMemSize = STARTING_SYSINFO_SIZE;
99: Status = GetSystemPerfData (
100: pSystem->sysDataKey,
101: pSystem->lpszValue,
102: pLocalPerfData,
103: &dwMemSize);
104:
105: // success means a valid buffer came back
106: // more data means someone tried (so it's probably good (?)
107:
108: if (!((Status == ERROR_MORE_DATA) || (Status == ERROR_SUCCESS)) ||
109: !((pLocalPerfData->Signature[0] == (WCHAR)'P') &&
110: (pLocalPerfData->Signature[1] == (WCHAR)'E') &&
111: (pLocalPerfData->Signature[2] == (WCHAR)'R') &&
112: (pLocalPerfData->Signature[3] == (WCHAR)'F'))) {
113: SetLastError (ERROR_BAD_NET_NAME); // unable to find name
114: SystemFree (pSystem, TRUE);
115: MemoryFree (pLocalPerfData); // don't really need anything from it
116: return NULL;
117: }
118:
119: MemoryFree (pLocalPerfData); // don't really need anything from it
120:
121: // ok, so we've established that a foreign data provider
122: // exists, now to finish the initialization.
123:
124: // change system name in structure to get counter names
125:
126: lstrcpy (pSystem->sysName, LocalComputerName);
127:
128: Status = GetSystemNames(pSystem); // get counter names & explain text
129: if (Status != ERROR_SUCCESS) {
130: // unable to get names so bail out
131: SetLastError (Status);
132: SystemFree (pSystem, TRUE);
133: return (NULL) ;
134: }
135:
136: // restore computer name for displays, etc.
137:
138: lstrcpy (pSystem->sysName, lpszSystemName);
139:
140: // allocate value string buffer
141: pSystem->lpszValue = MemoryAllocate (TEMP_BUF_LEN*sizeof(WCHAR));
142: if (!pSystem->lpszValue) {
143: // unable to allocate memory
144: SetLastError (ERROR_OUTOFMEMORY);
145: SystemFree (pSystem, TRUE);
146: return (NULL) ;
147: } else {
148: lstrcpy (pSystem->lpszValue, ForeignValueBuffer);
149: }
150: }
151: } else {
152: // if here, then a connection to the system's registry was established
153: // so continue with the system data structure initialization
154:
155: // get counter names & explain text from local computer
156:
157: Status = GetSystemNames(pSystem);
158: if (Status != ERROR_SUCCESS) {
159: // unable to get names so bail out
160: SetLastError (Status);
161: SystemFree (pSystem, TRUE);
162: return (NULL) ;
163: }
164:
165: // allocate value string buffer
166: pSystem->lpszValue = MemoryAllocate(TEMP_BUF_LEN*sizeof(WCHAR));
167:
168: if (!pSystem->lpszValue) {
169: // unable to allocate memory
170: SetLastError (ERROR_OUTOFMEMORY);
171: SystemFree (pSystem, TRUE);
172: return (NULL) ;
173: } else {
174: SetSystemValueNameToGlobal (pSystem);
175: }
176: }
177:
178: // initialize remaining system pointers
179:
180: pSystem->pSystemNext = NULL ;
181: pSystem->FailureTime = 0;
182:
183: SetLastError (ERROR_SUCCESS);
184:
185: return (pSystem) ;
186: } // SystemCreate
187:
188: PPERFSYSTEM
189: SystemGet (
190: PPERFSYSTEM pSystemFirst,
191: LPCTSTR lpszSystemName
192: )
193: {
194: PPERFSYSTEM pSystem ;
195:
196: if (!pSystemFirst) {
197: return (NULL) ;
198: }
199:
200: for (pSystem = pSystemFirst ;
201: pSystem ;
202: pSystem = pSystem->pSystemNext) {
203: if (strsamei (pSystem->sysName, lpszSystemName)) {
204: return (pSystem) ;
205: }
206: } // for
207:
208: return (NULL) ;
209: }
210:
211: PPERFSYSTEM
212: SystemAdd (
213: PPPERFSYSTEM ppSystemFirst,
214: LPCTSTR lpszSystemName
215: )
216: {
217: PPERFSYSTEM pSystem ;
218: PPERFSYSTEM pSystemPrev ;
219:
220:
221: if (!*ppSystemFirst) {
222: *ppSystemFirst = SystemCreate (lpszSystemName) ;
223: return (*ppSystemFirst) ;
224: }
225:
226: for (pSystem = *ppSystemFirst ;
227: pSystem ;
228: pSystem = pSystem->pSystemNext) {
229: pSystemPrev = pSystem ;
230: if (strsamei (pSystem->sysName, lpszSystemName)) {
231: return (pSystem) ;
232: }
233: } // for
234:
235: pSystemPrev->pSystemNext = SystemCreate (lpszSystemName) ;
236: return (pSystemPrev->pSystemNext) ;
237: }
238:
239: void
240: SystemFree (
241: PPERFSYSTEM pSystem,
242: BOOL bDeleteTheSystem
243: )
244: { // SystemFree
245:
246: PCOUNTERTEXT pCounter, pNextCounter;
247:
248: if (!pSystem) {
249: // can't proceed
250: return ;
251: }
252:
253: if (pSystem->sysDataKey && pSystem->sysDataKey != HKEY_PERFORMANCE_DATA) {
254: // close the remote computer key
255: RegCloseKey (pSystem->sysDataKey);
256: pSystem->sysDataKey = 0 ;
257: }
258:
259: for (pCounter = pSystem->CounterInfo.pNextTable, pNextCounter = NULL;
260: pCounter;
261: pCounter = pNextCounter) {
262: pNextCounter = pCounter->pNextTable;
263: MemoryFree (pCounter);
264: }
265: pSystem->CounterInfo.pNextTable = NULL ;
266:
267: if (pSystem->CounterInfo.TextString) {
268: MemoryFree (pSystem->CounterInfo.TextString);
269: pSystem->CounterInfo.TextString = NULL ;
270: }
271:
272: if (pSystem->CounterInfo.HelpTextString) {
273: MemoryFree (pSystem->CounterInfo.HelpTextString);
274: pSystem->CounterInfo.HelpTextString = NULL ;
275: }
276: pSystem->CounterInfo.dwLastId = 0 ;
277: pSystem->CounterInfo.dwHelpSize = 0 ;
278: pSystem->CounterInfo.dwCounterSize = 0 ;
279:
280: if (bDeleteTheSystem) {
281: if (pSystem->lpszValue) {
282: MemoryFree (pSystem->lpszValue);
283: pSystem->lpszValue = NULL ;
284: }
285: MemoryFree (pSystem) ;
286: }
287: }
288:
289: void
290: DeleteUnusedSystems (
291: PPPERFSYSTEM ppSystemFirst ,
292: int iNoUseSystems
293: )
294: {
295: PPERFSYSTEM pPrevSys, pCurrentSys, pNextSys ;
296:
297: // delete all the marked system from the list header until
298: // we hit one that is not marked
299: while ((*ppSystemFirst)->bSystemNoLongerNeeded) {
300: // delect from the list header
301: pCurrentSys = *ppSystemFirst ;
302: *ppSystemFirst = pCurrentSys->pSystemNext ;
303: SystemFree (pCurrentSys, TRUE) ;
304: iNoUseSystems-- ;
305: if (iNoUseSystems <= 0 || !(*ppSystemFirst)) {
306: // done
307: break ;
308: }
309: }
310:
311: if (iNoUseSystems <= 0 || !(*ppSystemFirst)) {
312: return ;
313: }
314:
315: // now walk the list and delete each marked system
316: for (pPrevSys = *ppSystemFirst, pCurrentSys = pPrevSys->pSystemNext ;
317: pCurrentSys && iNoUseSystems > 0 ;
318: pCurrentSys = pNextSys, iNoUseSystems--) {
319:
320: if (pCurrentSys->bSystemNoLongerNeeded) {
321: // the current system is marked, updated the list and free
322: // this system. No need to change pPrevSys here
323: pNextSys = pPrevSys->pSystemNext = pCurrentSys->pSystemNext ;
324: SystemFree (pCurrentSys, TRUE) ;
325: } else {
326: // pCurrentSys is OK, update the 2 list pointers and
327: // carry on looping
328: pPrevSys = pCurrentSys ;
329: pNextSys = pCurrentSys->pSystemNext ;
330: }
331: }
332: }
333:
334: void
335: FreeSystems (
336: PPERFSYSTEM pSystemFirst
337: )
338: {
339: PPERFSYSTEM pSystem, pSystemNext ;
340:
341:
342: for (pSystem = pSystemFirst;
343: pSystem;
344: pSystem = pSystemNext) {
345: pSystemNext = pSystem->pSystemNext ;
346: SystemFree (pSystem, TRUE) ;
347: }
348: } // FreeSystems
349:
350: PPERFSYSTEM
351: GetComputer (
352: HDLG hDlg,
353: WORD wControlID,
354: BOOL bWarn,
355: PPERFDATA *ppPerfData,
356: PPERFSYSTEM *ppSystemFirst
357: )
358: /*
359: Effect: Attempt to set the current computer to the one in the
360: hWndComputers dialog edit box. If this computer system
361: can be found, load the objects, etc. for the computer
362: and set pSystem and ppPerfdata to the values for this
363: system.
364: */
365: { // GetComputer
366: TCHAR szComputer [MAX_SYSTEM_NAME_LENGTH + 1] ;
367: PPERFSYSTEM pSystem;
368: TCHAR tempBuffer [LongTextLen] ;
369: DWORD dwBufferSize ;
370: LPTSTR pBuffer = NULL ;
371:
372: DialogText (hDlg, wControlID, szComputer) ;
373:
374: // If necessary, add the system to the lists for this view.
375: pSystem = SystemGet (*ppSystemFirst, szComputer) ;
376: if (!pSystem) {
377: pSystem = SystemAdd (ppSystemFirst, szComputer) ;
378: }
379:
380: if (!pSystem && bWarn) {
381: DialogSetString (hDlg, wControlID, LocalComputerName) ;
382:
383: // Note: this will succeed since the local computer is always
384: // available
385: EditSetModified (GetDlgItem(hDlg, wControlID), FALSE) ;
386:
387: pSystem = SystemGet (*ppSystemFirst, LocalComputerName) ;
388: if (!pSystem) {
389: pSystem = SystemAdd (ppSystemFirst, LocalComputerName) ;
390: }
391:
392: // MessageBoxResource (hDlg, IDS_COMPUTERNOTFOUND, IDS_APPNAME, MB_OK) ;
393: DlgErrorBox (hDlg, ERR_COMPUTERNOTFOUND) ;
394:
395: SetFocus (DialogControl(hDlg, wControlID)) ;
396: }
397:
398: if (pSystem) {
399: if (PlayingBackLog ()) {
400: *ppPerfData =
401: LogDataFromPosition (pSystem, &(PlaybackLog.StartIndexPos)) ;
402: } else {
403:
404: if (pSystem->lpszValue) {
405: // save the previous lpszValue string before
406: // SetSystemValueNameToGlobal screw it up
407: dwBufferSize = MemorySize (pSystem->lpszValue) ;
408: if (dwBufferSize <= sizeof(tempBuffer)) {
409: pBuffer = tempBuffer ;
410: } else {
411: pBuffer = MemoryAllocate (dwBufferSize) ;
412: }
413: memcpy (pBuffer, pSystem->lpszValue, dwBufferSize) ;
414: }
415:
416: SetSystemValueNameToGlobal (pSystem);
417: UpdateSystemData (pSystem, ppPerfData) ;
418:
419: if (pSystem->lpszValue) {
420: // retore the previous lpszValue string
421: memcpy (pSystem->lpszValue, pBuffer, dwBufferSize) ;
422: if (pBuffer != tempBuffer) {
423: MemoryFree (pBuffer) ;
424: }
425: }
426: }
427: }
428: return (pSystem) ;
429:
430: } // GetComputer
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.