Programação para Redes de Computadores (técnico) (diário 2012-1)

De MediaWiki do Campus São José
Revisão de 00h25min de 19 de junho de 2012 por Etorresini (discussão | contribs) (→‎Projeto Integrador)
(dif) ← Edição anterior | Revisão atual (dif) | Versão posterior → (dif)
Ir para navegação Ir para pesquisar

Sobre a disciplina

  • Horários de atendimento: segundas-feiras das 17:30 às 18:30 e sextas-feiras das 11:30 às 12:30.

Lógica de Programação

27/02

  • Apresentação da disciplina.
  • Linguagem de programação estruturada: instruções, operadores, tipos, alteração do fluxo do código em tempo de execução.
  • Apresentação do ambiente e linguagem Portugol.
  • Primeiro problema em Portugol: dados dois números, verificar se um é múltiplo do outro.
// Início do programa.
inicio

// Pedir o primeiro número.
escrever "Por favor, digite um número natural: "
inteiro primeiroNumero
ler primeiroNumero

// Pedir o segundo número.
escrever "E agora, digite um segundo número natural: "
inteiro segundoNumero
ler segundoNumero

// Calcule se o primeiro é múltiplo do segundo.
inteiro resto
resto <- primeiroNumero % segundoNumero

// Se for, mostre na tela.
se resto = 0 então
    escrever "O primeiro é múltiplo do segundo."
fimse

// Senão, calcule se o segundo é múltiplo do primeiro.
inteiro resto2
resto2 <- segundoNumero % primeiroNumero

// Se for, mostre na tela.
se resto2 = 0 então
    escrever "O segundo é múltiplo do primeiro."
fimse

se resto =/= 0 e resto2 =/= 0 então
    escrever "Não há múltiplos."
fimse

// Fim do programa.
fim
  • Segundo problema: um conversor decimal-binário para números até 255.

05/03

Conversor de decimal para binário utilizando apenas estruturas de decisão: 

inicio
    escrever "Por favor , digite um número entre 0 e 255: "
    inteiro numero
    ler numero
    inteiro resto
    resto <- numero - 128
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 64
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 32
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 16
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 8
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 4
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 2
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
    resto <- numero - 1
    se resto >= 0 entao
        escrever "1"
        numero <- resto
    senao
        escrever "0"
    fimse
fim

Conversor de decimal para binário utilizando estrutura de repetição: 

inicio
    inteiro numero
    inteiro resto
    inteiro expoente   
    escrever "Por favor , digite um número entre 0 e 255: "
    ler numero
    expoente <- 7
    repete
        resto <- numero - ( 2 ^ expoente )
        se resto >= 0 entao
            escrever "1"
            numero <- resto
        senao
            escrever "0"
        fimse
        expoente <- expoente - 1
    ate expoente < 0
fim

Conversor de decimal para binário utilizando estrutura de repetição e validação da entrada: 

inicio
    inteiro numero
    inteiro resto
    inteiro expoente   

    escrever "Por favor , digite um número entre 0 e 255: "
    ler numero
    enquanto (numero < 0) ou (numero > 255) faz
        ler numero
    fimenquanto 

    expoente <- 7
    repete
        resto <- numero - ( 2 ^ expoente )
        se resto >= 0 entao
            escrever "1"
            numero <- resto
        senao
            escrever "0"
        fimse
        expoente <- expoente - 1
    ate expoente < 0
fim

Conversor de decimal para binário com quaisquer casas binárias e divisão em bytes: 

inicio
    inteiro numero
    inteiro resto
    inteiro expoente
    escrever "Por favor , digite um número inteiro: "
    ler numero
    enquanto numero < 0 faz
        escrever "Número inválido! Um número inteiro: "
        ler numero
    fimenquanto
    expoente <- 0
    enquanto numero >= ( 2 ^ ( expoente + 1 ) ) faz
        expoente <- expoente + 1
    fimenquanto
    repete
        resto <- numero - ( 2 ^ expoente )
        se resto >= 0 entao
            escrever "1"
            numero <- resto
        senao
            escrever "0"
        fimse
        se expoente > 0 entao
            resto <- expoente % 8
            se resto = 0 entao
                escrever "."
            fimse
        fimse
        expoente <- expoente - 1
    ate expoente < 0
fim

Linguagens de Programação

Shell Script

12/03

O mesmo problema de verificação de múltiplos: 

#!/bin/bash

# Pedir o primeiro número.
clear
echo -n "Por favor, informe o 1o. número: "
read numero1

# Pedir o segundo número.
echo -n "Agora, digite o 2o. número: "
read numero2

# Calcule se o primeiro é múltiplo do segundo.
resto=$(expr ${numero1} % ${numero2})

# Se for, mostre na tela.
if [ "${resto}" = "0" ]
then
	echo "${numero1} é multiplo de ${numero2}."
else
	echo "${numero1} não é multiplo de ${numero2}."
fi

# Senão, calcule se o segundo é múltiplo do primeiro.
resto=$(expr ${numero2} % ${numero1})

# Se for, mostre na tela.
if [ "${resto}" = "0" ]
then
	echo "${numero2} é multiplo de ${numero1}."
else
	echo "${numero2} não é multiplo de ${numero1}."
fi

Agora com passagem direta dos parâmetros na linha de comando: 

#!/bin/bash

if [ "${2}" = "" ]
then
	echo "Informe pelo menos dois parâmetros."
	echo "Use: ${0} (número) (número)"
	exit
fi
numero1=${1}
numero2=${2}
 
# Calcule se o primeiro é múltiplo do segundo.
resto=$(expr ${numero1} % ${numero2})
 
# Se for, mostre na tela.
if [ "${resto}" = "0" ]
then
	echo "${numero1} é multiplo de ${numero2}."
else
	echo "${numero1} não é multiplo de ${numero2}."
fi
 
# Senão, calcule se o segundo é múltiplo do primeiro.
resto=$(expr ${numero2} % ${numero1})

# Se for, mostre na tela.
if [ "${resto}" = "0" ]
then
	echo "${numero2} é multiplo de ${numero1}."
else
	echo "${numero2} não é multiplo de ${numero1}."
fi

O mesmo problema de conversão: 

#!/bin/bash

# Testa se o usuário digitou um parâmetro
if [ "${1}" = "" ]
then
	# O parâmetro ${0} é o próprio comando
	echo "Use: ${0} (número)"
	exit
fi
numero=${1}

# Testa se o parâmetro é um número
soma=$(echo "${numero} + 1" | bc)
# Se a soma for zero (o parâmetro é inválido)
# 					E
# o parâmetro é diferente de zero (para afetar a soma)
if [ "${soma}" = "1" -a "${numero}" != "0" ]
then
	echo "O parâmetro informado não é número. Tente novamente."
	exit
fi

expoente="0"
while [ "${numero}" -ge "$(echo "2 ^ (${expoente} + 1)" | bc)" ]
do
	expoente=$(echo "${expoente} + 1" | bc)
done

while [ ${expoente} -ge 0 ]
do
	resto=$(echo "${numero} - 2 ^ ${expoente}" | bc)
#   se resto >= 0 entao
	if [ "${resto}" -ge "0" ]
	then
#       escrever "1"
		echo -n "1"
#       numero <- resto
		numero=${resto}
#   senao
	else
#   	escrever "0"
		echo -n "0"
#   fimse
	fi
#   se expoente > 0 entao
	if [ "${expoente}" -gt "0" ]
	then
#       resto <- expoente % 8
		resto=$(echo "${expoente} % 8" | bc)
#       se resto = 0 entao
		if [ "${resto}" = "0" ]
		then
#           escrever "."
			echo -n "."
#       fimse
		fi
#   fimse
	fi
#   expoente <- expoente - 1
	expoente=$(echo "${expoente} - 1" | bc)
done
echo ""

26/03

#!/bin/bash

# Declaração de função: verifica se um byte é válido (>=0 e <=255)
byteValido(){
	if [ "${1}" -ge "0" -a "${1}" -le "255" ]
	then
		echo "sim"
	else
		echo "não"
	fi
}

# Declaração de função: verifica IP
verificaIP(){
	primeiroOcteto=$(echo ${1} | cut -d . -f 1)
	segundoOcteto=$( echo ${1} | cut -d . -f 2)
	terceiroOcteto=$(echo ${1} | cut -d . -f 3)
	quartoOcteto=$(  echo ${1} | cut -d . -f 4)
	resposta=$(byteValido ${primeiroOcteto})
	if [ "${resposta}" = "sim" ]
	then
		resposta=$(byteValido ${segundoOcteto})
		if [ "${resposta}" = "sim" ]
		then
			resposta=$(byteValido ${terceiroOcteto})
			if [ "${resposta}" = "sim" ]
			then
				resposta=$(byteValido ${quartoOcteto})
				if [ "${resposta}" = "sim" ]
				then
					echo "sim"
				else
					echo "não"
				fi
			else
				echo "não"
			fi
		else
			echo "não"
		fi		
	else
		echo "não"
		exit
	fi
}


# Verifica se o usuário digitou pelo menos dois parâmetros
if [ "${1}" = "" -o "${2}" = "" ]
then
	# O usuário não digitou corretamente
	echo "Use: ${0} (IP) (máscara)"
	exit
fi

resposta=$(verificaIP ${1})
if [ "${resposta}" = "sim" ]
then
	resposta=$(verificaIP ${2})
	if [ "${resposta}" = "sim" ]
	then
		echo "Parâmetros dentro dos limites."
	else
		echo "Máscara de rede inválida. Tente novamente."
		exit
	fi
else
	echo "Endereço IP inválido. Tente novamente."
	exit
fi

# A partir de agora, informar os comandos com:
# - Endereço de 'broadcast';
# - Endereço de rota-padrão
echo ""
echo "O comando para configurar IP, máscara de rede e 'broadcast' é:"
broadcast=$(echo ${1} | cut -d . -f 1,2,3)".255"
echo "ifconfig eth0 ${1} netmask ${2} broadcast ${broadcast}"
echo ""
echo "E o comando para configurar rota padrão:"
roteador=$(echo ${1} | cut -d . -f 1,2,3)".254"
echo "route add default gw ${roteador}"

# Depois, o arquivo de configuração
echo ""
echo "O arquivo de configuração da interface fica assim:"
echo "auto eth0"
echo "iface eth0 inet static"
echo "    address ${1}"
echo "    netmask ${2}"
echo "    broadcast ${broadcast}"
echo "    gateway ${roteador}"

Projeto da disciplina

Neste semestre será desenvolvido um instalador assistente de servidor baseado em Debian/Ubuntu. Serão utilizados os seguintes arquivos:

Para descarregar os arquivos: 

[ -f /etc/assistente.conf ] && mv /etc/assistente.conf /etc/assistente.conf-original
wget -P /etc http://tele.sj.ifsc.edu.br/~etorresini/prc20121/assistente.conf
chmod 644 /etc/assistente.conf

[ -f /etc/assistente.funcoes ] && mv /etc/assistente.funcoes /etc/assistente.funcoes-original
wget -P /etc http://tele.sj.ifsc.edu.br/~etorresini/prc20121/assistente.funcoes
chmod 644 /etc/assistente.funcoes

[ -f /usr/local/sbin/assistente ] && mv /usr/local/sbin/assistente /usr/local/sbin/assistente-original
wget -P /usr/local/sbin http://tele.sj.ifsc.edu.br/~etorresini/prc20121/assistente
chmod 755 /usr/local/sbin/assistente

16/04

  • Trabalhando mais com estruturas de decisão e repetição: testador de número (par, ímpar, primo ou perfeito)
#!/bin/bash

qualidade()
{
    CONTADOR="0"
    for divisor in $(seq 1 $(expr $1 - 1))
    do  
        RESTO=$(echo ${1} % ${divisor}| bc)
        if [ "${RESTO}" = "0" ]
        then
            CONTADOR=$(expr ${CONTADOR} + ${divisor})
        fi  
    done
    case ${CONTADOR} in
        "1")
            echo "primo"
            ;;  
        "${1}")
            echo "perfeito"
            ;;  
        *)  
            echo ""
            ;;  
    esac
}

coluna1="1"
while [ "${coluna1}" -le "10" ]
do
    coluna2="1"
    while [ "${coluna2}" -le "10" ]
    do
        #   
        # Mostra as colunas de combinação
        echo -n "${coluna1} * ${coluna2} = "
        #   
        # Multiplica as colunas
        OPERACAO=$(echo "${coluna1} * ${coluna2}" | bc)
        #   
        # Verifica se o número é primo ou perfeito
        # Se não for, verifica-se se é par ou ímpar
        QUALIDADE=$(qualidade ${OPERACAO})
        if [ "${QUALIDADE}" != "" ]
        then
            RESTO=${QUALIDADE}
        else
            RESTO=$(echo "${OPERACAO} % 2" | bc)
        fi  
        case "${RESTO}" in
            "0")
                echo -e "${OPERACAO}\tpar"
                ;;
            "1")
                echo -e "${OPERACAO}\tímpar"
                ;;
            "primo")
                echo -e "${OPERACAO}\tprimo"
                ;;
            "perfeito")
                echo -e "${OPERACAO}\tperfeito"
                ;;
        esac
        coluna2=$(expr ${coluna2} + 1)
    done
    coluna1=$(expr ${coluna1} + 1)
done

23/04

  • Uma calculadora simples, com as 4 operações básicas:
#!/bin/bash

numeroValido(){
	RESULTADO=$(echo "${1} + 2" | bc)
	if [ "${1}" != "0" -a "${RESULTADO}" = "2" ]
	then
		echo "inválido"
	else
		echo "válido"
	fi
}

if [ "${3}" = "" ]
then
	echo "Use: ${0} (número) (operador) (número)"
	exit
fi

TESTE1=$(numeroValido ${1})
TESTE3=$(numeroValido ${3})
if [ "${TESTE1}" = "válido" -a "${TESTE3}" = "válido" ]
then
	case ${2} in
		"+")
			echo "scale=2; ${1} + ${3}" | bc
			;;
		"-")
			echo "scale=2; ${1} - ${3}" | bc
			;;
		"*")
			echo "scale=2; ${1} * ${3}" | bc
			;;
		"/")
			echo "scale=2; ${1} / ${3}" | bc
			;;
		*)
			echo "Operador inválido. Tente novamente."
			;;
	esac
else
	echo "Operando inválido. Tente novamente."
fi
  • Apresentando uma palavra ou número com caixa de decoração (e aproveitando a função numeroValido() do script anterior:
#!/bin/bash

numeroValido(){
	RESULTADO=$(echo "${1} + 2" | bc)
	if [ "${1}" != "0" -a "${RESULTADO}" = "2" ]
	then
		echo "inválido"
	else
		echo "válido"
	fi
}

linha(){
	echo -n "${2}"
	for caracter in $(seq 1 ${1})
	do
		echo -n "${3}"
	done
	echo "${2}"
}

if [ "${1}" = "" ]
then
	echo "Use: ${0} (palavra)"
fi

TESTE=$(numeroValido ${1})
TAMANHO=$(expr $(echo -n ${1} | wc -c) + 2)

if [ "${TESTE}" = "válido" ]
then
	linha ${TAMANHO} "!" "#"
	echo "| ${1} |"
	linha ${TAMANHO} "!" "#"
else
	linha ${TAMANHO} "*" "-"
	echo "| ${1} |"
	linha ${TAMANHO} "*" "-"
fi
  • Desenho de um losango na CLI:
#!/bin/bash

PONTOS="1"
while [ "${PONTOS}" -lt "${1}" ]
do
	ESPACOS=$(expr $(expr ${1} - ${PONTOS}) / 2)
	for espaco in $(seq 1 ${ESPACOS})
	do
		echo -n " "
	done
	for ponto in $(seq 1 ${PONTOS})
	do
		echo -n "*"
	done
	echo ""
	PONTOS=$(expr ${PONTOS} + 2)
done
while [ "${PONTOS}" -ge "1" ]
do
	ESPACOS=$(expr $(expr ${1} - ${PONTOS}) / 2)
	for espaco in $(seq 1 ${ESPACOS})
	do
		echo -n " "
	done
	for ponto in $(seq 1 ${PONTOS})
	do
		echo -n "*"
	done
	echo ""
	PONTOS=$(expr ${PONTOS} - 2)
done

04/06

Normalmente, a geração de um certificado auto-assinado requer a interação do usuário para informar valores como país, Estado, etc. Para automatizar esse passo, pode-se usar um arquivo com tais valores já discriminados. Seguem os passos:

  • Crie um arquivo de configuração do certificado, informando os parâmetros no item [certificate_authority]. No caso, esse possui o nome config.txt:
[req]
prompt = no
distinguished_name = certificate_authority
default_bits = 2048
x509_extensions = v3_ca

[certificate_authority]
countryName = SC
stateOrProvinceName = Santa Catarina
localityName = Sao Jose
organizationName = IFSC
emailAddress = administrador@sj.ifsc.edu.br
commonName = "www.sj.ifsc.edu.br"

[v3_ca]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer:always
basicConstraints = CA:true
  • Em seguida, use esse arquivo para gerar o certificado (cert.pem) auto-assinado:
openssl req -nodes -new -days 365 -out cert.pem -keyout cert.pem -config config.txt

Avaliação

Serão duas avaliações do projeto:

  • 30/04: até o estado do projeto na aula anterior.
  • 11/06: TODO o projeto.

Publicação dos conceitos: em tabela.

Projeto Integrador

Iniciado em 15 de junho deste ano.

Referências


Voltar para página principal da disciplina

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Programação_para_Redes_de_Computadores_(técnico)_(diário_2012-1)&oldid=44871”