![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to winnet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / winnet|
Return to winnet.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / winnet |
1.1 root 1: /****************************************************************************\
2: *
3: * MODULE: winnet.c
4: *
5: * PURPOSE: Demonstrate the WNetXXX Win32 api(s) (10 of the 11 - all but
6: * WNetConnectionDialog are demonstrated)
7: *
8: * TO RUN: Ensure 1 or more network disk shares can be used by the
9: * machine/user-id you run winnet on, and that these 1 or more
10: * network disk shares aren't already connected to the
11: * machine/user-id you run winnet on. These net shares must
12: * not require a password
13: *
14: * IMPORTANT: Ensure W: is not in use when you type "WINNET"
15: *
16: * OVERALL APPROACH: Find a connectable disk resource on the network, connect
17: * to it, and disconnect
18: *
19: * The first time you run this sample, it's probably best to
20: * ensure there's a shared disk directory accessable to the
21: * machine on which you run this program, so you can see the
22: * success paths in this code exercised first. Ensure this
23: * shared disk is NOT already connected
24: *
25: * We recursively open containers returned by the EnumResources
26: * calls (recursively using OpenEnum), but will bail out of the
27: * recursion without fully exploring all containers and enum's
28: * if we hit the arbitrary limit placed on how many connectable
29: * disk resources we enter into our list. Since there may
30: * possibly be many more enumerable resources on a net than
31: * there are connectable disk resources, we also place another
32: * arbitrary limit on the total number of resources we'll
33: * enumerate
34: *
35: * Both limits can easily be removed or raised by anyone working
36: * with this sample code
37: *
38: * After the container exploration is completed, we walk down the
39: * list of connectable disk resources, arbitrarily picking one
40: * to connect to and then disconnect from
41: *
42: * FUNCTIONS: Open_Do_Close_1_Enum
43: *
44: * Called by main with a NULL container to start the enumeration
45: * of the top-level container. Called recursively from
46: * EnumResources
47: *
48: * OpenEnum
49: *
50: * Returns an enumeration handle by opening a container
51: *
52: * EnumResources
53: *
54: * Enumerates the connectable resources and containers, given an
55: * enumeration handle. Recusively calls Open_Do_Close_1_Enum
56: *
57: * AddGetGetCancel
58: * AddGetGetCancel2
59: *
60: * Identical logic in both functions adds a connection, gets the
61: * user for the connection, gets information about the
62: * connection and then cancels the connection. The difference
63: * is that AddGetGetCancel2 uses the new Win32 forms of the Add
64: * and Cancel api's
65: *
66: * PrintAPIError
67: *
68: * Simple routine to print error message info
69: *
70: * GLOBAL VARS:
71: * ConnectablesList
72: *
73: * List of disk resources we can connect to. Filled in while
74: * enumeration resources, walked after all enumeration is
75: * complete
76: *
77: * dwResourcesEnumedSoFar
78: *
79: * Counter of resources enumerated so far, includes count of both
80: * disk resources and containers enumerated. If many
81: * containers are enumerated compared to disk resources, this
82: * counter will limit the search. If many disk resources are
83: * found compared to containers, the size of ConnectablesList
84: * will limit the search
85: *
86: * dwDiskListI
87: *
88: * Index into ConnectablesList. At all times, except when adding
89: * a list entry, dwDiskListI is 1 greater than the number of
90: * entries we have entered into ConnectablesList
91: *
92: \****************************************************************************/
93:
94:
95: /****************************************************************************\
96: * INCLUDES, DEFINES, TYPEDEFS
97: \****************************************************************************/
98: #define STRICT
99: #include <windows.h>
100: #include <stdio.h>
101: #include <string.h>
102: #include <stdlib.h>
103: #include <winnetwk.h>
104:
105: #define PERR(api) printf("%s: Error %d from %s on line %d\n", \
106: __FILE__, GetLastError(), api, __LINE__);
107: #define PMSG(msg) printf("%s line %d: %s\n", \
108: __FILE__, __LINE__, msg);
109:
110: #define PrintAppStyleAPIError(ApiTxt,MsgTxt) { \
111: PrintAPIError( #ApiTxt , #MsgTxt , __LINE__ , __FILE__ ); \
112: }
113:
114:
115: /****************************************************************************\
116: *
117: * These next two search limits are completely tunable. On one net
118: * MAX_NUMBER_OF_RESOURCES_TO_ENUM had to be 2200 to see 3 or 4 sharable disk
119: * resources. This could vary widely depending on the number of servers on
120: * the net that have no shares up
121: *
122: \****************************************************************************/
123:
124: #define MAX_NUMBER_OF_DISK_RESOURCES_TO_LIST 3
125: #define MAX_NUMBER_OF_RESOURCES_TO_ENUM 2200
126:
127: #define LOCAL_DEVICE_NAME "W:"
128: #define WHICH_TO_USE_FROM_LIST 0
129:
130: typedef struct _DISK_RESOURCES_CONNECTABLE
131: {
132: LPTSTR lpRemoteName;
133: LPTSTR lpComment;
134: LPTSTR lpProvider;
135: } DISK_RESOURCES_CONNECTABLE, *LPDISK_RESOURCES_CONNECTABLE;
136:
137: /****************************************************************************\
138: * GLOBAL VARIABLES
139: \****************************************************************************/
140:
141: DISK_RESOURCES_CONNECTABLE
142: ConnectablesList[MAX_NUMBER_OF_DISK_RESOURCES_TO_LIST];
143: DWORD dwResourcesEnumedSoFar = 0;
144: DWORD dwDiskListI = 0;
145:
146: /****************************************************************************\
147: * FUNCTION PROTOTYPES
148: \****************************************************************************/
149:
150: VOID Open_Do_Close_1_Enum(LPNETRESOURCE lpNetContainerToOpen);
151: HANDLE OpenEnum (LPNETRESOURCE lpNetContainerToOpen);
152: UINT EnumResources(HANDLE hNetEnum);
153: VOID AddGetGetCancel(VOID);
154: VOID AddGetGetCancel2(VOID);
155: VOID PrintAPIError(LPTSTR ApiTxt,
156: LPTSTR MsgTxt,
157: UINT Line,
158: LPTSTR File);
159:
160: /****************************************************************************\
161: *
162: * FUNCTION: Main
163: *
164: \****************************************************************************/
165:
166: UINT main(UINT argc, char *argv[])
167: {
168: UNREFERENCED_PARAMETER(argv[1]);
169:
170: if (argc > 1)
171: { printf("\nTo run type 'winnet', with no parameters\n");
172: printf("\n IMPORTANT: Ensure W: is not in use when you type WINNET\n");
173: return(1);
174: }
175:
176: /**************************************************************************\
177: *
178: * Pass NULL as container argument to get top level container. This call
179: * starts the recursive exploration of the top level network resource
180: * container
181: *
182: \**************************************************************************/
183:
184: Open_Do_Close_1_Enum(NULL);
185:
186: /**************************************************************************\
187: *
188: * We now have a list of connectable resources in our table, but some error
189: * conditions may have caused the list to be 0 length
190: *
191: \**************************************************************************/
192:
193: if (0<dwDiskListI)
194: { AddGetGetCancel();
195: AddGetGetCancel2();
196: }
197: else
198: { printf("\nError: enumerated 0 connectable disk resources!\n");
199: }
200:
201: /**************************************************************************\
202: *
203: * Free the list of connectable resources, zero length or not
204: *
205: \**************************************************************************/
206:
207: { DWORD i;
208: for (i=0; i<dwDiskListI; i++)
209: {
210: free(ConnectablesList[i].lpRemoteName);
211: free(ConnectablesList[i].lpComment );
212: free(ConnectablesList[i].lpProvider );
213: }
214: }
215:
216: return(0);
217: }
218:
219: /****************************************************************************\
220: *
221: * FUNCTION: Open_Do_Close_1_Enum
222: *
223: * COMMENTS: There's little reason this is in a separate function in this
224: * sample other than the code is used in two places, so putting it
225: * in a separate function saves repetition in the source code
226: *
227: \****************************************************************************/
228:
229: VOID Open_Do_Close_1_Enum(LPNETRESOURCE lpNetContainerToOpen)
230: {
231: HANDLE hNetEnum;
232:
233: hNetEnum = OpenEnum(lpNetContainerToOpen);
234:
235: if (!hNetEnum)
236: return;
237:
238: if (!EnumResources(hNetEnum))
239: return;
240:
241: if (NO_ERROR != WNetCloseEnum(hNetEnum))
242: { PERR("WNetCloseEnum");
243: return;
244: }
245: }
246:
247: /****************************************************************************\
248: *
249: * FUNCTION: OpenEnum
250: *
251: \****************************************************************************/
252:
253: HANDLE OpenEnum(LPNETRESOURCE lpNetContainerToOpen)
254: {
255: HANDLE hNetEnum;
256:
257: if (NO_ERROR != WNetOpenEnum(RESOURCE_GLOBALNET,
258: RESOURCETYPE_DISK,
259: (RESOURCEUSAGE_CONNECTABLE | RESOURCEUSAGE_CONTAINER),
260: lpNetContainerToOpen,
261: (LPHANDLE)&hNetEnum))
262: { if (GetLastError() != NO_ERROR)
263: { PrintAppStyleAPIError(WNetOpenEnum,"OpenEnum");
264: return(NULL);
265: }
266: }
267:
268: return(hNetEnum);
269: }
270:
271: /****************************************************************************\
272: *
273: * FUNCTION: EnumResources
274: *
275: \****************************************************************************/
276:
277: UINT EnumResources(HANDLE hNetEnum)
278: {
279: #define RESOURCE_BUF_ENTRIES 500
280: NETRESOURCE ResourceBuffer[RESOURCE_BUF_ENTRIES]; // about 13K for 500
281: DWORD dwSzResourceBuf;
282: DWORD dwEntriesToGet;
283:
284: /**************************************************************************\
285: *
286: * It's possible that not all entries will fit in a RESOURCE_BUF_ENTRIES slot
287: * buffer, so we call WNetEnumResource in a loop, asking for
288: * RESOURCE_BUF_ENTRIES at a time, and continuing to call WNetEnumResource
289: * until it returns no more entries
290: *
291: \**************************************************************************/
292:
293: for (;;)
294: {
295: dwSzResourceBuf = sizeof(ResourceBuffer);
296: dwEntriesToGet = RESOURCE_BUF_ENTRIES;
297:
298: printf("Getting %d entries\n",dwEntriesToGet);
299:
300: if (NO_ERROR != WNetEnumResource(hNetEnum,
301: (LPDWORD)&dwEntriesToGet,
302: (LPVOID)ResourceBuffer,
303: (LPDWORD)&dwSzResourceBuf))
304: { switch (GetLastError())
305: { case NO_ERROR :
306: // Drop out of the switch, walk the buffer
307: break;
308: case ERROR_NO_MORE_ITEMS :
309: // Return with 0 code because this only happens when we got
310: // RESOURCE_BUF_ENTRIES entries on the previous call to
311: // WNetEnumResource, and there were coincidentally exactly
312: // RESOURCE_BUF_ENTRIES entries total in the enum at the time of
313: // that previous call
314: return(0);
315: default :
316: PrintAppStyleAPIError(WNetEnumResource,"EnumResources");
317: return(1);
318: }
319: }
320:
321: /************************************************************************\
322: *
323: * Walk the returned buffer. Now dwEntriesToGet has been set by the api
324: * call to be the number of entries actually returned
325: *
326: \************************************************************************/
327:
328: {
329: DWORD i;
330:
331: printf("Got %d entries\n",dwEntriesToGet);
332:
333: for (i=0; i<dwEntriesToGet; i++)
334: {
335: printf("\nResourceBuffer[%d].dwScope = 0x%x \n",i,
336: ResourceBuffer[i].dwScope);
337: printf("ResourceBuffer[%d].dwType = 0x%x \n",i,
338: ResourceBuffer[i].dwType);
339: printf("ResourceBuffer[%d].dwUsage = 0x%x \n",i,
340: ResourceBuffer[i].dwUsage);
341: printf("ResourceBuffer[%d].lpLocalName = %s \n",i,
342: ResourceBuffer[i].lpLocalName);
343: printf("ResourceBuffer[%d].lpRemoteName = %s \n",i,
344: ResourceBuffer[i].lpRemoteName);
345: printf("ResourceBuffer[%d].lpComment = %s \n",i,
346: ResourceBuffer[i].lpComment);
347: printf("ResourceBuffer[%d].lpProvider = %s \n",i,
348: ResourceBuffer[i].lpProvider);
349:
350: dwResourcesEnumedSoFar += dwEntriesToGet;
351:
352: printf("dwResourcesEnumedSoFar = %d \n",dwResourcesEnumedSoFar);
353:
354: if (dwDiskListI >= MAX_NUMBER_OF_DISK_RESOURCES_TO_LIST)
355: return(0); // List full, stop enumerating
356:
357: switch (ResourceBuffer[i].dwUsage)
358: { case RESOURCEUSAGE_CONNECTABLE :
359:
360: ConnectablesList [dwDiskListI].lpRemoteName =
361: malloc(1+strlen(ResourceBuffer[i].lpRemoteName));
362: ConnectablesList [dwDiskListI].lpComment =
363: malloc(1+strlen(ResourceBuffer[i].lpComment ));
364: ConnectablesList [dwDiskListI].lpProvider =
365: malloc(1+strlen(ResourceBuffer[i].lpProvider ));
366:
367: if ((NULL == ConnectablesList[dwDiskListI].lpRemoteName) ||
368: (NULL == ConnectablesList[dwDiskListI].lpComment ) ||
369: (NULL == ConnectablesList[dwDiskListI].lpProvider ))
370: PERR("EnumResource - ran out of heap space");
371:
372: strcpy(ConnectablesList[dwDiskListI].lpRemoteName,
373: ResourceBuffer[i].lpRemoteName);
374: strcpy(ConnectablesList[dwDiskListI].lpComment ,
375: ResourceBuffer[i].lpComment );
376: strcpy(ConnectablesList[dwDiskListI].lpProvider ,
377: ResourceBuffer[i].lpProvider );
378:
379: dwDiskListI++;
380:
381: break;
382:
383: case RESOURCEUSAGE_CONTAINER : // Regular container
384: case (RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_RESERVED) : // Top-level container
385:
386: /****************************************************************\
387: *
388: * This next test is here to filter out servers we don't wish to
389: * enumerate while running the sample. A real app would be more
390: * likely to look at all servers, but for running a sample, it's
391: * worthwhile to think about which servers should actually be
392: * enumerated, to avoid annoying people who have other servers on
393: * the net they may not wish to be disturbed
394: *
395: * So, you may want to modify this test to filter out whatever
396: * servers make sense to filter out in your environment
397: *
398: * The first clause shows how to include in the filter the top
399: * level NT Lan Man container, the second clause shows how to
400: * include in the filter a domain name, and the third and fourth
401: * clauses show how to include any servers whose names start with
402: * particular characters
403: *
404: \****************************************************************/
405:
406: if (!( (0==strncmp("NT Lan Man",ResourceBuffer[i].lpRemoteName,10))
407: ||(0==strncmp("NtW000",ResourceBuffer[i].lpRemoteName,6))
408: ||(0==strncmp("\\\\BR",ResourceBuffer[i].lpRemoteName,4))
409: ||(0==strncmp("\\\\BL",ResourceBuffer[i].lpRemoteName,4))))
410: break;
411:
412: if (dwResourcesEnumedSoFar < MAX_NUMBER_OF_RESOURCES_TO_ENUM)
413: Open_Do_Close_1_Enum(&ResourceBuffer[i]);
414:
415: break;
416:
417: case RESOURCEUSAGE_RESERVED : // Ignore these
418: break;
419:
420: default :
421: { UCHAR ucMsgBuf[1500];
422:
423: sprintf(ucMsgBuf,"WNetEnumResources bad .dwUsage value = 0x%X,\n",
424: ResourceBuffer[i].dwUsage);
425: PERR(ucMsgBuf);
426: return(1);
427: }
428: }
429: }
430: }
431:
432: /************************************************************************\
433: *
434: * We have walked the returned buffer. Since dwEntriesToGet has been set
435: * by the api call to be the number of entries actually returned, if how
436: * many were returned is less than what we asked for, return out of the
437: * loop because this enum is done
438: *
439: \************************************************************************/
440:
441: if (dwEntriesToGet < RESOURCE_BUF_ENTRIES)
442: return(0);
443:
444: }
445: PERR("WNetEnumResource - impossible to drop out of infinite loop");
446: return(1);
447: }
448:
449: /****************************************************************************\
450: *
451: * FUNCTION: AddGetGetCancel
452: *
453: * COMMENTS: Connects to first disk resource on our global list
454: *
455: \****************************************************************************/
456:
457: VOID AddGetGetCancel(VOID)
458: {
459: UCHAR ucLocalName[sizeof(LOCAL_DEVICE_NAME)+1] = LOCAL_DEVICE_NAME;
460: UCHAR ucPassword[] = "";
461: #define SZ_BUF 1000
462: UCHAR ucRemoteName[SZ_BUF];
463: UCHAR ucUserName [SZ_BUF];
464: DWORD dwSzBuf = SZ_BUF;
465:
466: if (NO_ERROR != WNetAddConnection(
467: ConnectablesList[WHICH_TO_USE_FROM_LIST].lpRemoteName,
468: (LPTSTR)ucPassword,(LPTSTR)ucLocalName))
469: { PrintAppStyleAPIError(WNetAddConnection,"AddGetGetCancel");
470: return;
471: }
472:
473: dwSzBuf = SZ_BUF;
474:
475: if (NO_ERROR != WNetGetConnection((LPTSTR)ucLocalName,
476: (LPTSTR)ucRemoteName,(LPDWORD)&dwSzBuf))
477: { PrintAppStyleAPIError(WNetGetConnection,"AddGetGetCancel");
478: return;
479: }
480:
481: dwSzBuf = SZ_BUF;
482:
483: if (NO_ERROR != WNetGetUser((LPTSTR)ucLocalName,
484: (LPTSTR)ucUserName,(LPDWORD)&dwSzBuf))
485: { PrintAppStyleAPIError(WNetGetUser,"AddGetGetCancel");
486: return;
487: }
488:
489: printf("\nDisk resource AddGetGetCancel connected = [%s], User name logged on to that resource = [%s]\n",
490: ucRemoteName,ucUserName);
491:
492: if (NO_ERROR != WNetCancelConnection((LPTSTR)ucLocalName,FALSE))
493: { PrintAppStyleAPIError(WNetCancelConnection,"AddGetGetCancel");
494: return;
495: }
496: }
497:
498: /****************************************************************************\
499: *
500: * FUNCTION: AddGetGetCancel2
501: *
502: * COMMENTS: If we had chosen to keep our list as a list of NetResource data
503: * structures, using the new form of AddConnection2 would have been
504: * easier to code. As it is, declaring and filling in the
505: * NetResource takes a few more lines
506: *
507: \****************************************************************************/
508:
509: VOID AddGetGetCancel2(VOID)
510: {
511: UCHAR ucLocalName[sizeof(LOCAL_DEVICE_NAME)+1] = LOCAL_DEVICE_NAME;
512: NETRESOURCE ToConnect;
513: UCHAR ucPassword[] = "";
514: #define SZ_BUF 1000
515: UCHAR ucRemoteName[SZ_BUF];
516: UCHAR ucUserName [SZ_BUF] = "AUserName";
517: DWORD dwSzBuf = SZ_BUF;
518:
519: ToConnect.lpRemoteName =
520: ConnectablesList[WHICH_TO_USE_FROM_LIST].lpRemoteName;
521: ToConnect.lpLocalName = ucLocalName;
522: ToConnect.lpProvider = NULL;
523: ToConnect.dwType = RESOURCETYPE_DISK;
524:
525: if (NO_ERROR != WNetAddConnection2(&ToConnect,(LPTSTR)ucPassword,
526: (LPTSTR)ucUserName,CONNECT_UPDATE_PROFILE))
527: { PrintAppStyleAPIError(WNetAddConnection2,"AddGetGetCancel2");
528: return;
529: }
530:
531: dwSzBuf = SZ_BUF;
532:
533: if (NO_ERROR != WNetGetConnection((LPTSTR)ucLocalName,
534: (LPTSTR)ucRemoteName,(LPDWORD)&dwSzBuf))
535: { PrintAppStyleAPIError(WNetGetConnection,"AddGetGetCancel2");
536: return;
537: }
538:
539: dwSzBuf = SZ_BUF;
540:
541: if (NO_ERROR != WNetGetUser((LPTSTR)ucLocalName,
542: (LPTSTR)ucUserName,(LPDWORD)&dwSzBuf))
543: { PrintAppStyleAPIError(WNetGetUser,"AddGetGetCancel2");
544: return;
545: }
546:
547: printf("\nDisk resource AddGetGetCancel2 connected = [%s], User name logged on to that resource = [%s]\n",
548: ucRemoteName,ucUserName);
549:
550: if (NO_ERROR != WNetCancelConnection2((LPTSTR)ucLocalName,
551: CONNECT_UPDATE_PROFILE,FALSE))
552: { PrintAppStyleAPIError(WNetCancelConnection2,"AddGetGetCancel2");
553: return;
554: }
555: }
556:
557: /****************************************************************************\
558: *
559: * FUNCTION: PrintAPIError
560: *
561: \****************************************************************************/
562:
563: VOID PrintAPIError(LPTSTR ApiTxt,
564: LPTSTR MsgTxt,
565: UINT Line,
566: LPTSTR File)
567: { DWORD dwLastError;
568:
569: dwLastError = GetLastError();
570: switch (dwLastError)
571: { case NO_ERROR :
572: printf("\nNO_ERROR not expected (%s) line %d file %s",MsgTxt,Line,File);
573: break;
574: case ERROR_EXTENDED_ERROR :
575: { LPDWORD lpdwErrorCode;
576:
577: #define SZ_ERROR_BUF 4000
578: UCHAR ucErrorBuf[SZ_ERROR_BUF];
579: #define SZ_PROVIDER_NAME_BUF 400
580: UCHAR ucProviderNameBuf[SZ_PROVIDER_NAME_BUF];
581:
582: if (NO_ERROR != WNetGetLastError(lpdwErrorCode,
583: (LPTSTR)ucErrorBuf,
584: (DWORD)SZ_ERROR_BUF,
585: (LPTSTR)ucProviderNameBuf,
586: (DWORD)SZ_PROVIDER_NAME_BUF))
587: { PERR("WNetGetLastError");
588: }
589: else
590: {
591: #define szMsgBuf SZ_ERROR_BUF * 2
592: UCHAR ucMsgBuf[szMsgBuf];
593:
594: sprintf(ucMsgBuf,
595: "WNetGetLastError code = %d, Msg=[%s], Provider =[%s] line %d file %s",
596: lpdwErrorCode,ucErrorBuf,ucProviderNameBuf,Line,File);
597: PERR(ucMsgBuf);
598: }
599: }
600: break;
601: case ERROR_NOT_SUPPORTED :
602: printf("\nERROR_NOT_SUPPORTED (%s) line %d file %s",MsgTxt,Line,File);
603: break;
604: case ERROR_UNEXP_NET_ERR :
605: printf("\nERROR_UNEXP_NET_ERR (%s) line %d file %s",MsgTxt,Line,File);
606: break;
607: case ERROR_MORE_DATA :
608: printf("\nERROR_MORE_DATA (%s) line %d file %s",MsgTxt,Line,File);
609: break;
610: case ERROR_INVALID_ADDRESS :
611: printf("\nERROR_INVALID_ADDRESS (%s) line %d file %s",MsgTxt,Line,File);
612: break;
613: case ERROR_INVALID_PARAMETER :
614: printf("\nERROR_INVALID_PARAMETER (%s) line %d file %s",MsgTxt,Line,File);
615: break;
616: case ERROR_INVALID_PASSWORD :
617: printf("\nERROR_INVALID_PASSWORD (%s) line %d file %s",MsgTxt,Line,File);
618: break;
619: case ERROR_ACCESS_DENIED :
620: printf("\nERROR_ACCESS_DENIED (%s) line %d file %s",MsgTxt,Line,File);
621: break;
622: case ERROR_BUSY :
623: printf("\nERROR_BUSY (%s) line %d file %s",MsgTxt,Line,File);
624: break;
625: case ERROR_BAD_USERNAME :
626: printf("\nERROR_BAD_USERNAME (%s) line %d file %s",MsgTxt,Line,File);
627: break;
628: case ERROR_NOT_ENOUGH_MEMORY :
629: printf("\nERROR_NOT_ENOUGH_MEMORY (%s) line %d file %s",MsgTxt,Line,File);
630: break;
631: case ERROR_NO_NETWORK :
632: printf("\nERROR_NO_NETWORK (%s) line %d file %s",MsgTxt,Line,File);
633: break;
634: case ERROR_NOT_CONNECTED :
635: printf("\nERROR_NOT_CONNECTED (%s) line %d file %s",MsgTxt,Line,File);
636: break;
637: case ERROR_OPEN_FILES :
638: printf("\nERROR_OPEN_FILES (%s) line %d file %s",MsgTxt,Line,File);
639: break;
640: case ERROR_DEVICE_IN_USE :
641: printf("\nERROR_DEVICE_IN_USE (%s) line %d file %s",MsgTxt,Line,File);
642: break;
643: case ERROR_BAD_NET_NAME :
644: printf("\nERROR_BAD_NET_NAME (%s) line %d file %s",MsgTxt,Line,File);
645: break;
646: case ERROR_BAD_DEVICE :
647: printf("\nERROR_BAD_DEVICE (%s) line %d file %s",MsgTxt,Line,File);
648: break;
649: case ERROR_ALREADY_ASSIGNED :
650: printf("\nERROR_ALREADY_ASSIGNED (%s) line %d file %s",MsgTxt,Line,File);
651: break;
652: case ERROR_GEN_FAILURE :
653: printf("\nERROR_GEN_FAILURE (%s) line %d file %s",MsgTxt,Line,File);
654: break;
655: case ERROR_CONNECTION_UNAVAIL :
656: printf("\nERROR_CONNECTION_UNAVAIL (%s) line %d file %s",MsgTxt,Line,File);
657: break;
658: case ERROR_NO_NET_OR_BAD_PATH :
659: printf("\nERROR_NO_NET_OR_BAD_PATH (%s) line %d file %s",MsgTxt,Line,File);
660: break;
661: case ERROR_BAD_PROVIDER :
662: printf("\nERROR_BAD_PROVIDER (%s) line %d file %s",MsgTxt,Line,File);
663: break;
664: case ERROR_CANNOT_OPEN_PROFILE :
665: printf("\nERROR_CANNOT_OPEN_PROFILE (%s) line %d file %s",MsgTxt,Line,File);
666: break;
667: case ERROR_BAD_PROFILE :
668: printf("\nERROR_BAD_PROFILE (%s) line %d file %s",MsgTxt,Line,File);
669: break;
670: case ERROR_INVALID_HANDLE :
671: printf("\nERROR_INVALID_HANDLE (%s) line %d file %s",MsgTxt,Line,File);
672: break;
673: case ERROR_NO_MORE_ITEMS :
674: printf("\nERROR_NO_MORE_ITEMS (%s) line %d file %s",MsgTxt,Line,File);
675: break;
676: case ERROR_NOT_CONTAINER :
677: printf("\nERROR_NOT_CONTAINER (%s) line %d file %s",MsgTxt,Line,File);
678: break;
679: default :
680: printf("\n%s - unexpected return code=%d (%s) line %d file %s",ApiTxt,dwLastError,MsgTxt,Line,File);
681: break;
682: }
683: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.