管道，鸠占鹊巢

env | grep 2016查路径

捕获.PNG

写代码完成目录拷贝（注：包含子目录）

#include <stdio.h>
#include <string.h>  
#include <errno.h>  //errno
/*open   stat*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h> //read()   write()
/*dir ope*/
#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h> //exit()

#define PER_IO_BYTES 4096

int fileType(mode_t mode)
{
    int ret = -1;
    switch (mode & S_IFMT)
    {
    case S_IFREG:
        ret = 0;
        break;
    case S_IFDIR:
        ret = 1;
        break;
    default:
        ret = -1;
        break;
    }
    return ret;
}

void copyRegFile(const char *pDestPathname
                 , const char *pSrcPathname)
{
    //对形参进行有效性检查
    if (NULL == pDestPathname || NULL == pSrcPathname)
    {
        return;
    }

    int iDestFd = -1;
    //以写的方式打开目标文件，如果不存在则创建
    iDestFd = open(pDestPathname, O_WRONLY | O_CREAT
                   , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (-1 == iDestFd)
    {
        perror("open dest");
        exit(EXIT_FAILURE);
    }
    int iSrcFd = -1;
    //以读的方式打开源文件，如果不存在则创建
    iSrcFd = open(pSrcPathname, O_RDONLY | O_CREAT
                   , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (-1 == iSrcFd)
    {
        perror("open src");
        exit(EXIT_FAILURE);
    }

    unsigned char caBuf[PER_IO_BYTES] = {'\0'};
    int ret = -1;
    //从源文件循环读取数据
    while ((ret = read(iSrcFd, caBuf, PER_IO_BYTES)))
    {
        //判断数据读取成功失败与否
        if (-1 == ret)
        {
            //如果发生的错误是EAGAIN,EINTR
            //需要重新读取数据
            if (EAGAIN == errno || EINTR == errno)
            {
                continue;
            }
            //如果是其他错误，则显示错误信息并且退出程序
            perror("read src");
            //close(iSrcFd);
            //close(iDestFd);
            exit(EXIT_FAILURE);
        }
        //如果返回值为0，表示已读到文件末尾，没有数据可读
        //则文件拷贝结束
        else if (0 == ret)
        {
            break;
        }
        while (1)
        {
            //将读取到的数据写入到目标文件
            ret = write(iDestFd, caBuf, ret);
            if (-1 == ret)
            {
                if (EAGAIN == errno || EINTR == errno)
                {
                    continue;   
                }
                perror("write dest");
                //close(iSrcFd);
                //close(iDestFd);
                exit(EXIT_FAILURE);
            }
            break;
        }
    }
    close(iSrcFd);
    close(iDestFd);
}

void copyDirFile(const char *pDestDirName
                 , const char *pSrcDirName)
{
    if (NULL == pDestDirName || NULL == pSrcDirName)
    {
        return;
    }
    int ret = -1;
    //创建目录
    ret = mkdir(pDestDirName, 0775);
    if (-1 == ret)
    {
        if (EEXIST != errno)
        {
            perror("mkdir");
            exit(EXIT_FAILURE);
        }
    }
    DIR *pDestDir = NULL;
    //打开目标目录
    pDestDir = opendir(pDestDirName);
    if (NULL == pDestDir)
    {
        perror("open dest dir");
        exit(EXIT_FAILURE);
    }
    DIR *pSrcDir = NULL;
    //打开源目录
    pSrcDir = opendir(pSrcDirName);
    if (NULL == pSrcDir)
    {
        perror("open src dir");
        exit(EXIT_FAILURE);
    }
    char caDestFileName[64] = {'\0'};
    char caSrcFileName[64] = {'\0'};
    struct stat fileStat;
    struct dirent *pDirent = NULL;
    pDirent = readdir(pSrcDir);
    int iLen = 0;
    while (NULL != pDirent)
    {
        if (0 != strcmp(pDirent->d_name, "..")
            && 0 != strcmp(pDirent->d_name, "."))
        {
            //拼接路径名
            strcpy(caSrcFileName, pSrcDirName);
            iLen = strlen(pSrcDirName);
            if (pSrcDirName[iLen-1] != '/')
            {
                strcat(caSrcFileName, "/");
            }
            strcat(caSrcFileName, pDirent->d_name);
            printf("%s\n", caSrcFileName);
/********************************************************/
            strcpy(caDestFileName, pDestDirName);
            iLen = strlen(pDestDirName);
            if (pDestDirName[iLen-1] != '/')
            {
                strcat(caDestFileName, "/");
            }
            strcat(caDestFileName, pDirent->d_name);
/********************************************************/
            //获得文件status
            ret = stat(caSrcFileName, &fileStat);
            if (-1 == ret)
            {
                perror("stat");
                exit(EXIT_FAILURE);
            }
            //判断文件的类型
            ret = fileType(fileStat.st_mode);
            switch (ret)
            {
            case 0:
                copyRegFile(caDestFileName, caSrcFileName);
                break;
            case 1:
                copyDirFile(caDestFileName, caSrcFileName);
                break;
            default:
                break;
            }
        }
/********************************************************/
        pDirent = readdir(pSrcDir);
    }
}

int main(int argc, char *argv[])
{
    //copyRegFile(argv[2], argv[1]);
    copyDirFile(argv[2], argv[1]);

    return 0;
}

鸠占鹊巢（execl，ececlp，execv，execvp）

#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    int ret = -1;
    //使用新进程镜像替换当前进程镜像
    //但是当前进程的ID被新进程使用
    //-->鸠占鹊巢，巢还在，鹊变成了鸠
    //第一个参数：可执行文件的路径
    //之后的参数：可执行文件执行的方式
    //ret = execl("/bin/ls", "ls", "/usr/include", "-l", NULL);
    //ret = execl("./test", "test", NULL);
    //ret = execl("/usr/bin/gedit", "gedit", NULL);
    //ret = execl("/usr/bin/gedit", "gedit", "dirCopy.c", NULL);
    //可以不指定需要执行文件的路径
    //启动该执行文件时，到系统默认路径下去找该执行文件
    //若找到了则执行，否则出错返回
    //ret = execlp("gedit", "gedit", "dirCopy.c", NULL);
#if 0
    ret = execlp("myTest", "myTest", NULL);
    printf("ret = %d\n", ret);
    if (-1 == ret)
    {
        perror("execlp");
        return -1;
    }
#endif

    //char *const argv[] = {"ls", "/usr/include", "-l", NULL};
    //ret = execv("/bin/ls", argv);
    char *const argv[] = {"gedit", "dirCopy.c", NULL};
    ret = execvp("gedit", argv);

    return 0;
}

eg：execv

#include <stdio.h>
#include <string.h>
/*fork  exec*/
#include <unistd.h>

int main(int argc, char *argv[])
{
    pid_t pid = -1;
    pid = fork();
    if (pid > 0)  //parent
    {
        while (1) 
        {
            printf("this is parent\n");
            sleep(1);           
        }
    }
    else if (0 == pid)
    {
        //./fe /bin/ls  /usr/include -l
        int ret = -1;
        ret = execv(argv[1], argv+1);
        if (-1 == ret)
        {
            perror("execv");
            return -1;
        }
    }

    return 0;
}

运行结果：

捕获.PNG2.PNG

管道pipe

#include <unistd.h>  //pipe()  fork()
#include <stdio.h>
#include <string.h>

//通过pipe()函数创建的管道属于无名管道
//只能在父子进程间或者子进程间使用
//创建该管道的进程一旦结束，则该无名管道将会被销毁
int main(void)
{
    int pipefd[2] = {-1};
    int ret = -1;
    //创建管道，管道两端描述符存储到pipefd数组中
    //pipefd[0]表示数据流出端，可以从此端读取数据
    //pipefd[1]表示数据进入端，可以往此端写入数据
    ret = pipe(pipefd);
    if (-1 == ret)
    {
        perror("pipe");
        return -1;
    }

    pid_t pid = -1;
    //管道的创建的创建是在内核中，不独立属于进程
    //所以，fork产生子进程是并不会再次创建一个管道
    //只是对管道文件描述符进行了一次拷贝
    pid = fork();
    if (pid > 0)  //parent
    {
        close(pipefd[0]);
        while (1)
        {
            write(pipefd[1], "Hello child", 11);
            sleep(1);
        }
    }
    else if (0 == pid)  //child
    {
        close(pipefd[1]);
        char caBuf[32] = {'\0'};
        while (1)
        {
            memset(caBuf, '\0', sizeof(caBuf));
            read(pipefd[0], caBuf, 11);
            printf("%s\n", caBuf);
            sleep(1);
        }
    }
    else if (-1 == pid)  //fork failed
    {
        perror("fork");
        return -1;
    }   

    return 0;
}

eg:pipe-talk

#include <unistd.h>  //pipe()  fork()
#include <stdio.h>
#include <string.h>

int main(void)
{
    int pipefd[2] = {-1};
    int ret = -1;
    ret = pipe(pipefd);
    if (-1 == ret)
    {
        perror("pipe");
        return -1;
    }

    pid_t pid = -1;
    pid = fork();
    if (pid > 0)  //parent
    {
        int iSign = 0;
        char caBuf[64] = {'\0'};
        while (1)
        {
            memset(caBuf, '\0', sizeof(caBuf));
            if (0 == iSign)
            {
                printf("parent-input data:");
                scanf("%s", caBuf);
                write(pipefd[1], caBuf, strlen(caBuf));
                iSign = 1;
            }
            else if (1 == iSign)
            {
                read(pipefd[0], caBuf, sizeof(caBuf));
                printf("child says:%s\n", caBuf);
                iSign = 0;
            }
            sleep(1);
        }
    }
    else if (0 == pid)  //child
    {
        int iSign = 0;
        char caBuf[64] = {'\0'};
        while (1)
        {
            memset(caBuf, '\0', sizeof(caBuf));
            if (0 == iSign)
            {
                read(pipefd[0], caBuf, sizeof(caBuf));
                printf("parent says:%s\n", caBuf);
                iSign = 1;
            }
            else if (1 == iSign)
            {
                printf("child-input data:");
                scanf("%s", caBuf);
                write(pipefd[1], caBuf, strlen(caBuf));
                iSign = 0;
            }
            sleep(1);
        }
    }
    else if (-1 == pid)  //fork failed
    {
        perror("fork");
        return -1;
    }   

    return 0;
}

运行结果：

3.PNG

模仿终端

#include <stdio.h>
#include <string.h>
/*fork  exec*/
#include <unistd.h>
#include <stdlib.h>  //malloc

char *getInput(char *argv[])
{
    int ret = -1;
    int i = 0;
    char *pData = NULL;
    pData = (char *)malloc(64);
    while (EOF != scanf("%s", pData))
    {
        printf("%s\n", pData);
        argv[i] = pData;
        i++;
        pData = (char *)malloc(64);
    }
    free(pData);
    argv[i] = NULL;
    return NULL;
}

void showArgv(char *argv[])
{
    int i = 0;
    while (NULL != argv[i])
    {
        printf("%s\n", argv[i]);
        i++;
    }
}

int main(void)
{
    char *argv[32] = {NULL};
    while (1)
    {
        printf("MyTermal@sq$");
        getInput(argv);

        pid_t pid = -1;
        pid = fork();
        if (0 == pid)
        {
            int ret = -1;
            ret = execvp(argv[0], argv);
            if (-1 == ret)
            {
                perror("execv");
                return -1;
            }
        }
    }

    return 0;
}

运行结果：

捕获.PNG

atexit

#include <stdio.h>
#include <stdlib.h>  //atexit()
#include <unistd.h>  //_exit()

void fun1()
{
    printf("fun1...\n");
}
void fun2()
{
    printf("fun2...\n");
}
void fun3()
{
    printf("fun3...\n");
}
//进程正常结束时首先在用户态做一些善后工作
//然后进入内核层做一些善后工作

//return 0  exit()  会首先在用户态做一些善后工作，
//                  然后进入内核层做一些善后工作

//_exit() 直接进入内核层做一些善后工作
int main(void)
{
    //atexit注册的函数会在进程正常结束后被执行
    //执行的顺序和注册顺序相反
    atexit(fun1);
    atexit(fun2);
    atexit(fun3);

    _exit(-1);
    //abort(); //已放弃 (核心已转储): 非正常结束
    //exit(-1); //自杀

    printf("Hello World\n");
    return 0;  //寿终正寝
}