correção da aula 7

README.org

@@ -29,3 +29,4 @@ qualquer distribuição.
 - 21.03.2025 [[./aulas/05-controle/README.org][Aula 5: Estruturas de controle de fluxo]] ([[https://youtu.be/9dvDL7FbYKY][vídeo]]) ([[./exercicios/05/README.org][exercícios]])
 - 26.03.2025 [[./aulas/06-vetores/README.org][Aula 6: Vetores]] ([[https://youtu.be/W5TGNQYFs4E][vídeo]]) ([[./exercicios/06/README.org][exercícios]])
 - 28.03.2025 [[./aulas/07-vps/README.org][Aula 7: Vetores, ponteiros e strings]] ([[https://youtu.be/hhySl3ClTLE][vídeo]]) ([[./exercicios/07/README.org][exercícios]])
+- 31.03.2025 [[./aulas/08-processos/README.org][Aula 8: Processos e layout de memória]] ([[https://youtu.be/60bXYVCFoTI][vídeo]]) (sem exercícios)

aulas/08-processos/README.org

@@ -0,0 +1,421 @@
+#+title: Curso Básico da Linguagem C
+#+subtitle: Aula 8: Processos
+#+author: Blau Araujo
+#+startup: show2levels
+#+options: toc:3
+
+* Aula 8: Processos e layout de memória
+
+[[https://youtu.be/60bXYVCFoTI][Vídeo desta aula]]
+
+** Filosofia UNIX
+
+Doug McIlroy, que implementou o conceito de /pipes/ no Unix, resumiu a /filosofia
+UNIX/ em três princípios:
+
+- /Escreva programas que façam apenas uma coisa, mas que a façam bem feita./
+- /Escreva programas que trabalhem juntos./
+- /Escreva programas que manipulem fluxos de texto, pois esta é uma interface universal./
+
+Se repararmos bem, esses princípios de caracterizam perfeitamente o
+desenvolvimento do sistema operacional Unix e a forma como ele foi projetado
+para ser operado.
+
+*Lembre-se...*
+
+Os sistemas operacionais parecidos com o Unix (/Unix-like/) podem ser descritos
+através de seus quatro conjuntos de softwares mais essenciais, o que também se
+aplica ao nosso GNU/Linux:
+
+| Componente                     | Unix/Unix-like                         | GNU/Linux     |
+|--------------------------------+----------------------------------------+---------------|
+| Kernel                         | Unix Kernel, BSD Kernel, etc...        | Linux         |
+| Biblioteca C padrão            | =libc=                                   | =glibc=         |
+| Shell                          | =sh=                                     | =bash=          |
+| Utilitários da base do sistema | Programas como: =cat=, =grep=, =sed=, etc... | GNU Coreutils |
+
+*** Primeiro princípio: especialização
+
+#+begin_quote
+/Escreva programas que façam apenas uma coisa, mas que a façam bem feita./
+#+end_quote
+
+*Separação de atribuições...*
+
+No escopo do sistema como um todo, nós podemos relacionar esse princípio
+com a separação entre o /espaço do kernel/ e o /espaço de usuário/:
+
+- *Espaço do kernel:* região de memória onde o kernel do sistema operacional
+  executa e tem acesso privilegiado a todos os recursos de hardware e software.
+  
+- *Espaço do usuário:* região de memória onde os /processos/ dos programas são
+  executados com permissões restritas e têm o acesso ao hardware intermediado
+  pelo kernel.
+
+*Criação de programas...*
+  
+Para a escrita de programas, nós temos a =libc=, que abstrai as chamadas às
+funções internas do kernel (/chamadas de sistema/, ou /syscalls/) e centenas
+de outras funcionalidades.
+
+*Interface padrão de operação...*
+
+Mesmo no espaço de usuário, o /shell/ se diferencia dos demais programas da
+base do sistema porque, em princípio, é somente através dele que os outros
+programas são executados pelo /usuário/.
+
+#+begin_quote
+O /shell/ é a interface padrão entre o sistema e o usuário que, através de linhas
+de comandos em texto, declara o que quer que seja executado.
+#+end_quote
+
+*Programas para diversas tarefas úteis...*
+
+Finalmente, o usuário tem acesso a dezenas de utilitários da base do sistema,
+cada um com a sua especialidade, para a realização de inúmeros tipos de
+tarefas.
+
+*** Segundo princípio: modularidade
+
+#+begin_quote
+/Escreva programas que trabalhem juntos./
+#+end_quote
+
+Com a especialização, vem a necessidade de fazer com que cada componente do
+sistema, de acordo com suas atribuições, seja projetado para trabalhar com
+outros programas.
+
+*Linha de comandos...*
+
+Para operar o sistema, o usuário tem acesso a um terminal onde seus comandos
+poderão ser digitados e enviados para o shell:
+
+#+begin_example
+  +---------+      +----------+      +---------+      +--------+
+  | TECLADO | ---→ |          | ---→ |  SHELL  | ---→ | KERNEL |
+  +---------+      |          |      +---------+      +--------+
+                   | TERMINAL |                           ↑
+  +---------+      |          |      +---------------+    |
+  | MONITOR | ←--- |          | ←--→ | NOVO PROCESSO | ←--+
+  +---------+      +----------+      +---------------+
+#+end_example
+
+Quando o shell recebe a linha de um comando, ele interpreta o que foi
+digitado e, se for o caso, faz uma /chamada de sistema/ =fork= para que
+o kernel crie uma cópia (/clone/) de seu processo. Em seguida, no processo
+clonado, o shell faz uma chamada de sistema =exec=, para que o kernel
+substitua parte dos dados copiados do processo do shell pelos dados
+do programa que será executado.
+
+*Tarefas complexas...*
+
+Cada utilitário da base do sistema é construído segundo o conceito de
+/interface de linha de comando/, ou CLI. Isso quer dizer que, além das
+suas especialidades, cada um deles é capaz de trocar dados com outros
+programas para que o usuário, a partir de programas simples, seja
+capaz de realizar tarefas complexas.
+
+Por exemplo, digamos que você tenha um arquivo com uma lista de
+pedidos e queira filtrar as compras realizadas em um dado mês. Você
+poderia utilizar o programa =grep=, que é especializado em localizar
+e imprimir linhas de texto a partir de padrões descritos por
+expressões regulares:
+
+#+begin_example
+:~$ grep '03/2025' pedidos.data
+"Maria das Couves", "02/03/2025", "2564", "Porta copos" 
+"Antônio dos Santos", "09/03/2025", "7544", "Toalha de mesa" 
+"João da Silva", "01/03/2025", "3762", "Jogo de 12 talheres" 
+#+end_example
+
+Se, além das linhas impressas, você precisar ordenar o resultado
+pelos nomes dos clientes, o =grep= será insuficiente sozinho, mas
+você pode recorrer ao utilitário =sort= para processar a saída
+produzida pelo =grep= escrevendo apenas um comando:
+
+#+begin_example
+:~$ grep '03/2025' pedidos.data | sort
+"Antônio dos Santos", "09/03/2025", "7544", "Toalha de mesa" 
+"João da Silva", "01/03/2025", "3762", "Jogo de 12 talheres" 
+"Maria das Couves", "02/03/2025", "2564", "Porta copos" 
+#+end_example
+
+*** Terceiro princípio: fluxos de texto
+
+#+begin_quote
+/Escreva programas que manipulem fluxos de texto, pois esta é uma interface universal./
+#+end_quote
+
+Como vimos, até aqui...
+
+- 0 terminal recebe um fluxo de caracteres digitado em um teclado e envia
+  para o shell;
+- O shell interpreta o texto recebido e monta textos correspondendo aos
+  argumentos que serão passados para as chamadas de sistema;
+- O kernel executa a chamada de sistema e cria um novo processo para
+  executar o programa que foi invocado... Mas não é só isso!
+
+Além dos dados do programa (basicamente, o conteúdo de seu binário),
+o novo processo incluirá outros dados que já estavam registrados no
+processo do shell:
+
+- A quantidade de palavras utilizadas para invocar o programa;
+- A lista das palavras utilizadas para invocar o programa;
+- Uma lista das variáveis que serão herdadas pelo novo processo;
+- Uma lista de arquivos padrão que poderão ser utilizados para enviar
+  e receber fluxos de texto. 
+
+Sendo assim...
+
+- As palavras utilizadas para invocar o programa são chamadas de /argumentos
+  de linha de comando/. 
+- A lista de variáveis herdadas pelo programa irão compor um /ambiente de
+  dados/ que poderão ser utilizados pelo programa.
+- A lista de arquivos padrão para receber e enviar fluxos de caracteres para
+  o terminal são os /descritores de arquivos padrão/: =stdin= (entrada padrão),
+  =stdout= (saída padrão) e =stderr= (saída padrão de erros).
+
+Mas existem mecanismos no kernel que possibilitam o desvio dos fluxos de
+dados padrão para outros arquivos. Assim, se eu quiser enviar a saída do
+meu programa para um arquivo, em vez de para o terminal, eu posso redirecionar
+a saída padrão (=stdout=, descritor de arquivos =1=) para esse arquivo:
+
+#+begin_example
+ls -l > arquivos.txt
+#+end_example
+
+Do mesmo modo, eu poderia desviar a saída padrão de um programa para a
+entrada padrão de outro programa. Para isso, o kernel precisaria criar
+um outro tipo de arquivo, chamado de /pipe/, para canalizar o fluxo de
+texto entre os dois programas. Na linha de comandos...
+
+#+begin_example
+:~$ grep '03/2025' pedidos.data | sort
+#+end_example
+
+Nesse caso, os dois programas são executados ao mesmo tempo e, enquanto
+o primeiro envia dados para um /pipe/, o segundo lê este mesmo arquivo:
+
+#+begin_example
+  +-----------------------------+      +------+      +------+
+  | grep '03/2025' pedidos.data | ---> | PIPE | ---> | sort |
+  +-----------------------------+      +------+      +------+
+#+end_example
+
+Assim que o =grep= terminar o envio de linhas de texto, o =sort= será terminado.
+
+** A interface de linha de comando (CLI)
+
+A filosofia Unix nos ajuda a compreender, de um modo mais amplo, como os
+sistemas /Unix-like/ foram pensados para lidar com o hardware, possibilitarem
+a criação e execução de programas e serem operados. Especialmente quanto à
+operação do sistema pela linha de comandos, são as convenções da /interface
+de linha de comandos/ (CLI), implementada no shell, que determinam como
+os programas e o sistema deverão lidar com os nossos comandos.
+
+Um comando simples, seque este esquema geral:
+
+#+begin_example
+[EXPORTAÇÕES] [INVOCAÇÃO] [ARGS...] [REDIRECIONAMENTO ARQUIVO]
+#+end_example
+
+- *Exportações:* uma ou mais variáveis que serão exportadas para o ambiente
+  do processo do programa executado.
+- *Invocação:* o caminho e o nome do programa que será executado.
+- *Argumentos:* lista de palavras que serão passadas para o processo do
+  programa como opções ou informações adicionais.
+- *Redirecionamento:* através de operadores do shell, a saída do programa
+  pode ser desviada para um arquivo ou um arquivo poderá ser informado
+  para ser lido e processado pelo programa.
+
+#+begin_quote
+A /invocação/ (o caminho e o nome do programa) sempre será o primeiro argumento
+da lista de argumentos. 
+#+end_quote
+
+*** Operadores de controle do shell
+
+Quando a linha de um comando contém a invocação de mais de um programa,
+é necessário estabelecer como essas invocações se relacionam, o que é
+feito com os /operadores de controle/ do shell:
+
+- *Encadeamento incondicional* (=;= ou =\n=): O comando seguinte será executado após o
+  término do anterior.
+  
+- *Encadeamento assíncrono* (=&=): O comando seguinte será executado em paralelo com
+  o anterior e em segundo plano.
+
+- *Encadeamento condicional "se sucesso"* (=&&=): O comando seguinte só será
+  executado se, e quando, o último comando executado terminar com sucesso.
+
+- *Encadeamento condicional "se erro"* (=||=): O comando seguinte só será executado
+  se, e quando, o último comando executado terminar com erro.
+
+- *Encadeamento por pipe* (=|=): Os comandos serão executados em paralelo e a saída
+  do primeiro será canalizada para a entrada do segundo.
+
+** O que são processos
+
+Um processo é um conjunto de estruturas de dados que o kernel utiliza para
+gerenciar a execução de programas. No centro dessas estruturas de dados está uma
+faixa virtual contínua de endereços de memória que o kernel designará para cada
+programa em execução. Essa faixa virtual de endereços de memória, também chamada
+de /memória virtual/ ou /espaço de endereços/, representa toda a memória disponível
+a que o processo do programa terá acesso.
+
+Além disso, o kernel disponibiliza todas as informações sobre todos os processos
+em execução na forma de um sistema de arquivos virtual (/procfs/) montado no
+diretório =/proc=. Nele, cada processo terá um subdiretório nomeado segundo seu
+número de identificação (PID).
+
+** Como programas são executados
+
+Para o sistema operacional, /executar um programa/ significa criar um novo processo
+e designar um espaço de memória para ele. Para chegar a este ponto, o programa terá
+que ser invocado por outro programa já em execução (/processo pai/, geralmente o shell)
+que, através de duas chamadas de sistema responsáveis por (chamada =fork=) criar uma
+duplicata do processo pai (um /clone/) como um novo processo e depois substituir parte
+dos dados no espaço de memória dessa duplicata pelos dados encontrados no binário
+do programa que será executado.
+
+Aqui está um exemplo em C que mostra. simplificadamente, a execução de outro programa:
+
+#+begin_src c
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int main(void) {
+    // Chamada fork...
+    pid_t pid = fork();
+    
+    // Se o fork falhar...
+    if (pid < 0) {
+        perror("fork falhou");
+        exit(EXIT_FAILURE);
+    }
+
+    /*
+    Um segundo processo é criado e o código seguinte será executado
+    por ambos os processos (eles são idênticos!), mas com valores
+    de pid diferentes:
+
+    - Para o processo filho, pid == 0
+    - Para o processo pai, pid == PID do processo filho
+
+    Por isso temos essa estrutura if...
+    */
+    if (pid == 0) {
+        // Processo filho...
+        printf("[Filho] PID: %d, iniciado.\n", getpid());
+        char *args[] = {"ls", "-l", NULL};
+        // Chamada exec (execvp)...
+        execvp(args[0], args);
+        // Se execvp falhar...
+        perror("execvp falhou");
+        exit(EXIT_FAILURE);
+    } else {
+        // Processo pai...
+        printf("[Pai] PID: %d, criou filho PID: %d\n", getpid(), pid);
+        printf("[Pai] Aguardando término do filho...\n");
+        int status;
+        waitpid(pid, &status, 0);
+        printf("[Pai] Processo filho %d terminou com status %d\n", pid, WEXITSTATUS(status));
+        printf("[Pai] Voltando ao controle.\n");
+    }
+
+    return 0;
+}
+#+end_src
+
+Compilando e executando:
+
+#+begin_example
+:~$ gcc -Wall exemplo.c
+:~$ ./a.out
+[Pai] PID: 1810185, criou filho PID: 1810186
+[Pai] Aguardando término do filho...
+[Filho] PID: 1810186, iniciado.
+total 56
+-rwxrwxr-x 1 blau blau 16280 mar 22 08:00 analise
+-rw-rw-r-- 1 blau blau  1549 mar 22 08:05 analise.c
+-rwxrwxr-x 1 blau blau 16304 mar 30 11:37 a.out
+-rw-rw-r-- 1 blau blau   594 mar 22 11:22 exemplo.c
+-rw-rw-r-- 1 blau blau   325 mar 22 10:45 fizzbuzz.c
+-rw-rw-r-- 1 blau blau  1743 mar 17 21:32 limites.c
+-rw-rw-r-- 1 blau blau   340 mar 20 14:33 str.c
+-rw-rw-r-- 1 blau blau   882 mar 30 11:37 teste.c
+[Pai] Processo filho 1810186 terminou com status 0
+[Pai] Voltando ao controle.
+#+end_example
+
+#+begin_quote
+No GNU/Linux, o shell chama a /syscall/ =clone=, em vez de =fork=, e =execve=,
+em vez de =execvp=.
+#+end_quote
+
+** Layout de memória
+
+Quando o processo é iniciado, ele recebe uma faixa contínua de endereços /virtuais/
+de memória, segundo o layout abaixo:
+
+#+begin_example
+      ENDEREÇOS MAIS ALTOS
+  +--------------------------+ ---+
+  |      Vetor Ambiente      |    |
+  +--------------------------+    |
+  |     Vetor Argumentos     |    |
+  +--------------------------+  PILHA (STACK)
+  | Quantidade de argumentos |    |
+  +--------------------------+    |
+  |    Dados das funções     |    |
+  +------------+-------------+ ---+
+  |            ↓             |
+  |                          |
+  |            ↑             |
+  +------------+-------------+
+  |                          |  <- Mapeamento de arquivos.
+  |           HEAP           |  <- Bibliotecas dinâmicas.
+  |                          |  <- Alocação dinâmica.
+  +--------------------------+
+  |         .bss             |  Dados globais e estáticos não inicializados.
+  +--------------------------+
+  |         .data            |  Dados globais e estáticos inicializados.
+  +--------------------------+
+  |        .rodata           |  Dados constantes (read only).
+  +--------------------------+
+  |         .text            |  Código do programa.
+  +--------------------------+
+     ENDEREÇOS MAIS BAIXOS
+#+end_example
+
+*** Conteúdo do binário executável
+
+As seções do binário do executável serão copiadas para os segmentos
+mais baixos desse espaço de endereços.
+
+*** Região do HEAP
+
+Acima dos dados do binário, uma grande região é designada para a alocação
+dinâmica de espaços em memória para receber dados processados durante a execução
+do programa: o /heap/. Nesta mesma região, também são carregados os conteúdos
+binários das bibliotecas carregadas dinamicamente, como a =glibc=, o =ld-linux= e
+a biblioteca =vdso=, do kernel.
+
+*** Região da pilha (stack)
+
+Nos endereços mais altos, é configurada uma estrutura de dados chamada /pilha/.
+Como o nome sugere, é uma estrutura onde os dados são "empilhados" uns sobre os
+outros, como numa pilha de pratos.
+
+Na base da pilha, nós encontramos um vetor de strings contendo as variáveis
+exportadas para o processo (vetor ambiente). Imediatamente acima, nós temos
+outro vetor de strings com as palavras utilizadas na linha do comando para
+invocar a execução do programa e, eventualmente, seus argumentos (vetor de
+argumentos ou /parâmetros/). Por último, no topo da pilha, nós encontraremos
+a quantidade de palavras no vetor de argumentos.
+
+Ao longo da execução do programa, os dados das funções que forem chamadas
+serão incluídos no topo da pilha e serão removidos quando elas terminarem.

aulas/08-processos/fork-exec.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int main(void) {
+    // Chamada fork...
+    pid_t pid = fork();
+    
+    // Se o fork falhar...
+    if (pid < 0) {
+        perror("fork falhou");
+        exit(EXIT_FAILURE);
+    }
+
+    /*
+    Um segundo processo é criado e o código seguinte será executado
+    por ambos os processos (eles são idênticos!), mas com valores
+    de pid diferentes:
+
+    - Para o processo filho, pid == 0
+    - Para o processo pai, pid == PID do processo filho
+
+    Por isso temos essa estrutura if...
+    */
+    if (pid == 0) {
+        // Processo filho...
+        printf("[Filho] PID: %d, iniciado.\n", getpid());
+        char *args[] = {"ls", "-l", NULL};
+        // Chamada exec (execvp)...
+        execvp(args[0], args);
+        // Se execvp falhar...
+        perror("execvp falhou");
+        exit(EXIT_FAILURE);
+    } else {
+        // Processo pai...
+        printf("[Pai] PID: %d, criou filho PID: %d\n", getpid(), pid);
+        printf("[Pai] Aguardando término do filho...\n");
+        int status;
+        waitpid(pid, &status, 0);
+        printf("[Pai] Processo filho %d terminou com status %d\n", pid, WEXITSTATUS(status));
+        printf("[Pai] Voltando ao controle.\n");
+    }
+
+    return 0;
+}

aulas/08-processos/mmap/main.c

@@ -0,0 +1,96 @@
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LINE_LEN 256  // Quantidade de bytes para as linhas.
+#define PATH_LEN 256  // Quantidade de bytes para os caminhos. 
+#define PERM_LEN 5    // Quantidade de bytes para as permissões.
+#define PROG_END 5    // Fim das linhas do programa.
+
+typedef unsigned long u64t;
+typedef int i32t;
+
+void read_maps();
+
+int main(void) {
+    read_maps();
+    return 0;
+}
+
+/*
+ * Lê e imprime o conteúdo de /proc/self/maps filtrando
+ * as faixas dos segmentos de memória.
+ */
+void read_maps() {
+    // Define um descritor de arquivos para ler /proc/self/maps...
+    FILE *fd = fopen("/proc/self/maps", "r");
+    
+    // Terminar no caso de erro...
+    if (!fd) {
+        perror("Erro ao abrir /proc/self/maps");
+        exit(EXIT_FAILURE);
+    }
+
+    char line[LINE_LEN];     // Linhas lidas do arquivo.
+    u64t start;              // Endereço inicial.
+    u64t end;                // Endereço final.
+    char perm[PERM_LEN];     // Permissões.
+    char path[PATH_LEN];     // Caminho do arquivo carregado.
+    i32t current_line = 1;   // Linha atual.
+    
+    // Itera as linhas de /proc/self/maps...
+    while (fgets(line, sizeof(line), fd)) {
+
+        // Zera a string em 'path'...
+        path[0] = '\0';
+        
+        /*
+         * Analisa a linha conforme os campos de /proc/self/maps:
+         * ADDR_START-ADDR_END PERM FILE_OFFSET DEVICE INODE FILE_PATH
+         */
+        sscanf(line, "%lx-%lx %4s %*s %*s %*s %255[^\n]", &start, &end, perm, path);
+
+        // Impressão dos segmentos do código...
+        if (current_line <= PROG_END) {
+            printf("0x%lx-0x%lx %s --> ", start, end, perm);
+            switch (current_line) {
+                case 1:
+                    puts("Tabela de cabeçalhos do programa");
+                    break;
+                case 2:
+                    puts("Código do programa (.text)");
+                    break;
+                case 3:
+                    puts("Dados constantes (.rodata)");
+                    break;
+                case 4:
+                    puts("Tabela de dados globais e dinâmicos");
+                    break;
+                case 5:
+                    puts("Variáveis globais e estáticas (.data e .bss)");
+                    break;
+            }
+            current_line++;
+            continue;
+        }
+
+        // Impressão da faixa do HEAP...
+        if (strstr(path, "[heap]")) {
+            printf("0x%lx-0x%lx %s --> [HEAP]\n", start, end, perm);
+            continue;
+        }
+
+        // Impressão da faixa da STACK...
+        if (strstr(path, "[stack]")) {
+            printf("0x%lx-0x%lx %s --> [STACK]\n", start, end, perm);
+            continue;
+        }
+        
+        // Demais linhas com caminho...
+        if (path[0] != '\0') printf("0x%lx-0x%lx %s --> %s\n", start, end, perm, path);
+    }
+    
+    // Fecha o descritor de arquivos...
+    fclose(fd);
+}

exercicios/07/README.org

@@ -0,0 +1,138 @@
+#+title: Curso Básico da Linguagem C
+#+subtitle: Exercícios
+#+author: Blau Araujo
+#+startup: show2levels
+#+options: toc:3
+
+* Exercícios da aula 7: Vetores, ponteiros e strings
+
+- [[../../aulas/07-vps/README.org][Anotações da aula]]
+- [[https://youtu.be/hhySl3ClTLE][Vídeo]]
+
+** 1. Desafio: Função =str_blen=
+
+Crie uma função que retorne um inteiro correspondente ao comprimento em bytes de
+uma string sem incluir o terminador nulo.
+
+*Exemplo de teste...*
+
+#+begin_src c
+#include <stdio.h>
+
+int main(void) {
+
+    char *str = "Olá, mundo!";
+
+    /* \042 é o caractere " em octal na tabela ASCII. */
+    printf("A string \042%s\042 tem %d bytes.\n", str, str_blen(????????));
+    
+    return 0;
+}
+#+end_src
+
+** 2. Pesquise e analise o código
+
+No último exercício, você obteve um número de bytes maior do que a quantidade
+de caracteres do texto em =*str=. Isso acontece porque caracteres acentuados
+são compostos por mais de um byte (caracteres /multibyte/).
+
+O código abaixo implementa a função =str_mblen=, para retornar o número de
+caracteres contando caracteres multibyte como um único caractere:
+
+#+begin_src c
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale.h>
+
+int str_mblen(const char *str) {
+    setlocale(LC_ALL, "");
+    int count = 0;
+    int len;
+    
+    while (*str) {
+        len = mblen(str, MB_CUR_MAX);
+        if (len < 1) break;
+        str += len;
+        count++;
+    }
+
+    return count;
+}
+
+int main() {
+    const char *txt = "Olá, mundo!";
+    
+    printf("Número de caracteres: %d\n", str_mblen(txt));
+
+    return 0;
+}
+#+end_src
+
+Seu objetivo é explicar:
+
+- Como a função =str_mblen= funciona?
+- Como a função =mblen= é utilizada?
+- O que é a macro =MB_CUR_MAX=?
+- Por que foi necessário definir =setlocale=?
+- O que está sendo testado no /loop/ =while (*str)=?
+
+** 3. Desafio: Palavras invertidas
+
+Escreva uma função que inverta a ordem dos caracteres de cada palavra em
+uma string, mas preservando a ordem das palavras.
+
+*Exemplo:*
+
+#+begin_example
+Original --> Maria das Couves
+Inversão --> airaM sad sevuoC
+#+end_example
+
+** 4. Desafio: Função =array_isort=
+
+Escreva a função =array_sort= para organizar, em ordem crescente, os valores em um
+dado vetor de inteiros.
+
+*Vetor para testes...*
+
+#+begin_src c
+int num[] = {3, 7, 5, 9, 3, 2, 0, 4, 1, 6, 8};
+#+end_src
+
+** 5. Desafio: codificador e decodificador ROT13
+
+O método de codificação ROT13 desloca em 13 caracteres à frente no alfabeto cada
+um dos caracteres de um texto.
+
+*Exemplos...*
+
+#+begin_example
+a => n
+b => o
+c => p
+e => r
+t => g (depois de 'z', continua em 'a')
+#+end_example
+
+Seu objetivo é criar as funções =rot13_encode= e =rot13_decode= para, respectivamente,
+codificar e decodificar uma string no método ROT13.
+
+*Requisitos...*
+
+- Não alterar caracteres multibyte.
+- As funções devem apenas imprimir os resultados.
+
+*Referência...*
+
+As suas funções devem se comportar como os comandos abaixo:
+
+#+begin_example
+:~$ echo abacate | tr 'A-Za-z' 'N-ZA-Mn-za-m'
+nonpngr
+:~$ echo avião | tr 'A-Za-z' 'N-ZA-Mn-za-m'
+nivãb
+:~$ echo cvgnatn | tr 'A-Za-z' 'N-ZA-Mn-za-m'
+pitanga
+#+end_example
+