![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scandir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to scandir.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: SCANDIR.C
14: *
15: * Scan a directory tree and build a sorted list of filenames within that
16: * tree.
17: *
18: * Functions:
19: *
20: * dir_buildlist()
21: * dir_delete()
22: * dir_isfile()
23: * dir_firstitem()
24: * dir_nextitem()
25: * dir_findnextfile()
26: * dir_getrelname()
27: * dir_getfullname()
28: * dir_getroot_list()
29: * dir_getroot_item()
30: * dir_freerelname()
31: * dir_freefullname()
32: * dir_freeroot_list()
33: * dir_freerootitem()
34: * dir_getopenname()
35: * dir_freeopenname()
36: * dir_openfile()
37: * dir_closefile()
38: * dir_filesize()
39: * dir_startcopy()
40: * dir_endcopy()
41: * dir_copy()
42: * dir_finalelem()
43: * dir_cleardirect()
44: * dir_adddirect()
45: * dir_addfile()
46: * dir_scan()
47: * dir_isvaliddir()
48: * dir_isvalidfile()
49: * dir_fileinit()
50: * dir_dirinit()
51: * dir_getpathsize()
52: * dir_findnextfile()
53: *
54: * Comments:
55: *
56: * The call dir_buildlist takes a pathname and returns a handle. Subsequent
57: * calls to dir_firstitem and dir_nextitem return handles to
58: * items within the list, from which you can get the name of the
59: * file (relative to the original pathname, or complete), and filesize.
60: *
61: * The list can be either built entirely during the build call, or
62: * built one directory at a time as required by dir_nextitem calls. This
63: * option affects only relative performance, and is taken as a
64: * recommendation only (ie some of the time we will ignore the flag).
65: *
66: * The list is ordered alphabetically (case-insensitive using lstrcmpi).
67: * within any one directory, we list filenames before going on
68: * to subdirectory contents.
69: *
70: * All memory is allocated from a gmem_* heap hHeap declared
71: * and initialised elsewhere.
72: *
73: * The caller gets handles to two things: a DIRLIST, representing the
74: * entire list of filenames, and a DIRITEM: one item within the list.
75: *
76: * From the DIRITEM he can get the filename (including or excluding the
77: * tree root passed to dir_build*) - and also he can get to the next
78: * DIRITEM.
79: *
80: * We permit lazy building of the tree (usually so the caller can keep
81: * the user-interface up-to-date as we go along). In this case,
82: * we need to store information about how far we have scanned and
83: * what is next to do. We need to scan an entire directory at a time and then
84: * sort it so we can return files in the correct order.
85: *
86: * We scan an entire directory and store it in a DIRECT struct. This contains
87: * a list of DIRITEMs for the files in the current directory, and a list of
88: * DIRECTs for the subdirectories (possible un-scanned).
89: *
90: * dir_nextitem will use the list functions to get the next DIRITEM on the list.
91: * When the end of the list is reached, it will use the backpointer back to the
92: * DIRECT struct to find the next directory to scan.
93: *
94: ****************************************************************************/
95:
96: #include <windows.h>
97: #include <stdlib.h>
98: #include <string.h>
99: #include <dos.h>
100: #include <direct.h>
101:
102: #include "gutils.h"
103: #include "list.h"
104: #include "scandir.h"
105: #include "windiff.h"
106: #include "wdiffrc.h"
107:
108: /*
109: * Hold name and information about a given file (one ITEM in a DIRectory)
110: * caller's DIRITEM handle is a pointer to one of these structures
111: */
112: struct diritem {
113: LPSTR name; /* ptr to filename (final element only) */
114: long size; /* filesize */
115: struct direct FAR * direct; /* containing directory */
116: LPSTR localname; /* name of temp copy of file */
117: BOOL bLocalIsTemp; /* true if localname is tempfile.
118: */
119: };
120:
121:
122: /* DIRECT: Hold state about directory and current position in list of filenames.
123: */
124: typedef struct direct {
125: LPSTR relname; /* name of dir relative to DIRLIST root */
126: DIRLIST head; /* back ptr (to get fullname) */
127: struct direct FAR * parent; /* parent directory (NULL if above tree root)*/
128:
129: BOOL bScanned; /* TRUE if scanned */
130: LIST diritems; /* list of DIRITEMs for files in cur. dir */
131: LIST directs; /* list of DIRECTs for child dirs */
132:
133: int pos; /* where are we begin, files, dirs */
134: struct direct FAR * curdir; /* subdir being scanned (ptr to list element)*/
135: } FAR * DIRECT;
136:
137: /* Values for direct.pos */
138: #define DL_FILES 1 /* reading files from the diritems */
139: #define DL_DIRS 2 /* in the dirs: List_Next on curdir */
140:
141:
142: /*
143: * The DIRLIST handle returned from a build function is in fact
144: * a pointer to one of these
145: */
146: struct dirlist {
147:
148: char rootname[256]; /* name of root of tree */
149: BOOL bFile; /* TRUE if root of tree is file, not dir */
150: DIRECT dot; /* dir for '.' - for tree root dir */
151: };
152:
153: extern BOOL bAbort; /* from windiff.c (read only here). */
154:
155:
156: /* ------ memory allocation ---------------------------------------------*/
157:
158: /* All memory is allocated from a heap created by the application */
159: extern HANDLE hHeap;
160:
161: /*-- forward declaration of internal functions ---------------------------*/
162:
163: LPSTR dir_finalelem(LPSTR path);
164: void dir_cleardirect(DIRECT dir);
165: void dir_adddirect(DIRECT dir, LPSTR path);
166: void dir_addfile(DIRECT dir, LPSTR path, DWORD size);
167: void dir_scan(DIRECT dir, BOOL bRecurse);
168: BOOL dir_isvaliddir(LPSTR path);
169: BOOL dir_isvalidfile(LPSTR path);
170: void dir_fileinit(DIRITEM pfile, DIRECT dir, LPSTR path, long size);
171: void dir_dirinit(DIRECT dir, DIRLIST head, DIRECT parent, LPSTR name);
172: long dir_getpathsize(LPSTR path);
173: DIRITEM dir_findnextfile(DIRLIST dl, DIRECT curdir);
174:
175:
176:
177: /***************************************************************************
178: * Function: dir_buildlist
179: *
180: * Purpose:
181: *
182: * Build a list of filenames
183: *
184: * Optionally build the list on demand, in which case we scan the
185: * entire directory but don't recurse into subdirs until needed
186: *
187: */
188:
189: DIRLIST
190: dir_buildlist(LPSTR path, BOOL bOnDemand)
191: {
192: DIRLIST dl;
193: BOOL bFile;
194:
195: /* first check if the path is valid */
196: if (dir_isvaliddir(path)) {
197: bFile = FALSE;
198: } else if (dir_isvalidfile(path)) {
199: bFile = TRUE;
200: } else {
201: /* not valid */
202: return(NULL);
203: }
204:
205:
206: /* alloc and init the DIRLIST head */
207:
208: dl = (DIRLIST) gmem_get(hHeap, sizeof(struct dirlist));
209: memset(dl, 0, sizeof(struct dirlist));
210:
211: /* convert the pathname to an absolute path */
212:
213: _fullpath(dl->rootname, path, sizeof(dl->rootname));
214:
215: dl->bFile = bFile;
216: /* make a '.' directory for the current directory -
217: * all files and subdirs will be listed from here
218: */
219: dl->dot = (DIRECT) gmem_get(hHeap, sizeof(struct direct));
220: dir_dirinit(dl->dot, dl, NULL, ".");
221:
222: /* were we given a file or a directory ? */
223: if (bFile) {
224: /* its a file. create a single file entry
225: * and set the state accordingly
226: */
227: dl->dot->bScanned = TRUE;
228:
229: dir_addfile(dl->dot, dir_finalelem(path),
230: dir_getpathsize(path));
231:
232: return(dl);
233: }
234:
235: /* scan the root directory and return. if we are asked
236: * to scan the whole thing, this will cause a recursive
237: * scan all the way down the tree
238: */
239: dir_scan(dl->dot, (!bOnDemand) );
240:
241: return(dl);
242: } /* dir_buildlist */
243:
244: /***************************************************************************
245: * Function: dir_delete
246: *
247: * Purpose:
248: *
249: * Free up the DIRLIST and all associated memory
250: */
251: void
252: dir_delete(DIRLIST dl)
253: {
254: if (dl == NULL) {
255: return;
256: }
257: dir_cleardirect(dl->dot);
258: gmem_free(hHeap, (LPSTR) dl->dot, sizeof(struct direct));
259:
260:
261: gmem_free(hHeap, (LPSTR) dl, sizeof(struct dirlist));
262: }
263:
264:
265:
266: /***************************************************************************
267: * Function: dir_isfile
268: *
269: * Purpose:
270: *
271: * Was the original build request a file or a directory ?
272: */
273: BOOL
274: dir_isfile(DIRLIST dl)
275: {
276: if (dl == NULL) {
277: return(FALSE);
278: }
279:
280: return(dl->bFile);
281: }
282:
283: /***************************************************************************
284: * Function: dir_firstitem
285: *
286: * Purpose:
287: *
288: * Return the first file in the list, or NULL if no files found.
289: * Returns a DIRITEM. This can be used to get filename, size and chcksum.
290: * If there are no files in the root, we recurse down until we find a file.
291: */
292: DIRITEM
293: dir_firstitem(DIRLIST dl)
294: {
295: if (dl == NULL) {
296: return(NULL);
297: }
298: /*
299: * reset the state to indicate that no files have been read yet
300: */
301: dl->dot->pos = DL_FILES;
302: dl->dot->curdir = NULL;
303:
304: /* now get the next filename */
305: return(dir_findnextfile(dl, dl->dot));
306: } /* dir_firstitem */
307:
308:
309: /***************************************************************************
310: * Function:dir_nextitem
311: *
312: * Purpose:
313: *
314: * Get the next filename after the one given.
315: *
316: * The List_Next function can give us the next element on the list of files.
317: * If this is null, we need to go back to the DIRECT and find the
318: * next list of files to traverse (in the next subdir).
319: *
320: * After scanning all the subdirs, return to the parent to scan further
321: * dirs that are peers of this, if there are any. If we have reached the end of
322: * the tree (no more dirs in dl->dot to scan), return NULL.
323: *
324: * Don't recurse to lower levels unless fDeep is TRUE
325: */
326: DIRITEM
327: dir_nextitem(DIRLIST dl, DIRITEM cur, BOOL fDeep)
328: {
329: DIRITEM next;
330:
331: if ((dl == NULL) || (cur == NULL)) {
332: return(NULL);
333: }
334: if (bAbort) return NULL; /* user requested abort */
335:
336: if ( (next = List_Next(cur)) != NULL) {
337: /* there was another file on this list */
338: return(next);
339: }
340: if (!fDeep) return NULL;
341:
342: /* get the head of the next list of filenames from the directory */
343: cur->direct->pos = DL_DIRS;
344: cur->direct->curdir = NULL;
345: return(dir_findnextfile(dl, cur->direct));
346: } /* dir_nextitem */
347:
348: /***************************************************************************
349: * Function: dir_findnextfile
350: *
351: * Purpose:
352: *
353: * Gets the next file in the directory
354: */
355: DIRITEM
356: dir_findnextfile(DIRLIST dl, DIRECT curdir)
357: {
358: DIRITEM curfile;
359:
360: if ((dl == NULL) || (curdir == NULL)) {
361: return(NULL);
362: }
363:
364: /* scan the subdir if necessary */
365: if (!curdir->bScanned) {
366: dir_scan(curdir, FALSE);
367: }
368:
369: /* have we already read the files in this directory ? */
370: if (curdir->pos == DL_FILES) {
371: /* no - return head of file list */
372: curfile = (DIRITEM) List_First(curdir->diritems);
373: if (curfile != NULL) {
374: return(curfile);
375: }
376:
377: /* no more files - try the subdirs */
378: curdir->pos = DL_DIRS;
379: }
380:
381: /* try the next subdir on the list, if any */
382: /* is this the first or the next */
383: if (curdir->curdir == NULL) {
384: curdir->curdir = (DIRECT) List_First(curdir->directs);
385: } else {
386: curdir->curdir = (DIRECT) List_Next(curdir->curdir);
387: }
388: /* did we find a subdir ? */
389: if (curdir->curdir == NULL) {
390:
391: /* no more dirs - go back to parent if there is one */
392: if (curdir->parent == NULL) {
393: /* no parent - we have exhausted the tree */
394: return(NULL);
395: }
396:
397: /* reset parent state to indicate this is the current
398: * directory - so that next gets the next after this.
399: * this ensures that multiple callers of dir_nextitem()
400: * to the same tree work.
401: */
402: curdir->parent->pos = DL_DIRS;
403: curdir->parent->curdir = curdir;
404:
405: return(dir_findnextfile(dl, curdir->parent));
406: }
407:
408: /* there is a next directory - set it to the
409: * beginning and get the first file from it
410: */
411: curdir->curdir->pos = DL_FILES;
412: curdir->curdir->curdir = NULL;
413: return(dir_findnextfile(dl, curdir->curdir));
414:
415: } /* dir_findnextfile */
416:
417:
418: /*-- pathnames ----
419: *
420: * This module supports two types of pathnames, called relative and full.
421: * Relative names are relative to the root passed in the initial call
422: * to dir_build*, and full names include the tree root.
423: *
424: * Note that this is a different distinction to relative vs absolute
425: * pathnames, since the tree root may still be either relative or absolute.
426: *
427: * Examples:
428: *
429: * - if you called dir_buildlist("c:\")
430: * getrelname gives: ".\config.sys"
431: * getfullname gives: "c:\config.sys"
432: *
433: * - if you called dir_buildlist(".\geraintd")
434: * getrelname gives: ".\source\scandir.h"
435: * getfullname gives either
436: * ".\geraintd\source\scandir.h"
437: * or "c:\geraintd\source\scandir.h"
438: * (depending on the implementation).
439: *
440: * To support this, we maintain the tree root name in the DIRLIST head, and
441: * in each directory, the name of that directory relative to tree root.
442: * Files just have the filename, so we need to prepend the directory name,
443: * and (for getfullname) the tree root name as well
444: *
445: * We store the directory name with a trailing
446: * slash to make concatenation easier
447: *
448: * -----
449: */
450:
451: /***************************************************************************
452: * Function: dir_getrelname
453: *
454: * Purpose:
455: *
456: * Return the name of the current file relative to tree root
457: */
458: LPSTR
459: dir_getrelname(DIRITEM cur)
460: {
461: LPSTR name;
462: int size;
463:
464: /* check this is a valid item */
465: if (cur == NULL) {
466: return(NULL);
467: }
468: /* remember to include the NULL when sizing */
469: size = lstrlen(cur->direct->relname) + lstrlen(cur->name) + 1;
470: name = gmem_get(hHeap, size);
471: lstrcpy(name, cur->direct->relname);
472: lstrcat(name, cur->name);
473:
474: return(name);
475: } /* dir_getrelname */
476:
477: /***************************************************************************
478: * Function: dir_getfullname
479: *
480: * Purpose:
481: *
482: * Return the fullname of the file (including the tree root passed in)
483: */
484: LPSTR
485: dir_getfullname(DIRITEM cur)
486: {
487: LPSTR name;
488: int size;
489: LPSTR head;
490:
491: /* check this is a valid item */
492: if (cur == NULL) {
493: return(NULL);
494: }
495:
496: if (cur->direct->head->bFile) {
497: return(cur->direct->head->rootname);
498: }
499:
500: /* remember to include the NULL when sizing */
501: size = lstrlen(cur->name) + 1;
502:
503: size += lstrlen(cur->direct->relname);
504:
505: /* add on root name */
506: head = cur->direct->head->rootname;
507: size += lstrlen(head);
508:
509: /* root names may not end in a slash. we need to
510: * insert one in this case. Also, relnames always begin .\, so
511: * we skip the . always, and the .\ if we don't need to
512: * append a slash
513: *
514: */
515: size--; /* omit the '.' */
516: if (head[lstrlen(head) -1] == '\\') {
517: size--; /* omit the .\ */
518: }
519:
520: name = gmem_get(hHeap, size);
521:
522: lstrcpy(name, cur->direct->head->rootname);
523:
524: /* add relname and then name, omiting the .\ */
525:
526: /* skip . or .\ before relname */
527: if (head[lstrlen(head) -1] == '\\') {
528: lstrcat(name, &cur->direct->relname[2]);
529: } else {
530: lstrcat(name, &cur->direct->relname[1]);
531: }
532: lstrcat(name, cur->name);
533: return(name);
534: } /* dir_getfullname */
535:
536:
537: /***************************************************************************
538: * Function: dir_getroot_list
539: *
540: * Purpose:
541: *
542: * Return the name of the tree root given a handle to the DIRLIST.
543: */
544: LPSTR
545: dir_getroot_list(DIRLIST dl)
546: {
547: if (dl == NULL)
548: return(NULL);
549: return(dl->rootname);
550: } /* dir_getroot_list */
551:
552: /***************************************************************************
553: * Function: dir_getroot_item
554: *
555: * Purpose:
556: *
557: * Return the root name of this tree given a handle to a DIRITEM in the
558: * list.
559: */
560: LPSTR dir_getroot_item(DIRITEM item)
561: {
562: if (item == NULL)
563: return(NULL);
564:
565: return(dir_getroot_list(item->direct->head));
566: }
567:
568:
569: /***************************************************************************
570: * Function: dir_freerelname
571: *
572: * Purpose:
573: *
574: * Free up a relname that we allocated. This interface allows us
575: * some flexibility in how we store relative and complete names
576: *
577: */
578: void
579: dir_freerelname(DIRITEM cur, LPSTR name)
580: {
581: if((cur != NULL) && (name != NULL))
582: gmem_free(hHeap, name, lstrlen(name) +1);
583: } /* dir_freerelname */
584:
585: /***************************************************************************
586: * Function: dir_freefullname
587: *
588: * Purpose:
589: *
590: */
591: void
592: dir_freefullname(DIRITEM cur, LPSTR name)
593: {
594: if (cur->direct->head->bFile)
595: return;
596:
597: if (name != NULL)
598: gmem_free(hHeap, name, lstrlen(name) + 1);
599: } /* dir_freefullname */
600:
601: /***************************************************************************
602: * Function: dir_freeroot_list
603: *
604: * Purpose:
605: *
606: * Free up rootname allocated by dir_getroot_list.
607: * We just gave a pointer to the rootname, so do nothing.
608: */
609: void
610: dir_freeroot_list(DIRLIST dl, LPSTR name)
611: {
612: if ((dl == NULL) || (name == NULL)) {
613: return;
614: }
615: return;
616: } /* dir_freeroot_list */
617:
618: /***************************************************************************
619: * Function: dir_freeroot_item
620: *
621: * Purpose:
622: *
623: * Free up memory alloc-ed by a call to dir_getroot_item.
624: */
625: void
626: dir_freeroot_item(DIRITEM item, LPSTR name)
627: {
628: if ((item == NULL) || (name == NULL))
629: return;
630: dir_freeroot_list(item->direct->head, name);
631: }
632:
633: /***************************************************************************
634: * Function: dir_getopenname
635: *
636: * Purpose:
637: *
638: * Get an open-able name for the file. This will be the same as the fullname.
639: */
640: LPSTR
641: dir_getopenname(DIRITEM item)
642: {
643: LPSTR fname;
644:
645: if (item == NULL)
646: return(NULL);
647:
648: fname = dir_getfullname(item);
649:
650: return(fname);
651: } /* dir_getopenname */
652:
653:
654: /***************************************************************************
655: * Function: dir_freeopenname
656: *
657: * Purpose:
658: *
659: * Free up memory created by a call to dir_getopenname(). This *may*
660: * cause the file to be deleted if it was a temporary copy.
661: */
662: void
663: dir_freeopenname(DIRITEM item, LPSTR openname)
664: {
665: if ((item == NULL) || (openname == NULL))
666: return;
667:
668: dir_freefullname(item, openname);
669: } /* dir_freeopenname */
670:
671: /***************************************************************************
672: * Function: dir_openfile
673: *
674: * Purpose:
675: *
676: * Return an open file handle to the file.
677: */
678: int
679: dir_openfile(DIRITEM item)
680: {
681: LPSTR fname;
682: int fh;
683: OFSTRUCT os;
684:
685: fname = dir_getfullname(item);
686: fh = OpenFile(fname, &os, OF_READ|OF_SHARE_DENY_NONE);
687: dir_freefullname(item, fname);
688: return(fh);
689: } /* dir_openfile */
690:
691: /***************************************************************************
692: * Function: dir_closefile
693: *
694: * Purpose:
695: *
696: * Close a file opened with dir_openfile.
697: */
698: void
699: dir_closefile(DIRITEM item, int fh)
700: {
701: _lclose(fh);
702:
703: } /* dir_closefile */
704:
705:
706: /***************************************************************************
707: * Function: dir_getfilesize
708: *
709: * Purpose:
710: *
711: * Return the file size (set during scanning)
712: */
713: long
714: dir_getfilesize(DIRITEM cur)
715: {
716: /* check this is a valid item */
717: if (cur == NULL)
718: return(0);
719:
720: return(cur->size);
721: } /* dir_getfilesize */
722:
723:
724:
725: /* ss_endcopy returns a number indicating the number of files copied,
726: but we may have some local copies too. We need to count these
727: ourselves and add them in
728: */
729:
730: int nLocalCopies; /* cleared in startcopy, ++d in copy
731: ** inspected in endcopy
732: */
733:
734: /***************************************************************************
735: * Function: dir_startcopy
736: *
737: * Purpose:
738: *
739: * Start a bulk copy
740: */
741: BOOL dir_startcopy(DIRLIST dl)
742: {
743: nLocalCopies = 0;
744: return(TRUE);
745:
746: } /* dir_startcopy */
747: /***************************************************************************
748: * Function: dir_endcopy
749: *
750: */
751:
752: int dir_endcopy(DIRLIST dl)
753: {
754: return(nLocalCopies);
755:
756: } /* dir_endcopy */
757:
758: /***************************************************************************
759: * Function: dir_copy
760: *
761: * Purpose:
762: *
763: * Create a copy of the file, in the new root directory. Creates sub-dirs as
764: * necessary.
765: *
766: * Returns TRUE for success and FALSE for failure.
767: */
768: BOOL dir_copy(DIRITEM item, LPSTR newroot)
769: {
770: static char newpath[256];
771: LPSTR relname, fullname;
772: LPSTR pstart, pdest, pel;
773: BOOL bOK;
774:
775: BY_HANDLE_FILE_INFORMATION bhfi;
776: HANDLE hfile;
777:
778: /*
779: * check that the newroot directory itself exists
780: */
781: if ((item == NULL) || !dir_isvaliddir(newroot)) {
782: return(FALSE);
783: }
784:
785: /*
786: * name of file relative to the tree root
787: */
788: relname = dir_getrelname(item);
789:
790: /*
791: * build the new pathname by concatenating the new root and
792: * the old relative name. add one path element at a time and
793: * ensure that the directory exists, creating it if necessary.
794: */
795: lstrcpy(newpath, newroot);
796:
797: /* add separating slash if not already there */
798: if (newpath[lstrlen(newpath) -1] != '\\') {
799: lstrcat(newpath, "\\");
800: }
801:
802: pstart = relname;
803: while ( (pel = strchr(pstart, '\\')) != NULL) {
804:
805: /* found another element ending in slash. incr past the \\ */
806: pel++;
807:
808: /*
809: * ignore .
810: */
811: if (strncmp(pstart, ".\\", 2) != 0) {
812:
813: pdest = &newpath[lstrlen(newpath)];
814: strncpy(pdest, pstart, pel - pstart);
815: pdest[pel - pstart] = '\0';
816:
817: /* create subdir if necessary */
818: if (!dir_isvaliddir(newpath)) {
819: if (_mkdir(newpath) != 0) {
820: return(FALSE);
821: }
822: }
823: }
824:
825: pstart = pel;
826: }
827:
828: /*
829: * there are no more slashes, so pstart points at the final
830: * element
831: */
832: lstrcat(newpath, pstart);
833:
834: fullname = dir_getfullname(item);
835:
836: bOK = CopyFile(fullname, newpath, FALSE);
837:
838: /* having copied the file, now copy the times, attributes */
839: hfile = CreateFile(fullname, GENERIC_READ, 0, NULL,
840: OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
841: bhfi.dwFileAttributes = GetFileAttributes(fullname);
842: GetFileTime(hfile, &bhfi.ftCreationTime,
843: &bhfi.ftLastAccessTime, &bhfi.ftLastWriteTime);
844: CloseHandle(hfile);
845:
846: hfile = CreateFile(newpath, GENERIC_WRITE, 0, NULL,
847: OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
848: SetFileTime(hfile, &bhfi.ftCreationTime,
849: &bhfi.ftLastAccessTime,
850: &bhfi.ftLastWriteTime);
851: CloseHandle(hfile);
852: SetFileAttributes(newpath, bhfi.dwFileAttributes);
853:
854:
855: if (bOK) ++nLocalCopies;
856:
857: dir_freerelname(item, relname);
858: dir_freefullname(item, fullname);
859:
860: return(bOK);
861: } /* dir_copy */
862:
863:
864: /***************************************************************************
865: * Function: dir_dirinit
866: *
867: * Purpose:
868: *
869: * Fill out a new DIRECT for a subdirectory (pre-allocated).
870: * Init files and dirs lists to empty (List_Create). Set the relname
871: * of the directory by pre-pending the parent relname if there
872: * is a parent, and appending a trailing slash (if there isn't one).
873: */
874: void
875: dir_dirinit(DIRECT dir, DIRLIST head, DIRECT parent, LPSTR name)
876: {
877: int size;
878:
879: dir->head = head;
880: dir->parent = parent;
881:
882: /* add on one for the null and one for the trailing slash */
883: size = lstrlen(name) + 2;
884: if (parent != NULL) {
885: size += lstrlen(parent->relname);
886: }
887:
888: /* build the relname from the parent and the current name
889: * with a terminating slash
890: */
891: dir->relname = gmem_get(hHeap, size);
892: if (parent != NULL) {
893: lstrcpy(dir->relname, parent->relname);
894: } else{
895: dir->relname[0] = '\0';
896: }
897:
898: lstrcat(dir->relname, name);
899:
900: if (dir->relname[lstrlen(dir->relname) -1] != '\\') {
901: lstrcat(dir->relname, "\\");
902: }
903:
904: /* force name to lowercase */
905: AnsiLowerBuff(dir->relname, lstrlen(dir->relname));
906:
907: dir->diritems = List_Create();
908: dir->directs = List_Create();
909: dir->bScanned = FALSE;
910: dir->pos = DL_FILES;
911:
912: } /* dir_dirinit */
913:
914:
915: /***************************************************************************
916: * Function: dir_fileinit
917: *
918: * Purpose:
919: *
920: * Initialise the contents of an (allocated) DIRITEM struct.
921: */
922: void
923: dir_fileinit(DIRITEM pfile, DIRECT dir, LPSTR path, long size)
924: {
925:
926: pfile->name = gmem_get(hHeap, lstrlen(path) + 1);
927: lstrcpy(pfile->name, path);
928:
929: /* force name to lower case */
930: AnsiLowerBuff(pfile->name, lstrlen(path));
931:
932: pfile->direct = dir;
933: pfile->size = size;
934:
935: pfile->localname = NULL;
936:
937: } /* dir_fileinit */
938:
939: /***************************************************************************
940: * Function: dir_isfilevalid
941: *
942: * Purpose:
943: *
944: * Is this a valid file or not
945: */
946: BOOL
947: dir_isvalidfile(LPSTR path)
948: {
949: DWORD dwAttrib;
950:
951: dwAttrib = GetFileAttributes(path);
952: if (dwAttrib == -1) {
953: return(FALSE);
954: }
955: if (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) {
956: return(FALSE);
957: }
958: return(TRUE);
959: } /* dir_isvalidfile */
960:
961: /***************************************************************************
962: * Function: dir_isvaliddir
963: *
964: * Purpose:
965: *
966: * Is this a valid directory ?
967: */
968: BOOL
969: dir_isvaliddir(LPSTR path)
970: {
971: DWORD dwAttrib;
972:
973: dwAttrib = GetFileAttributes(path);
974: if (dwAttrib == -1) {
975: return(FALSE);
976: }
977: if (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) {
978: return(TRUE);
979: }
980: return(FALSE);
981: } /* dir_isvaliddir */
982:
983: /***************************************************************************
984: * Function: dir_scan
985: *
986: * Purpose:
987: *
988: * Scan the directory given. Add all files to the list
989: * in alphabetic order, and add all directories in alphabetic
990: * order to the list of child DIRITEMs. If bRecurse is true, go on to
991: * recursive call dir_scan for each of the child DIRITEMs
992: */
993: void
994: dir_scan(DIRECT dir, BOOL bRecurse)
995: {
996: PSTR path;
997: int size;
998: DIRECT child;
999: BOOL bMore;
1000: long filesize;
1001: BOOL bIsDir;
1002: LPSTR name;
1003:
1004: HANDLE hFind;
1005: WIN32_FIND_DATA finddata;
1006:
1007: char debugmsg[200];
1008: wsprintf(debugmsg, "scandir: %s %s\n",
1009: dir->relname, bRecurse?"recursive":"non-recursive"
1010: );
1011:
1012: /* make the complete search string including *.* */
1013: size = lstrlen(dir->head->rootname);
1014: size += lstrlen(dir->relname);
1015:
1016: /* add on one null and *.* */
1017: size += 4;
1018:
1019: path = LocalLock(LocalAlloc(LHND, size));
1020:
1021: lstrcpy(path, dir->head->rootname);
1022:
1023: /* omit the . at the beginning of the relname, and the
1024: * .\ if there is a trailing \ on the rootname
1025: */
1026: if (path[strlen(path)-1] == '\\') {
1027: lstrcat(path, &dir->relname[2]);
1028: } else {
1029: lstrcat(path, &dir->relname[1]);
1030: }
1031: lstrcat(path, "*.*");
1032:
1033: /* read all entries in the directory */
1034: hFind = FindFirstFile(path, &finddata);
1035: bMore = (hFind != (HANDLE) -1);
1036: LocalUnlock(LocalHandle ( (PSTR) path));
1037: LocalFree(LocalHandle ( (PSTR) path));
1038:
1039: while (bMore) {
1040:
1041: bIsDir = (finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
1042: name = (LPSTR) &finddata.cFileName;
1043: filesize = finddata.nFileSizeLow;
1044: if (!bIsDir) {
1045:
1046: dir_addfile(dir, name, filesize);
1047:
1048: } else if ( (lstrcmp(name, ".") != 0) &&
1049: ( lstrcmp(name, "..") != 0) ) {
1050:
1051: dir_adddirect(dir, name);
1052: }
1053:
1054: bMore = FindNextFile(hFind, &finddata);
1055: }
1056:
1057: FindClose(hFind);
1058:
1059: dir->bScanned = TRUE;
1060: dir->pos = DL_FILES;
1061:
1062: if (bRecurse) {
1063: List_TRAVERSE(dir->directs, child) {
1064: dir_scan(child, TRUE);
1065: }
1066: }
1067:
1068: } /* dir_scan */
1069:
1070:
1071: /***************************************************************************
1072: * Function: dir_addfile
1073: *
1074: * Purpose:
1075: *
1076: * Add the file 'path' to the list of files in dir, in order.
1077: */
1078: void
1079: dir_addfile(DIRECT dir, LPSTR path, DWORD size)
1080: {
1081: DIRITEM pfile;
1082:
1083: AnsiLowerBuff(path, lstrlen(path)); // needless?
1084:
1085: List_TRAVERSE(dir->diritems, pfile) {
1086: /////if (lstrcmpi(pfile->name, path) > 0) {
1087: if (utils_CompPath(pfile->name, path) > 0) {
1088:
1089: /* goes before this one */
1090: pfile = List_NewBefore(dir->diritems, pfile, sizeof(struct diritem));
1091: dir_fileinit(pfile, dir, path, size);
1092: return;
1093: }
1094: }
1095: /* goes at end */
1096: pfile = List_NewLast(dir->diritems, sizeof(struct diritem));
1097: dir_fileinit(pfile, dir, path, size);
1098: } /* dir_addfile */
1099:
1100:
1101: /***************************************************************************
1102: * Function: dir_addirect
1103: *
1104: * Purpose:
1105: *
1106: * Add a new directory in alphabetic order on
1107: * the list dir->directs
1108: *
1109: */
1110: void
1111: dir_adddirect(DIRECT dir, LPSTR path)
1112: {
1113: DIRECT child;
1114: LPSTR finalel;
1115: char achTempName[256];
1116:
1117: AnsiLowerBuff(path, lstrlen(path));
1118: List_TRAVERSE(dir->directs, child) {
1119:
1120: int cmpval;
1121:
1122: /* we need to compare the child name with the new name.
1123: * the child name is a relname with a trailing
1124: * slash - so compare only the name up to but
1125: * not including the final slash.
1126: */
1127: finalel = dir_finalelem(child->relname);
1128:
1129: /*
1130: * we cannot use strnicmp since this uses a different
1131: * collating sequence to lstrcmpi. So copy the portion
1132: * we are interested in to a null-term. buffer.
1133: */
1134: strncpy(achTempName, finalel, lstrlen(finalel)-1);
1135: achTempName[lstrlen(finalel)-1] = '\0';
1136:
1137: cmpval = utils_CompPath(achTempName, path);
1138:
1139: if (cmpval > 0) {
1140:
1141: /* goes before this one */
1142: child = List_NewBefore(dir->directs, child, sizeof(struct direct));
1143: dir_dirinit(child, dir->head, dir, path);
1144: return;
1145: }
1146: }
1147: /* goes at end */
1148: child = List_NewLast(dir->directs, sizeof(struct direct));
1149: dir_dirinit(child, dir->head, dir, path);
1150: } /* dir_adddirect */
1151:
1152:
1153: /***************************************************************************
1154: * Function: dir_cleardirect
1155: *
1156: * Purpose:
1157: *
1158: * Free all memory associated with a DIRECT (including freeing
1159: * child lists). Don't de-alloc the direct itself (allocated on a list)
1160: */
1161: void
1162: dir_cleardirect(DIRECT dir)
1163: {
1164: DIRITEM pfile;
1165: DIRECT child;
1166:
1167: /* clear contents of files list */
1168: List_TRAVERSE(dir->diritems, pfile) {
1169: gmem_free(hHeap, pfile->name, lstrlen(pfile->name));
1170: if ((pfile->localname) && (pfile->bLocalIsTemp)) {
1171:
1172: /*
1173: * the copy will have copied the attributes,
1174: * including read-only. We should unset this bit
1175: * so we can delete the temp file.
1176: */
1177: SetFileAttributes(pfile->localname,
1178: GetFileAttributes(pfile->localname)
1179: & ~FILE_ATTRIBUTE_READONLY);
1180: DeleteFile(pfile->localname);
1181: gmem_free(hHeap, pfile->localname, 256);
1182: pfile->localname = NULL;
1183: }
1184:
1185: }
1186: List_Destroy(&dir->diritems);
1187:
1188: /* clear contents of dirs list (recursively) */
1189: List_TRAVERSE(dir->directs, child) {
1190: dir_cleardirect(child);
1191: }
1192: List_Destroy(&dir->directs);
1193:
1194: gmem_free(hHeap, dir->relname, lstrlen(dir->relname) + 1);
1195:
1196: } /* dir_cleardirect */
1197:
1198: /***************************************************************************
1199: * Function: dir_finalelem
1200: *
1201: * Purpose:
1202: *
1203: * Return a pointer to the final element in a path. Note that
1204: * we may be passed relnames with a trailing final slash - ignore this
1205: * and return the element before that final slash.
1206: */
1207: LPSTR
1208: dir_finalelem(LPSTR path)
1209: {
1210: LPSTR chp;
1211: int size;
1212:
1213: /* is the final character a slash ? */
1214: size = lstrlen(path) - 1;
1215: if (path[size] == '\\') {
1216: /* find the slash before this */
1217: for (size-- ; size > 0; size--) {
1218: if (path[size] == '\\') {
1219: /* skip the slash itself */
1220: size++;
1221: break;
1222: }
1223: }
1224: return(&path[size]);
1225: }
1226: /* look for final slash */
1227: chp = strrchr(path, '\\');
1228: if (chp != NULL) {
1229: return(chp+1);
1230: }
1231:
1232: /* no slash - is there a drive letter ? */
1233: chp = strrchr(path, ':');
1234: if (chp != NULL) {
1235: return(chp+1);
1236: }
1237:
1238: /* this is a final-element anyway */
1239: return(path);
1240:
1241: } /* dir_finalelem */
1242:
1243: /***************************************************************************
1244: * Function: dir_getpathsize
1245: *
1246: * Purpose:
1247: *
1248: * Find the size of a file given a pathname to it
1249: */
1250: long
1251: dir_getpathsize(LPSTR path)
1252: {
1253: int fh;
1254: OFSTRUCT os;
1255: long size;
1256: fh = OpenFile(path, &os, OF_READ|OF_SHARE_DENY_NONE);
1257: if (fh == -1) {
1258: return(0);
1259: }
1260:
1261: size = GetFileSize( (HANDLE) fh, NULL);
1262: _lclose(fh);
1263: return(size);
1264: } /* dir_getpathsize */
1265:
1266:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.