1. O processo "pg-sun", criado através da chamada "fork()" pelo processo "pg-father", recebe como parametros os descritores de 02 arquivos "file1.txt" e "file2.txt" abertos pelo processo pai ("pg-father"). Assim, o processo "pg-sun" não precisará abrir os arquivos para manipula-los, seus descritores já foram passados como parâmetros possibilitam ao processo FILHO manipula-los.

Os códigos referentes aos processos "pg-father.c", "pg-sun.c", "file1.txt" e "file2.txt" estão abaixo descritos, nesta ordem.

  
  /* pg-father.c - instanciacao de um processo "pg-sun" via fork(). */

  /* **************************************** Includes */
  #include 
  #include       // execl, execlp
  #include 
  #include 
  #include 

  /* ************************************************** Main Program */
  int main( int argc, char* argv[] )
  {
    int pid, fd_1, fd_2;
    char str_fd1[16], str_fd2[16];
  
    if( argc != 3 ) {
      printf("Digite: pg-father \"file1.txt\" \"file2.txt\" \n");
      exit(1);
    }

    printf("Programa \"pg-father\" lendo descritores dos arquivos: %s e %s\n",
            argv[1], argv[2] );
  
    fd_1 = open( "file1.txt", O_RDONLY, 0 );
    if( fd_1 == -1 ) {
      printf("Impossivel abrir Arquivo: %s\n", argv[1] );
      exit(1);
    }

    fd_2 = open( "file2.txt", O_RDONLY, 0 );
    if( fd_2 == -1 ) {
      printf("Impossivel abrir Arquivo: %s\n", argv[2] );
      exit(1);
    }

    sprintf( str_fd1, "%d", fd_1 );
    sprintf( str_fd2, "%d", fd_2 );
    printf("Arquivo: %s fd: %s e Arquivo: %s fd: %s\n",
            argv[1], str_fd1, argv[2], str_fd2);

    pid = fork();
    if( pid == 0 )  {  /* Processo Filho */
      execlp( "pg-sun", str_fd1, str_fd2, NULL );
      printf("Error: execlv fault!\n");
      exit(0);
    }
  
    printf("Processo PAI: ... espera Processo FILHO ...\n");
    wait(NULL);  /* Sincroniza com o Proc. Filho */
    exit(0);
  }
 

  
  /* pg-sun.c - instanciacao de um processo via fork() */

  /* **************************************** Includes */
  #include 

  /* ************************************************** Main Program */
  int main( int argc, char* argv[] )
  {
    int fd_1, fd_2;

    sscanf( argv[0], "%d", &fd_1 );
    sscanf( argv[1], "%d", &fd_2 );

    printf("Processo FILHO: arquivos com descritores %d e %d serao
            manipulados!\n", fd_1, fd_2 );
    printf("Processo FILHO: ... processando ...!\n");

    exit(0);
  }
 

  
  /* file1.txt */
  Este é o arquivo 1!
 

  
  /* file2.txt */
  Este é o arquivo 2!
 

2. Os programas no ambiente UNIX não possuem nenhum conhecimento sobre o formato interno no qual o núcleo armazena os dados de arquivo. Os dados são fornecidos pelo UNIX como um "stream" de bytes, cabendo aos programas interpretarem o seu conteúdo. Este tratamento estende-se também aos diretórios, ou seja, estes são vistos como arquivos regulares. O código abaixo ilustra o programa "copy" que copia o conteúdo de um arquivo para outro.

Compile o programa "copy-fl.c" e gere o executável "copy-fl". Edite o arquivo "fl-old.txt" e modifique-o. Em seguida, execute o comando: "copy-fl fl-old.txt fl-new.txt"e observe a saída

  
  /* copy-fl.c - copia o conteudo de um arquivo para outro. */

  /* **************************************** Includes */
  #include 
  #include 
  #include 

  /* **************************************** Global Variables*/
  char buffer[512];

  /* ************************************************** Copy Function */
  void copy( int old, int new )
  {
    int count;
    while( (count = read( old, buffer, sizeof(buffer))) > 0 )
      write( new, buffer, count );
  }

  /* ************************************************** Main Program */
  int main( int argc, char* argv[] )
  {
    int fd_old, fd_new;

    if( argc != 3 ) {
      printf("Digite: \"copy-fl fl-old.txt fl-new.txt\"\n");
      exit(1);
    }

    /* Abre Arquivo para Leitura */
    fd_old = open( argv[1], O_RDONLY );
    if( fd_old == -1 ) {
      printf("Impossivel abrir Arquivo: %s\n", argv[1] );
      exit(1);
    }

    /* Cria Arquivo novo */
    fd_new = open( argv[2], 0666 );
    if( fd_new == -1 ) {
      printf("Impossivel abrir Arquivo: %s\n", argv[2] );
      exit(1);
    }

    /* Chama copy */
    copy( fd_old, fd_new );
    printf("Copia Arquivo \"%s\" para \"%s\". \n", argv[1], argv[2]);
    exit(0);
  }
 

Arquivo "fl-old.txt" do qual os dados serão copiado para o arquivo "fl-new.txt".

  
  /* fl-old.txt - contem caracteres ASCII */
    .... .... .... .... .... ....
    .... .... .... .... .... ....
    .... .... .... .... .... ....
 

  
  /* fl-new.txt - contem caracteres ASCII */
    .... .... .... .... .... ....
    .... .... .... .... .... ....
    .... .... .... .... .... ....