# Configurando um Adaptador USB Wireless no Ubuntu Server


Esses dias um amigo me emprestou um NUC (a.k.a. Next Unit of Computing) e decidi
fazer alguns experimentos utilizando o Ubuntu Server 21.04. Durante esse processo,
precisei configurar um Adaptador USB Wireless pois não tinha como conectar o NUC
utilizando um cabo UTP (e.g. CAT5, CAT6). Devido ter algumas informações
não tão fáceis de encontrar ou um passo a passo bem definido, decidi fazer esse
post no intuito de ajudar alguém que eventualmente possa passar por uma
situação parecida.

Nesse post iremos aprender a configurar o acesso a internet por meio de um
Adaptador USB Wireless, mais especificamente o adaptador
[TL-WN725N][adaptador-usb-wireless] no meu caso, considerando que o servidor
não tem disponível uma conexão ethernet.

Durante esse processo, precisaremos lidar com ferramentas como
[wpa_supplicant][wpa-supplicant-homepage], [netplan][netplan-homepage],
[systemd][systemd-homepage], dentre outros.

## Preparando as dependências

Antes de mais nada precisamos baixar os pacotes necessários para construção
e execução do [driver][driver-homepage] para comunicação com o adaptador, e do
[wpa_supplicant][wpa-supplicant-homepage].

Se você tiver outro computador disponível com um Ubuntu, você pode utilizar o
comando `apt-rdepends` para baixar os pacotes principais (`wpasupplicant`,
`make` e `gcc`) e suas dependências de forma recursiva.

e.g.
```bash
$ sudo apt install apt-rdepends

$ for pkg in wpasupplicant make gcc; do
$  apt download $(apt-rdepends "${pkg}" | grep -v "^ " | sed 's/debconf-2.0/debconf/g')
$ done
```

Porém, se você não tem outro computador disponível com um Ubuntu, você pode
baixar os pacotes individualmente [aqui][ubuntu-packages-homepage], utilizando
qualquer dispositivo que tenha a disposição.

Após baixarmos as dependências, precisamos baixar o [driver][driver-homepage]
que iremos utilizar.

O [driver oficial][official-driver-homepage] da TP-Link está em beta e só
suporta as versões de kernel entre 2.6.18 e 4.4.3, porém a versão que estou
utilizando é a 5.11.0. Até tentei construir o driver, mas sem sucesso. Com
isso, decidi seguir com um open source que encontrei e que iremos utilizar mais
a frente. Obrigado ao mantenedor do projeto. :)

```bash
$ git clone git@github.com:lwfinger/rtl8188eu.git
```

Uma vez que possuímos as dependências e o driver, podemos colocá-los em um flash
drive.

{{< admonition >}}
Se estiver utilizando MacOS para montar o flash drive, lembre-se de utilizar
um sistema de arquivos reconhecido pelo Ubuntu (e.g. exFAT).
{{< /admonition >}}

## Instalando as dependências e o driver

Após conectar o flash drive no dispositivo com o Ubuntu Server, você precisará
montar o sistema de arquivos dele em um diretório qualquer para podermos
utilizá-lo.

No entanto, precisamos saber primeiro qual dispositivo de bloco representa nosso
flash drive. Para isso, você pode utilizar o comando `lsblk` para listar os
dispositivos reconhecidos.

A saída será bem parecida com essa:
```text
NAME                      MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
loop0                       7:0    0  55.4M  1 loop /snap/core18/1997
loop1                       7:1    0  68.8M  1 loop /snap/lxd/20037
loop2                       7:2    0  32.3M  1 loop /snap/snapd/11588
sda                         8:0    0 111.8G  0 disk
├─sda1                      8:1    0   512M  0 part /boot/efi
├─sda2                      8:2    0     1G  0 part /boot
└─sda3                      8:3    0 110.3G  0 part
  └─ubuntu--vg-ubuntu--lv 253:0    0  55.1G  0 lvm  /
sdc                         8:32   1  57.3G  0 disk
├─sdc1                      8:33   1   200M  0 part
└─sdc2                      8:34   1  57.1G  0 part
```

Agora podemos montar o sistema de arquivos. Para isso, podemos utilizar o
seguinte comando:
```bash
$ sudo mount /dev/<device> /mnt

# no meu caso
$ sudo mount /dev/sdc2 /mnt
```

Com o sistema de arquivos montado, podemos instalar os pacotes que estão no
flash drive.
```bash
$ cd /mnt

$ sudo dpkg -i *.deb
```

Com as dependências instaladas, podemos agora construir e instalar o driver para
o adaptador USB wireless.

Ele irá gerenciar toda comunicação feita com o nosso adaptador, além disso ele
criará a interface de rede que iremos utilizar posteriormente com o
[wpa_supplicant][wpa-supplicant-homepage].
```bash
$ cd /mnt/rtl8188eu
$ make
$ sudo make install

$ sudo echo “blacklist r8188eu”  >>  /etc/modprobe.d/blacklist.conf
$ sudo modprobe -r r8188eu
```

Lembrando que a cada nova atualização do kernel, após o reboot solicitado, você
precisará instalar o driver novamente. Por isso, é interessante que salve o
repositório do driver em algum diretório local.

e.g.
```bash
$ cd rtl8188eu
$ make clean
$ git pull

$ make
$ sudo make install
```

Com o driver instalado, remova e insira novamente o adaptador USB wireless.

Ao executar o comando `ip a` uma nova interface será exibida, além da de
loopback e a de ethernet.

{{< admonition tip >}}
Caso queira, os logs do driver podem ser obtidos junto com os logs do kernel
utilizando o comando `dmesg`.
{{< /admonition >}}

## Configurando o WPA Supplicant

Após a instalação do driver, podemos agora iniciar a configuração do
[wpa_supplicant][wpa-supplicant-homepage].

Uma explicação rápida sobre o [wpa_supplicant][wpa-supplicant-homepage]: ele é
como o próprio nome diz, um suplicante (IEEE 802.1X Supplicant), ou seja, é o
software que age no lado do cliente e que implementa negociação de chaves com um
autenticador WPA. Ele precisa fornecer credenciais ou certificados para se
autenticar em um autenticador que está do outro lado da rede (roteador no nosso
caso) e conseguir estabeler uma conexão.

Voltando para a sua configuração, o primeiro passo é criar o arquivo que ele
utilizará. Para isso precisaremos do SSID, ou nome da rede, em que iremos
conectar, e a senha.
```bash
$ cd /etc/wpa_supplicant

# Opção 1
$ wpa_passphrase <ssid> <password> >> wpa_supplicant.conf

# Opção 2
$ wpa_passphrase <ssid> >> wpa_supplicant.conf
# Nesse caso ele irá solicitar a senha. Digite-a e pressione ENTER.
```

Após a criação do arquivo de configuração, precisaremos adicionar mais alguns
parâmetros.
```text
country=BR
ctrl_interface=DIR=/run/wpa_supplicant GROUP=netdev
update_config=1

network={
        ssid="<ssid>"
        #psk="<password>"
        psk=<pre-shared-key>
}
```

Ao instalarmos o [wpa_supplicant][wpa-supplicant-homepage], é criado uma
service unit em `/usr/lib/systemd/system/wpa_supplicant.service` para a sua
execução. Precisaremos editar essa unit para adicionar alguns parâmetros ao seu
comando de execução.

Para obter o nome da interface de rede, podemos utilizar o comando `ifconfig`
ou o comando `ip a`.

A flag `-D` indica qual driver (interno do
[wpa_supplicant][wpa-supplicant-homepage]) que iremos utilizar. No meu caso,
precisei utilizar o driver `wext`.
```text
[Unit]
Description=WPA supplicant
Before=network.target
After=dbus.service
Wants=network.target
IgnoreOnIsolate=true

[Service]
Type=dbus
BusName=fi.w1.wpa_supplicant1
ExecStart=/sbin/wpa_supplicant -u -s -O /run/wpa_supplicant -c /etc/wpa_supplicant/wpa_supplicant.conf -d -i <interface-name> -D wext dhclient <interface-name> -t

[Install]
WantedBy=multi-user.target
Alias=dbus-fi.w1.wpa_supplicant1.service
```

Após a modificação da unit precisamos notificar o [systemd][systemd-homepage]
das mudanças e reiniciar o serviço em execução.
```bash
$ sudo systemctl daemon-reload
$ sudo systemctl restart wpa_supplicant.service
```

{{< admonition tip >}}
Para visualizar os logs do serviço podemos utilizar o comando
`journalctl -u wpa_supplicant.service -f`.
{{< /admonition >}}

Podemos verificar o status utilizando o `wpa_cli`.
```bash
$ sudo wpa_cli status
```

> Se você possui mais de um adaptador, ou até mesmo uma placa de rede embutida
> no seu dispositivo, e deseja utilizar ambos, provavelmente você precisará
> configurar uma instância do wpa_supplicant para cada interface de rede
> individualmente.

## Configurando o Netplan

Com o [wpa_supplicant][wpa-supplicant-homepage] configurado, agora iremos
configurar o [netplan][netplan-homepage].

Para isso, basta editarmos o arquivo que fica em `/etc/netplan`, ou criá-lo
caso já não exista. No meu caso, já existia o arquivo `00-installer-config.yaml`,
então apenas o editei.

Precisamos adicionar a seção `wifis` com o seguinte conteúdo.
```yaml
network:
  ...
  wifis:
    "<interface-name>":
      dhcp4: true
      access-points:
        "<ssid>":
          password: "<password>"
```

Após editar o arquivo, basta aplicarmos as mudanças.
```bash
$ sudo netplan generate
$ sudo netplan apply
```

{{< admonition tip >}}
Caso seja necessário, o netplan possui uma flag `--debug` para ajudar durante
um troubleshooting.

Para visualizar os logs do networkd podemos utilizar o comando
`journalctl -u systemd-networkd -f`.
{{< /admonition >}}

Após isso, podemos testar nossa conexão fazendo um `ping` para algum dispositivo
da rede local, ou para algum endereço externo (e.g. google.com).


[adaptador-usb-wireless]: https://www.tp-link.com/br/home-networking/adapter/tl-wn725n
[ubuntu-packages-homepage]: https://packages.ubuntu.com
[official-driver-homepage]: https://www.tp-link.com/br/support/download/tl-wn725n
[driver-homepage]: https://github.com/lwfinger/rtl8188eu
[wpa-supplicant-homepage]: https://hostap.epitest.fi/wpa_supplicant
[netplan-homepage]: https://netplan.io/reference
[systemd-homepage]: https://systemd.io