Step 1: Make sure your OpenWRT image include all the needed packages

Make sure that your OpenWRT at least includes the following packages:

libopenssl hostapd-common wpad-openssl -wpad-basic-wolfssl

Note: wpad-basic-wolfssl is explicitly excluded.

You can easely get your image build using the OpenWRT Firmware Selector.

Step 2: Create wpa_suplicant configuration file

We need to create:

• /etc/config/wpadot1x.conf

ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=root
ap_scan=0
network={
	key_mgmt=IEEE8021X
	eap=PEAP
	identity="username"
	password=""
	anonymous_identity="username"
	pairwise=CCMP
	phase2="auth=MSCHAPV2"
	ca_cert="/etc/config/80211x-CA.pem"
	priority=2
}

Step 3: Attach a script to run wpa_supplicant when the wan interface goes up

Create /etc/hotplug.d/iface/99-ifup-wan as following:

#!/bin/sh
[ "$ACTION" = "ifup" -a "$INTERFACE" = "wan" ] && {
    logger "iface wan up detected..."
    wpa_supplicant -s -t -D wired -B -i eth1 -c /etc/config/wpadot1x.conf
    # Wait 3 s
    sleep 3
    echo "wan ifup -> dhcp releases"
    # Renew DHCP adresses on all the interfaces
    PID=`pidof udhcpc` && kill -SIGUSR1 $PID
}
exit 0

Make the script executable:

chmod +x /etc/hotplug.d/iface/99-ifup-wan

Restart the interface:

ifup wan

Note: eth1 should be replaced with the actual WAN interface.

Note: The CA certificate is optional, but recomanded for security.

Note: If you are looking for UPB’s CA certificate you can download it from here.

On Ubuntu

Create a file /etc/systemd/system/docker-compose-example.service as following:

[Unit]
Description=Docker Compose Application Service
Requires=docker.service
After=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
User=myuser # CHANGE THIS
Group=mygroup # CHANGE THIS
WorkingDirectory=/home/dockermgr/service # CHANGE THIS
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0

[Install]
WantedBy=multi-user.target

On some older systems, Docker Compose might be standalone. In this case, you should change two lines as:

ExecStart=/usr/local/bin/docker-compose up -d
ExecStop=/usr/local/bin/docker-compose down

To start the service use systemctl:

# Autostart systemd service
sudo systemctl enable docker-compose-example.service
# Start systemd service now
sudo systemctl start docker-compose-example.service

Step 1: Make sure your interface is disconnected.

If your network connection is active, you will get the following error:

ifconfig: ioctl (SIOCAIFADDR): Can't assign requested address

Step 2:

Open Terminal and type:

sudo ifconfig en0 ether 12:34:56:78:90:ab

where:

• en0 is the name of the interface
• 12:34:56:78:90:ab is the desired MAC address

Step 1: Make sure you initialized Docker Swarm

docker swarm init

Step 2: Create an external network

docker network create --driver overlay --opt encrypted --attachable --scope "swarm" proxy_net

Step 3: Run nginx-admin as a Swarm service

version: '3.6'
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    networks:
      - proxy_net
    ports:
      - target: 80
        published: 80
        protocol: tcp
        mode: host

      - target: 443
        published: 443
        protocol: tcp
        mode: host

      - "81:81"
    volumes:
      - data:/data
      - letsencrypt:/etc/letsencrypt

volumes:
  data:
  letsencrypt:

networks:
  proxy_net:
    external: true

Use the following snippet to get rid of it:

int enable = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0)
    perror("setsockopt(SO_REUSEADDR) failed");

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <time.h>
#include <unistd.h>

void draw_diagnonal_lines(int count) {
  for (int i = 0; i < count; i++) {
    if (rand() % 2 == 0) {
      printf("╱");
    } else {
      printf("╲");
    }
  }
}

void draw_orizonal_lines(int count) {
  for (int i = 0; i < count; i++)
    printf("─");
}

int main(void) {
  struct winsize w;
  ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

  printf("lines %d\n", w.ws_row);
  printf("columns %d\n", w.ws_col);

  printf("┌");
  draw_orizonal_lines(w.ws_col - 2);
  printf("┐\n");

  srand(time(NULL));
  for (int line = 0; line < w.ws_row - 3; line++) {
    printf("│");
    draw_diagnonal_lines(w.ws_col - 2);
    printf("│");

    puts("");
    // sleep(1);
  }

  printf("└");
  draw_orizonal_lines(w.ws_col - 2);
  printf("┘\n");

  return 0;
}