summaryrefslogtreecommitdiff
path: root/utility.c
diff options
context:
space:
mode:
Diffstat (limited to 'utility.c')
-rw-r--r--utility.c1181
1 files changed, 1181 insertions, 0 deletions
diff --git a/utility.c b/utility.c
new file mode 100644
index 000000000..68259710b
--- /dev/null
+++ b/utility.c
@@ -0,0 +1,1181 @@
1/*
2 * Utility routines.
3 *
4 * Copyright (C) 1998 by Erik Andersen <andersee@debian.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Based in part on code from sash, Copyright (c) 1999 by David I. Bell
21 * Permission has been granted to redistribute this code under the GPL.
22 *
23 */
24
25#include "utility.h"
26
27#if 0
28
29extern char *
30join_paths(char * buffer, const char * a, const char * b)
31{
32 int length = 0;
33
34 if ( a && *a ) {
35 length = strlen(a);
36 memcpy(buffer, a, length);
37 }
38 if ( b && *b ) {
39 if ( length > 0 && buffer[length - 1] != '/' )
40 buffer[length++] = '/';
41 if ( *b == '/' )
42 b++;
43 strcpy(&buffer[length], b);
44 }
45 return buffer;
46}
47
48#endif
49
50
51
52
53
54
55static CHUNK * chunkList;
56
57extern void
58name_and_error(const char * name)
59{
60 fprintf(stderr, "%s: %s\n", name, strerror(errno));
61}
62
63
64
65/*
66 * Return the standard ls-like mode string from a file mode.
67 * This is static and so is overwritten on each call.
68 */
69const char *
70modeString(int mode)
71{
72 static char buf[12];
73
74 strcpy(buf, "----------");
75
76 /*
77 * Fill in the file type.
78 */
79 if (S_ISDIR(mode))
80 buf[0] = 'd';
81 if (S_ISCHR(mode))
82 buf[0] = 'c';
83 if (S_ISBLK(mode))
84 buf[0] = 'b';
85 if (S_ISFIFO(mode))
86 buf[0] = 'p';
87#ifdef S_ISLNK
88 if (S_ISLNK(mode))
89 buf[0] = 'l';
90#endif
91#ifdef S_ISSOCK
92 if (S_ISSOCK(mode))
93 buf[0] = 's';
94#endif
95
96 /*
97 * Now fill in the normal file permissions.
98 */
99 if (mode & S_IRUSR)
100 buf[1] = 'r';
101 if (mode & S_IWUSR)
102 buf[2] = 'w';
103 if (mode & S_IXUSR)
104 buf[3] = 'x';
105 if (mode & S_IRGRP)
106 buf[4] = 'r';
107 if (mode & S_IWGRP)
108 buf[5] = 'w';
109 if (mode & S_IXGRP)
110 buf[6] = 'x';
111 if (mode & S_IROTH)
112 buf[7] = 'r';
113 if (mode & S_IWOTH)
114 buf[8] = 'w';
115 if (mode & S_IXOTH)
116 buf[9] = 'x';
117
118 /*
119 * Finally fill in magic stuff like suid and sticky text.
120 */
121 if (mode & S_ISUID)
122 buf[3] = ((mode & S_IXUSR) ? 's' : 'S');
123 if (mode & S_ISGID)
124 buf[6] = ((mode & S_IXGRP) ? 's' : 'S');
125 if (mode & S_ISVTX)
126 buf[9] = ((mode & S_IXOTH) ? 't' : 'T');
127
128 return buf;
129}
130
131
132/*
133 * Get the time string to be used for a file.
134 * This is down to the minute for new files, but only the date for old files.
135 * The string is returned from a static buffer, and so is overwritten for
136 * each call.
137 */
138const char *
139timeString(time_t timeVal)
140{
141 time_t now;
142 char * str;
143 static char buf[26];
144
145 time(&now);
146
147 str = ctime(&timeVal);
148
149 strcpy(buf, &str[4]);
150 buf[12] = '\0';
151
152 if ((timeVal > now) || (timeVal < now - 365*24*60*60L))
153 {
154 strcpy(&buf[7], &str[20]);
155 buf[11] = '\0';
156 }
157
158 return buf;
159}
160
161
162/*
163 * Return TRUE if a fileName is a directory.
164 * Nonexistant files return FALSE.
165 */
166BOOL
167isDirectory(const char * name)
168{
169 struct stat statBuf;
170
171 if (stat(name, &statBuf) < 0)
172 return FALSE;
173
174 return S_ISDIR(statBuf.st_mode);
175}
176
177
178/*
179 * Return TRUE if a filename is a block or character device.
180 * Nonexistant files return FALSE.
181 */
182BOOL
183isDevice(const char * name)
184{
185 struct stat statBuf;
186
187 if (stat(name, &statBuf) < 0)
188 return FALSE;
189
190 return S_ISBLK(statBuf.st_mode) || S_ISCHR(statBuf.st_mode);
191}
192
193
194/*
195 * Copy one file to another, while possibly preserving its modes, times,
196 * and modes. Returns TRUE if successful, or FALSE on a failure with an
197 * error message output. (Failure is not indicted if the attributes cannot
198 * be set.)
199 */
200BOOL
201copyFile(
202 const char * srcName,
203 const char * destName,
204 BOOL setModes
205)
206{
207 int rfd;
208 int wfd;
209 int rcc;
210 char buf[BUF_SIZE];
211 struct stat statBuf1;
212 struct stat statBuf2;
213 struct utimbuf times;
214
215 if (stat(srcName, &statBuf1) < 0)
216 {
217 perror(srcName);
218
219 return FALSE;
220 }
221
222 if (stat(destName, &statBuf2) < 0)
223 {
224 statBuf2.st_ino = -1;
225 statBuf2.st_dev = -1;
226 }
227
228 if ((statBuf1.st_dev == statBuf2.st_dev) &&
229 (statBuf1.st_ino == statBuf2.st_ino))
230 {
231 fprintf(stderr, "Copying file \"%s\" to itself\n", srcName);
232
233 return FALSE;
234 }
235
236 rfd = open(srcName, O_RDONLY);
237
238 if (rfd < 0)
239 {
240 perror(srcName);
241
242 return FALSE;
243 }
244
245 wfd = creat(destName, statBuf1.st_mode);
246
247 if (wfd < 0)
248 {
249 perror(destName);
250 close(rfd);
251
252 return FALSE;
253 }
254
255 while ((rcc = read(rfd, buf, sizeof(buf))) > 0)
256 {
257 if (fullWrite(wfd, buf, rcc) < 0)
258 goto error_exit;
259 }
260
261 if (rcc < 0)
262 {
263 perror(srcName);
264 goto error_exit;
265 }
266
267 (void) close(rfd);
268
269 if (close(wfd) < 0)
270 {
271 perror(destName);
272
273 return FALSE;
274 }
275
276 if (setModes)
277 {
278 (void) chmod(destName, statBuf1.st_mode);
279
280 (void) chown(destName, statBuf1.st_uid, statBuf1.st_gid);
281
282 times.actime = statBuf1.st_atime;
283 times.modtime = statBuf1.st_mtime;
284
285 (void) utime(destName, &times);
286 }
287
288 return TRUE;
289
290
291error_exit:
292 close(rfd);
293 close(wfd);
294
295 return FALSE;
296}
297
298
299/*
300 * Build a path name from the specified directory name and file name.
301 * If the directory name is NULL, then the original fileName is returned.
302 * The built path is in a static area, and is overwritten for each call.
303 */
304const char *
305buildName(const char * dirName, const char * fileName)
306{
307 const char * cp;
308 static char buf[PATH_LEN];
309
310 if ((dirName == NULL) || (*dirName == '\0'))
311 return fileName;
312
313 cp = strrchr(fileName, '/');
314
315 if (cp)
316 fileName = cp + 1;
317
318 strcpy(buf, dirName);
319 strcat(buf, "/");
320 strcat(buf, fileName);
321
322 return buf;
323}
324
325
326
327/*
328 * Expand the wildcards in a fileName wildcard pattern, if any.
329 * Returns an argument list with matching fileNames in sorted order.
330 * The expanded names are stored in memory chunks which can later all
331 * be freed at once. The returned list is only valid until the next
332 * call or until the next command. Returns zero if the name is not a
333 * wildcard, or returns the count of matched files if the name is a
334 * wildcard and there was at least one match, or returns -1 if either
335 * no fileNames matched or there was an allocation error.
336 */
337int
338expandWildCards(const char * fileNamePattern, const char *** retFileTable)
339{
340 const char * last;
341 const char * cp1;
342 const char * cp2;
343 const char * cp3;
344 char * str;
345 DIR * dirp;
346 struct dirent * dp;
347 int dirLen;
348 int newFileTableSize;
349 char ** newFileTable;
350 char dirName[PATH_LEN];
351
352 static int fileCount;
353 static int fileTableSize;
354 static char ** fileTable;
355
356 /*
357 * Clear the return values until we know their final values.
358 */
359 fileCount = 0;
360 *retFileTable = NULL;
361
362 /*
363 * Scan the file name pattern for any wildcard characters.
364 */
365 cp1 = strchr(fileNamePattern, '*');
366 cp2 = strchr(fileNamePattern, '?');
367 cp3 = strchr(fileNamePattern, '[');
368
369 /*
370 * If there are no wildcard characters then return zero to
371 * indicate that there was actually no wildcard pattern.
372 */
373 if ((cp1 == NULL) && (cp2 == NULL) && (cp3 == NULL))
374 return 0;
375
376 /*
377 * There are wildcards in the specified filename.
378 * Get the last component of the file name.
379 */
380 last = strrchr(fileNamePattern, '/');
381
382 if (last)
383 last++;
384 else
385 last = fileNamePattern;
386
387 /*
388 * If any wildcards were found before the last filename component
389 * then return an error.
390 */
391 if ((cp1 && (cp1 < last)) || (cp2 && (cp2 < last)) ||
392 (cp3 && (cp3 < last)))
393 {
394 fprintf(stderr,
395 "Wildcards only implemented for last file name component\n");
396
397 return -1;
398 }
399
400 /*
401 * Assume at first that we are scanning the current directory.
402 */
403 dirName[0] = '.';
404 dirName[1] = '\0';
405
406 /*
407 * If there was a directory given as part of the file name then
408 * copy it and null terminate it.
409 */
410 if (last != fileNamePattern)
411 {
412 memcpy(dirName, fileNamePattern, last - fileNamePattern);
413 dirName[last - fileNamePattern - 1] = '\0';
414
415 if (dirName[0] == '\0')
416 {
417 dirName[0] = '/';
418 dirName[1] = '\0';
419 }
420 }
421
422 /*
423 * Open the directory containing the files to be checked.
424 */
425 dirp = opendir(dirName);
426
427 if (dirp == NULL)
428 {
429 perror(dirName);
430
431 return -1;
432 }
433
434 /*
435 * Prepare the directory name for use in making full path names.
436 */
437 dirLen = strlen(dirName);
438
439 if (last == fileNamePattern)
440 {
441 dirLen = 0;
442 dirName[0] = '\0';
443 }
444 else if (dirName[dirLen - 1] != '/')
445 {
446 dirName[dirLen++] = '/';
447 dirName[dirLen] = '\0';
448 }
449
450 /*
451 * Find all of the files in the directory and check them against
452 * the wildcard pattern.
453 */
454 while ((dp = readdir(dirp)) != NULL)
455 {
456 /*
457 * Skip the current and parent directories.
458 */
459 if ((strcmp(dp->d_name, ".") == 0) ||
460 (strcmp(dp->d_name, "..") == 0))
461 {
462 continue;
463 }
464
465 /*
466 * If the file name doesn't match the pattern then skip it.
467 */
468 if (!match(dp->d_name, last))
469 continue;
470
471 /*
472 * This file name is selected.
473 * See if we need to reallocate the file name table.
474 */
475 if (fileCount >= fileTableSize)
476 {
477 /*
478 * Increment the file table size and reallocate it.
479 */
480 newFileTableSize = fileTableSize + EXPAND_ALLOC;
481
482 newFileTable = (char **) realloc((char *) fileTable,
483 (newFileTableSize * sizeof(char *)));
484
485 if (newFileTable == NULL)
486 {
487 fprintf(stderr, "Cannot allocate file list\n");
488 closedir(dirp);
489
490 return -1;
491 }
492
493 fileTable = newFileTable;
494 fileTableSize = newFileTableSize;
495 }
496
497 /*
498 * Allocate space for storing the file name in a chunk.
499 */
500 str = getChunk(dirLen + strlen(dp->d_name) + 1);
501
502 if (str == NULL)
503 {
504 fprintf(stderr, "No memory for file name\n");
505 closedir(dirp);
506
507 return -1;
508 }
509
510 /*
511 * Save the file name in the chunk.
512 */
513 if (dirLen)
514 memcpy(str, dirName, dirLen);
515
516 strcpy(str + dirLen, dp->d_name);
517
518 /*
519 * Save the allocated file name into the file table.
520 */
521 fileTable[fileCount++] = str;
522 }
523
524 /*
525 * Close the directory and check for any matches.
526 */
527 closedir(dirp);
528
529 if (fileCount == 0)
530 {
531 fprintf(stderr, "No matches\n");
532
533 return -1;
534 }
535
536 /*
537 * Sort the list of file names.
538 */
539 qsort((void *) fileTable, fileCount, sizeof(char *), nameSort);
540
541 /*
542 * Return the file list and count.
543 */
544 *retFileTable = (const char **) fileTable;
545
546 return fileCount;
547}
548
549
550/*
551 * Sort routine for list of fileNames.
552 */
553int
554nameSort(const void * p1, const void * p2)
555{
556 const char ** s1;
557 const char ** s2;
558
559 s1 = (const char **) p1;
560 s2 = (const char **) p2;
561
562 return strcmp(*s1, *s2);
563}
564
565
566
567/*
568 * Routine to see if a text string is matched by a wildcard pattern.
569 * Returns TRUE if the text is matched, or FALSE if it is not matched
570 * or if the pattern is invalid.
571 * * matches zero or more characters
572 * ? matches a single character
573 * [abc] matches 'a', 'b' or 'c'
574 * \c quotes character c
575 * Adapted from code written by Ingo Wilken.
576 */
577BOOL
578match(const char * text, const char * pattern)
579{
580 const char * retryPat;
581 const char * retryText;
582 int ch;
583 BOOL found;
584
585 retryPat = NULL;
586 retryText = NULL;
587
588 while (*text || *pattern)
589 {
590 ch = *pattern++;
591
592 switch (ch)
593 {
594 case '*':
595 retryPat = pattern;
596 retryText = text;
597 break;
598
599 case '[':
600 found = FALSE;
601
602 while ((ch = *pattern++) != ']')
603 {
604 if (ch == '\\')
605 ch = *pattern++;
606
607 if (ch == '\0')
608 return FALSE;
609
610 if (*text == ch)
611 found = TRUE;
612 }
613
614 if (!found)
615 {
616 pattern = retryPat;
617 text = ++retryText;
618 }
619
620 /* fall into next case */
621
622 case '?':
623 if (*text++ == '\0')
624 return FALSE;
625
626 break;
627
628 case '\\':
629 ch = *pattern++;
630
631 if (ch == '\0')
632 return FALSE;
633
634 /* fall into next case */
635
636 default:
637 if (*text == ch)
638 {
639 if (*text)
640 text++;
641 break;
642 }
643
644 if (*text)
645 {
646 pattern = retryPat;
647 text = ++retryText;
648 break;
649 }
650
651 return FALSE;
652 }
653
654 if (pattern == NULL)
655 return FALSE;
656 }
657
658 return TRUE;
659}
660
661
662/*
663 * Take a command string and break it up into an argc, argv list while
664 * handling quoting and wildcards. The returned argument list and
665 * strings are in static memory, and so are overwritten on each call.
666 * The argument list is ended with a NULL pointer for convenience.
667 * Returns TRUE if successful, or FALSE on an error with a message
668 * already output.
669 */
670BOOL
671makeArgs(const char * cmd, int * retArgc, const char *** retArgv)
672{
673 const char * argument;
674 char * cp;
675 char * cpOut;
676 char * newStrings;
677 const char ** fileTable;
678 const char ** newArgTable;
679 int newArgTableSize;
680 int fileCount;
681 int len;
682 int ch;
683 int quote;
684 BOOL quotedWildCards;
685 BOOL unquotedWildCards;
686
687 static int stringsLength;
688 static char * strings;
689 static int argCount;
690 static int argTableSize;
691 static const char ** argTable;
692
693 /*
694 * Clear the returned values until we know them.
695 */
696 argCount = 0;
697 *retArgc = 0;
698 *retArgv = NULL;
699
700 /*
701 * Copy the command string into a buffer that we can modify,
702 * reallocating it if necessary.
703 */
704 len = strlen(cmd) + 1;
705
706 if (len > stringsLength)
707 {
708 newStrings = realloc(strings, len);
709
710 if (newStrings == NULL)
711 {
712 fprintf(stderr, "Cannot allocate string\n");
713
714 return FALSE;
715 }
716
717 strings = newStrings;
718 stringsLength = len;
719 }
720
721 memcpy(strings, cmd, len);
722 cp = strings;
723
724 /*
725 * Keep parsing the command string as long as there are any
726 * arguments left.
727 */
728 while (*cp)
729 {
730 /*
731 * Save the beginning of this argument.
732 */
733 argument = cp;
734 cpOut = cp;
735
736 /*
737 * Reset quoting and wildcarding for this argument.
738 */
739 quote = '\0';
740 quotedWildCards = FALSE;
741 unquotedWildCards = FALSE;
742
743 /*
744 * Loop over the string collecting the next argument while
745 * looking for quoted strings or quoted characters, and
746 * remembering whether there are any wildcard characters
747 * in the argument.
748 */
749 while (*cp)
750 {
751 ch = *cp++;
752
753 /*
754 * If we are not in a quote and we see a blank then
755 * this argument is done.
756 */
757 if (isBlank(ch) && (quote == '\0'))
758 break;
759
760 /*
761 * If we see a backslash then accept the next
762 * character no matter what it is.
763 */
764 if (ch == '\\')
765 {
766 ch = *cp++;
767
768 /*
769 * Make sure there is a next character.
770 */
771 if (ch == '\0')
772 {
773 fprintf(stderr,
774 "Bad quoted character\n");
775
776 return FALSE;
777 }
778
779 /*
780 * Remember whether the quoted character
781 * is a wildcard.
782 */
783 if (isWildCard(ch))
784 quotedWildCards = TRUE;
785
786 *cpOut++ = ch;
787
788 continue;
789 }
790
791 /*
792 * If we see one of the wildcard characters then
793 * remember whether it was seen inside or outside
794 * of quotes.
795 */
796 if (isWildCard(ch))
797 {
798 if (quote)
799 quotedWildCards = TRUE;
800 else
801 unquotedWildCards = TRUE;
802 }
803
804 /*
805 * If we were in a quote and we saw the same quote
806 * character again then the quote is done.
807 */
808 if (ch == quote)
809 {
810 quote = '\0';
811
812 continue;
813 }
814
815 /*
816 * If we weren't in a quote and we see either type
817 * of quote character, then remember that we are
818 * now inside of a quote.
819 */
820 if ((quote == '\0') && ((ch == '\'') || (ch == '"')))
821 {
822 quote = ch;
823
824 continue;
825 }
826
827 /*
828 * Store the character.
829 */
830 *cpOut++ = ch;
831 }
832
833 /*
834 * Make sure that quoting is terminated properly.
835 */
836 if (quote)
837 {
838 fprintf(stderr, "Unmatched quote character\n");
839
840 return FALSE;
841 }
842
843 /*
844 * Null terminate the argument if it had shrunk, and then
845 * skip over all blanks to the next argument, nulling them
846 * out too.
847 */
848 if (cp != cpOut)
849 *cpOut = '\0';
850
851 while (isBlank(*cp))
852 *cp++ = '\0';
853
854 /*
855 * If both quoted and unquoted wildcards were used then
856 * complain since we don't handle them properly.
857 */
858 if (quotedWildCards && unquotedWildCards)
859 {
860 fprintf(stderr,
861 "Cannot use quoted and unquoted wildcards\n");
862
863 return FALSE;
864 }
865
866 /*
867 * Expand the argument into the matching filenames or accept
868 * it as is depending on whether there were any unquoted
869 * wildcard characters in it.
870 */
871 if (unquotedWildCards)
872 {
873 /*
874 * Expand the argument into the matching filenames.
875 */
876 fileCount = expandWildCards(argument, &fileTable);
877
878 /*
879 * Return an error if the wildcards failed to match.
880 */
881 if (fileCount < 0)
882 return FALSE;
883
884 if (fileCount == 0)
885 {
886 fprintf(stderr, "Wildcard expansion error\n");
887
888 return FALSE;
889 }
890 }
891 else
892 {
893 /*
894 * Set up to only store the argument itself.
895 */
896 fileTable = &argument;
897 fileCount = 1;
898 }
899
900 /*
901 * Now reallocate the argument table to hold the file name.
902 */
903 if (argCount + fileCount >= argTableSize)
904 {
905 newArgTableSize = argCount + fileCount + 1;
906
907 newArgTable = (const char **) realloc(argTable,
908 (sizeof(const char *) * newArgTableSize));
909
910 if (newArgTable == NULL)
911 {
912 fprintf(stderr, "No memory for arg list\n");
913
914 return FALSE;
915 }
916
917 argTable = newArgTable;
918 argTableSize = newArgTableSize;
919 }
920
921 /*
922 * Copy the new arguments to the end of the old ones.
923 */
924 memcpy((void *) &argTable[argCount], (const void *) fileTable,
925 (sizeof(const char **) * fileCount));
926
927 /*
928 * Add to the argument count.
929 */
930 argCount += fileCount;
931 }
932
933 /*
934 * Null terminate the argument list and return it.
935 */
936 argTable[argCount] = NULL;
937
938 *retArgc = argCount;
939 *retArgv = argTable;
940
941 return TRUE;
942}
943
944
945/*
946 * Make a NULL-terminated string out of an argc, argv pair.
947 * Returns TRUE if successful, or FALSE if the string is too long,
948 * with an error message given. This does not handle spaces within
949 * arguments correctly.
950 */
951BOOL
952makeString(
953 int argc,
954 const char ** argv,
955 char * buf,
956 int bufLen
957)
958{
959 int len;
960
961 while (argc-- > 0)
962 {
963 len = strlen(*argv);
964
965 if (len >= bufLen)
966 {
967 fprintf(stderr, "Argument string too long\n");
968
969 return FALSE;
970 }
971
972 strcpy(buf, *argv++);
973
974 buf += len;
975 bufLen -= len;
976
977 if (argc)
978 *buf++ = ' ';
979
980 bufLen--;
981 }
982
983 *buf = '\0';
984
985 return TRUE;
986}
987
988
989/*
990 * Allocate a chunk of memory (like malloc).
991 * The difference, though, is that the memory allocated is put on a
992 * list of chunks which can be freed all at one time. You CAN NOT free
993 * an individual chunk.
994 */
995char *
996getChunk(int size)
997{
998 CHUNK * chunk;
999
1000 if (size < CHUNK_INIT_SIZE)
1001 size = CHUNK_INIT_SIZE;
1002
1003 chunk = (CHUNK *) malloc(size + sizeof(CHUNK) - CHUNK_INIT_SIZE);
1004
1005 if (chunk == NULL)
1006 return NULL;
1007
1008 chunk->next = chunkList;
1009 chunkList = chunk;
1010
1011 return chunk->data;
1012}
1013
1014
1015/*
1016 * Duplicate a string value using the chunk allocator.
1017 * The returned string cannot be individually freed, but can only be freed
1018 * with other strings when freeChunks is called. Returns NULL on failure.
1019 */
1020char *
1021chunkstrdup(const char * str)
1022{
1023 int len;
1024 char * newStr;
1025
1026 len = strlen(str) + 1;
1027 newStr = getChunk(len);
1028
1029 if (newStr)
1030 memcpy(newStr, str, len);
1031
1032 return newStr;
1033}
1034
1035
1036/*
1037 * Free all chunks of memory that had been allocated since the last
1038 * call to this routine.
1039 */
1040void
1041freeChunks(void)
1042{
1043 CHUNK * chunk;
1044
1045 while (chunkList)
1046 {
1047 chunk = chunkList;
1048 chunkList = chunk->next;
1049 free((char *) chunk);
1050 }
1051}
1052
1053
1054/*
1055 * Write all of the supplied buffer out to a file.
1056 * This does multiple writes as necessary.
1057 * Returns the amount written, or -1 on an error.
1058 */
1059int
1060fullWrite(int fd, const char * buf, int len)
1061{
1062 int cc;
1063 int total;
1064
1065 total = 0;
1066
1067 while (len > 0)
1068 {
1069 cc = write(fd, buf, len);
1070
1071 if (cc < 0)
1072 return -1;
1073
1074 buf += cc;
1075 total+= cc;
1076 len -= cc;
1077 }
1078
1079 return total;
1080}
1081
1082
1083/*
1084 * Read all of the supplied buffer from a file.
1085 * This does multiple reads as necessary.
1086 * Returns the amount read, or -1 on an error.
1087 * A short read is returned on an end of file.
1088 */
1089int
1090fullRead(int fd, char * buf, int len)
1091{
1092 int cc;
1093 int total;
1094
1095 total = 0;
1096
1097 while (len > 0)
1098 {
1099 cc = read(fd, buf, len);
1100
1101 if (cc < 0)
1102 return -1;
1103
1104 if (cc == 0)
1105 break;
1106
1107 buf += cc;
1108 total+= cc;
1109 len -= cc;
1110 }
1111
1112 return total;
1113}
1114
1115
1116/*
1117 * Read all of the supplied buffer from a file.
1118 * This does multiple reads as necessary.
1119 * Returns the amount read, or -1 on an error.
1120 * A short read is returned on an end of file.
1121 */
1122int
1123recursive( const char *fileName, BOOL followLinks, const char* pattern,
1124 int (*fileAction)(const char* fileName, const struct stat* statbuf),
1125 int (*dirAction)(const char* fileName, const struct stat* statbuf))
1126{
1127 int status;
1128 struct stat statbuf;
1129 struct dirent* next;
1130
1131 if (followLinks)
1132 status = stat(fileName, &statbuf);
1133 else
1134 status = lstat(fileName, &statbuf);
1135
1136 if (status < 0) {
1137 perror(fileName);
1138 return( -1);
1139 }
1140
1141 if (S_ISREG(statbuf.st_mode)) {
1142 if (match(fileName, pattern)) {
1143 if (fileAction==NULL)
1144 fprintf( stdout, "%s\n", fileName);
1145 else
1146 return(fileAction(fileName, &statbuf));
1147 }
1148 }
1149 else if (S_ISDIR(statbuf.st_mode)) {
1150 if (dirAction==NULL) {
1151 DIR *dir;
1152 if (! match(fileName, pattern))
1153 return 1;
1154 dir = opendir(fileName);
1155 if (!dir) {
1156 perror(fileName);
1157 return( -1);
1158 }
1159 while ((next = readdir (dir)) != NULL) {
1160 status = recursive(fileName, followLinks, pattern, fileAction, dirAction);
1161 if (status < 0) {
1162 closedir(dir);
1163 return(status);
1164 }
1165 }
1166 status = closedir (dir);
1167 if (status < 0) {
1168 perror(fileName);
1169 return( -1);
1170 }
1171 }
1172 else
1173 return(dirAction(fileName, &statbuf));
1174 }
1175 return( 1);
1176
1177}
1178
1179
1180
1181/* END CODE */
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 05:33:20 +0000