Linux--简单copy程序

1. 测试main函数

#include <stdio.h>
#include <string.h>
#include "copy.h"

int main(int argc, char *argv[])
{
if (argc != 3)
{
printf("usage: %s src dst\n", argv[0]);
return -1;
}

char src[MAX_PATH] = {0};
char dst[MAX_PATH] = {0};
strncpy(src, argv[1], strlen(argv[1]));
strncpy(dst, argv[2], strlen(argv[2]));

int copyResult = copy(src, dst);
if (copyResult == ERROR_SUCCESS_OK)
{
printf("copy complete...\n");
}
else
{
printf("error in copying\n");
specify_error(copyResult, src);
}

return 0;
}

2. copy.h 头文件，定义了几个函数

#ifndef _COPY_H_
#define _COPY_H_

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <dirent.h>
#include <string.h>

#define MAX_PATH 255

//error detail info
enum error_info
{
ERROR_SUCCESS_OK = 0,
ERROR_FILE_NO_EXISTS = -1,
ERROR_FILE_STAT_ERROR = -2,
ERROR_FILE_UNKNOWN_ERROR = -3,
ERROR_FILE_CREATE_ERROR = -4,
ERROR_FILE_OPEN_ERROR = -5,
ERROR_FILE_COPY_WRITE = -6,
ERROR_FILE_COPY_READ = -7,
ERROR_COPY_PATTERN_ERROR = -8,
ERROR_COPY_MKDIR_ERROR = -9
};

enum file_type
{
FILE_DIR = 1,
FILE_REGULAR = 2,
FILE_SOCKET = 3,
FILE_LINK = 4,
FILE_FIFO = 5,
FILE_BLOCK = 6,
FILE_CHAR = 7,
FILE_UNKNOWN = 8,
FILE_NEED_CREATE = 9,

FILE_NOT_EXISTS = 10,
FILE_DIR_NOT_EXISTS = 11
};

enum dir_type
{
DIR_ABSOLUTE = 1,
DIR_RELATIVE = 2
};

int copy(const char *src, const char *dst);
int check_file(const char *file);
int check_file_type(const char *file);
long int get_file_length(const char *file);
int analysis_file(const char *file);
int is_absolute_dir(const char *dir);
void specify_error(int errno, const char *file);
int file_create(const char *file, int flags, mode_t mode);
int core_copy(int srcFileType, const char *src, int dstFileType, const char *dst);
void get_file_name(const char *file, char *fileName);
int core_read_write(const char *src, const char *dst);
int do_dir(const char *src, const char *dst);

#endif //_COPY_H_

3. copy.c文件，小程序支持拷贝文件和目录，只不过拷贝目录是将目录里面的文件拷贝到另外一个目录中，支持嵌套

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <dirent.h>
#include "copy.h"

int copy(const char *src, const char *dst)
{
assert(src != NULL);
assert(dst != NULL);

int srcFileType;
if ((srcFileType = check_file_type(src)) == ERROR_FILE_NO_EXISTS)
{
return ERROR_FILE_NO_EXISTS;
}
else if (srcFileType == FILE_UNKNOWN)
{
return ERROR_FILE_UNKNOWN_ERROR;
}

int dstFileType = analysis_file(dst);
if (dstFileType == FILE_NOT_EXISTS || dstFileType == FILE_DIR_NOT_EXISTS)
{
return ERROR_FILE_NO_EXISTS;
}

if (dstFileType == FILE_NEED_CREATE)
{
if (file_create(dst, 0, 0) < 0)
{
return ERROR_FILE_CREATE_ERROR;
}
dstFileType = FILE_REGULAR;
}

return core_copy(srcFileType, src, dstFileType, dst);
}

int check_file(const char *file)
{
assert(file != NULL);

if (access(file, F_OK) < 0)
{
return FILE_NOT_EXISTS;
}

return ERROR_SUCCESS_OK;
}

int check_file_type(const char *file)
{
assert(file != NULL);

if (check_file(file) < 0)
{
return ERROR_FILE_NO_EXISTS;
}

struct stat fileInfo;
if (stat(file, &fileInfo) < 0)
{
return ERROR_FILE_STAT_ERROR;
}

if (fileInfo.st_mode & S_IFDIR)
{
return FILE_DIR;
}
else if (fileInfo.st_mode & S_IFREG)
{
return FILE_REGULAR;
}
else if (fileInfo.st_mode & S_IFSOCK)
{
return FILE_SOCKET;
}
else if (fileInfo.st_mode & S_IFLNK)
{
return FILE_LINK;
}
else if (fileInfo.st_mode & S_IFIFO)
{
return FILE_FIFO;
}
else if (fileInfo.st_mode & S_IFBLK)
{
return FILE_BLOCK;
}
else if (fileInfo.st_mode & S_IFCHR)
{
return FILE_CHAR;
}
else
{
return FILE_UNKNOWN;
}
}

long int get_file_length(const char *file)
{
assert(file != NULL);

if (check_file(file) < 0)
{
return ERROR_FILE_NO_EXISTS;
}

struct stat fileInfo;
if (stat(file, &fileInfo) < 0)
{
return ERROR_FILE_STAT_ERROR;
}

return (long int)fileInfo.st_size;
}

int analysis_file(const char *file)
{
//1 check file exists
int fileExists = check_file(file);

if (fileExists == ERROR_SUCCESS_OK)
{
int fileType = check_file_type(file);
return fileType;
}

//2 file is not exists
//2.1 check basedir
char file_path[MAX_PATH] = {0};
strncpy(file_path, file, strlen(file));
char *dirPos = strrchr(file_path, '/');
if (dirPos == NULL)
{
//current dir
return FILE_NEED_CREATE;
}

if (dirPos != file_path + strlen(file_path)) //type '/'
{
//create a file then return
dirPos = '\0';
fileExists = check_file(file_path);
if (fileExists == FILE_NOT_EXISTS)
{
return FILE_NOT_EXISTS;
}
else
{
return FILE_NEED_CREATE;
}
}
else
{
return FILE_DIR_NOT_EXISTS;
}
}

int is_absolute_dir(const char *dir)
{
assert(dir != NULL);
if (dir[0] == '/')
{
return DIR_ABSOLUTE;
}
else
{
return DIR_RELATIVE;
}
}

void specify_error(int errno, const char *file)
{
switch(errno)
{
case ERROR_SUCCESS_OK:
{
fprintf(stderr, "file or directory[%s] is ok\n", file);
}
break;
case ERROR_FILE_NO_EXISTS:
{
fprintf(stderr, "file or directory[%s] is not exists\n", file);
}
break;
case ERROR_FILE_STAT_ERROR:
{
fprintf(stderr, "file or directory[%s] stat error, maybe not permits\n", file);
}
break;
case ERROR_FILE_UNKNOWN_ERROR:
{
fprintf(stderr, "file or directory[%s] is unknown type\n", file);
}
break;
case ERROR_FILE_CREATE_ERROR:
{
fprintf(stderr, "create file or directory[%s] error, maybe not permits\n", file);
}
break;
case ERROR_COPY_PATTERN_ERROR:
{
fprintf(stderr, "copy[%s] error, cannot copy a directory to a file\n", file);
}
break;
case ERROR_COPY_MKDIR_ERROR:
{
fprintf(stderr, "mkdir error\n");
}
break;
default:
break;
}
}

int file_create(const char *file, int flags, mode_t mode)
{
assert(file != NULL);

if (mode == 0)
{
mode = 0644;
}

if (flags == 0)
{
flags = O_CREAT | O_RDWR;
}

int fd = open(file, flags, mode);
if (!fd)
{
return ERROR_FILE_CREATE_ERROR;
}

close(fd);
return ERROR_SUCCESS_OK;
}

int core_copy(int srcFileType, const char *src, int dstFileType, const char *dst)
{
assert(src != NULL);
assert(dst != NULL);

if (srcFileType != FILE_DIR)
{
if (dstFileType != FILE_DIR) //file to file
{
return core_read_write(src, dst);
}
else //file to dir
{
char fileName[MAX_PATH] = {0};
get_file_name(src, fileName);
char dirFileName[MAX_PATH] = {0};
strncpy(dirFileName, dst, strlen(dst));
strncat(dirFileName, "/", strlen("/"));
strncat(dirFileName, fileName, strlen(fileName));

if (file_create(dirFileName, 0, 0) < 0)
{
return ERROR_FILE_CREATE_ERROR;
}

return core_read_write(src, dirFileName);
}
}
else
{
if (dstFileType != FILE_DIR)
{
unlink(dst);
return ERROR_COPY_PATTERN_ERROR;
}
else
{
return do_dir(src, dst);
}
}
}

void get_file_name(const char *file, char *fileName)
{
assert(file != NULL);

char *posBegin = strrchr(file, '/');
if (!posBegin)
{
strncpy(fileName, file, strlen(file));
}
else
{
strncpy(fileName, posBegin+1, file + strlen(file) - posBegin);
}
}

int core_read_write(const char *src, const char *dst)
{
int fdSrc = open(src, O_RDONLY);
if (!fdSrc)
{
return ERROR_FILE_OPEN_ERROR;
}
int fdDst = open(dst, O_RDWR | O_TRUNC);
if (!fdDst)
{
return ERROR_FILE_OPEN_ERROR;
}

char buffer[1024] = {0};
ssize_t readSize = 0;
ssize_t writeSize = 0;

while((readSize = read(fdSrc, buffer, sizeof(buffer))) > 0)
{
writeSize = write(fdDst, buffer, readSize);
if (writeSize != readSize)
{
close(fdSrc);
close(fdDst);
unlink(dst);
return ERROR_FILE_COPY_WRITE;
}
memset(buffer, 0, sizeof(buffer));
}

if (readSize < 0)
{
close(fdSrc);
close(fdDst);
unlink(dst);
return ERROR_FILE_COPY_READ;
}

close(fdSrc);
close(fdDst);
return ERROR_SUCCESS_OK;
}

int do_dir(const char *src, const char *dst)
{
DIR * root = opendir(src);
struct dirent *dirInfo = NULL;

while((dirInfo = readdir(root)) != NULL)
{
if (strcmp(dirInfo->d_name, ".") == 0 || strcmp(dirInfo->d_name, "..") == 0)
{
continue;
}

char fileSrcName[MAX_PATH] = {0};
strncpy(fileSrcName, src, strlen(src));
strncat(fileSrcName, "/", strlen("/"));
strncat(fileSrcName, dirInfo->d_name, strlen(dirInfo->d_name));
if (dirInfo->d_type & DT_DIR)
{
char fileDstName[MAX_PATH] = {0};
strncpy(fileDstName, dst, strlen(dst));
strncat(fileDstName, "/", strlen("/"));
strncat(fileDstName, dirInfo->d_name, strlen(dirInfo->d_name));

if (check_file(fileDstName) == FILE_NOT_EXISTS)
{
if (mkdir(fileDstName, 0755) < 0)
{
return ERROR_COPY_MKDIR_ERROR;
}
}
do_dir(fileSrcName, fileDstName);
}
else
{
char fileDstName[MAX_PATH] = {0};
strncpy(fileDstName, dst, strlen(dst));
strncat(fileDstName, "/", strlen("/"));
strncat(fileDstName, dirInfo->d_name, strlen(dirInfo->d_name));

if (file_create(fileDstName, 0, 0) < 0)
{
return ERROR_FILE_CREATE_ERROR;
}

core_read_write(fileSrcName, fileDstName);
}
}
closedir(root);

return ERROR_SUCCESS_OK;
}

可能还不太完善，不能和Linux 的CP比较，纯属娱乐