Recursive Copy Command

1. Recursive Copy Command
3. (CP command with -R argument)
4.  
5. /*Course: system programming  *
6.  *2008-11-24*
7.  */
8. #include <stdio.h>
9. #include <dirent.h>
10. #include <errno.h>
11. #include <sys/stat.h>
12. #include <string.h>
13. #include <fcntl.h>
14. #include <sys/types.h>
15. #include <stdlib.h>
17. #define BUFFER_SIZE 1048576
19. /* copy regular file from src_path to dst_path*/
20. void copy_file(char *src_path, char *dst_path)
21. {
22.         void copy_dir();
23.         int from_fd;
24.         int to_fd;
25.         int bytes_read;
26.         int bytes_write;
27.         char buffer[BUFFER_SIZE];
28.         char *p;
30.         if((from_fd = open(src_path, O_RDONLY)) == -1) { /*open source file and error handler*/
31.                 fprintf(stderr, "Open %s Error:%s/n", src_path, strerror(errno));
32.                 exit(1);
33.         }
35.         if((to_fd = open(dst_path, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR)) == -1) { /*create dst file and error handler*/
36.                 fprintf(stderr,"Open %s Error:%s/n", dst_path, strerror(errno));
37.                 exit(1);
38.         }
40.         while(bytes_read = read(from_fd, buffer, BUFFER_SIZE)) { /* read file buffer from source file */
41.                 if((bytes_read == -1) && (errno != EINTR)) { /* can't read source file */
42.                         fprintf(stderr,"read  %s Error:%s/n", src_path, strerror(errno));
43.                         break;
44.                 }
45.                 else if(bytes_read > 0) {
46.                         p = buffer;
47.                         while(bytes_write = write(to_fd, p, bytes_read)) { /* write buffer into dst file */
48.                                 if((bytes_write == -1) && (errno != EINTR)) {
49.                                         fprintf(stderr,"write %s Error:%s/n", dst_path, strerror(errno));
50.                                         break;
51.                                 }
52.                                 else if(bytes_write == bytes_read) /* for big file, read and write normally done */
53.                                         break;
54.                                 else if(bytes_write > 0) {
55.                                         p += bytes_write;
56.                                         bytes_read -= bytes_write;
57.                                 }
58.                         }
59.                         if(bytes_write == -1) {
60.                                 fprintf(stderr,"write %s Error:%s/n", dst_path, strerror(errno));
61.                                 break;
62.                         }
63.                 }
64.         }
65.         close(from_fd);
66.         close(to_fd);
67. }
70. void copy_dir(char *name, char *dst)
71. {
72.         DIR *dp;
73.         DIR *dp1;
74.         char pp[255];
75.         char pn[255];
76.         int i;
77.         struct stat sbuf;
78.         struct dirent *dir;
80.         if((dp = opendir(name)) == NULL) { /* open src dir,here src is not only the input agrument */
81.                 printf("Open Directory %s Error:%s/n", name, strerror(errno));
82.                 exit(1);
83.                 }
84.         while ((dir = readdir(dp)) != NULL) { /* list all contents(file and dir) of dp dir*/
85.                 if (dir->d_ino=0)  /* nothing exist */
86.                         continue;
87.                      /* get source path and dst path */
88.                 strcpy(pn,name);
89.                 strcat(pn,"/");
90.                 strcat(pn,dir->d_name);
91.                 strcpy(pp,dst);
92.                 strcat(pp,"/");
93.                 strcat(pp,dir->d_name);
94.                 if (lstat(pn,&sbuf) < 0) { /*get stat of source */
95.                         perror(pn);
96.                         closedir(dp);
97.                         exit(1);
98.                 }
99.                                        /* if source is a dir, recursive copying dir*/
100.                 if ( ((sbuf.st_mode & S_IFMT) != S_IFLNK) &&
101.                      ((sbuf.st_mode & S_IFMT) == S_IFDIR) &&
102.                      (strcmp(dir->d_name, ".") != 0) &&
103.                      (strcmp(dir->d_name, "..") != 0) ) {
104.                         if((dp1 = opendir(pn)) == NULL) {
105.                                 printf("Open Directory %s Error:%s/n",pn,strerror(errno));
106.                                 exit(1);
107.                         }
108.                         if((mkdir(pp, 0700)))
109.                                 break;
110.                         copy_dir(pn,pp);
111.                 }
112.                                                /*if souce is a regular file ,copy it */
113.                 else if ( ((sbuf.st_mode & S_IFMT) != S_IFLNK) &&
114.                           ((sbuf.st_mode & S_IFMT) == S_IFREG) &&
115.                           (strcmp(dir->d_name,".") != 0) &&
116.                           (strcmp(dir->d_name, "..") != 0) ) {
117.                            copy_file(pn,pp);
118.                 }
119.         }
120. }
123. int main(int argc,char **argv)
124. {
126.         char *program_name;
127.         DIR *dp;
128.          struct stat stat_src;
129.         struct dirent *dir;
133.         program_name = argv[0];
134.         if(argc != 3) { /*argument check */
135.                 fprintf(stderr,"Usage:%s fromdir todir/n", argv[0]);
136.                 exit(1);
137.                      }
138.         
139.          if (stat(argv[1], &stat_src) != 0 ){    
140.                   printf ("Stat %s Error:%s/n", argv[1], strerror(errno));
141.                   exit(1);
142.                 }
143.          if (S_ISREG(stat_src.st_mode)) /*source is a regular file */
144.              copy_file(argv[1], argv[2]); /*do copy a regular file */
145.            
146.          else if(S_ISDIR(stat_src.st_mode))/* source is directory */
147.                 {
149.         if((dp = opendir(argv[1])) == NULL) { /*open src dir or error handler*/
150.                 printf("Open Directory %s Error:%s/n", argv[1], strerror(errno));
151.                 exit(1);
152.                      }
154.         if((mkdir(argv[2], 0777))) { /* make the dst dir */
155.                 printf("makedir %s is failed /n", argv[2]);
156.                 exit(1);
157.                     }
159.         copy_dir(argv[1], argv[2]); /* do copy a dir */
160.     
161.         closedir(dp);
162.                 }
163.         exit(0);
164. }