mix format

.github/workflows/build_test.yml

@@ -0,0 +1,39 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build and test
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Elixir
+      uses: erlef/setup-beam@v1
+      with:
+        elixir-version: '1.16.2'
+        otp-version: '26.2.3'
+    - name: Restore dependencies cache
+      uses: actions/cache@v3
+      with:
+        path: deps
+        key: ${{ runner.os }}-mix-${{ hashFiles('**/mix.lock') }}
+        restore-keys: ${{ runner.os }}-mix-
+    - name: Get dependencies and compile
+        run: |
+          mix deps.get
+          mix compile --warnings-as-errors
+    - name: Verify formatting
+      run: mix format --check-formatted
+    - name: Audit dependencies
+      run: mix hex.audit
+    - name: Run tests
+      run: mix test

lib/peridio/rat.ex

@@ -1,3 +1,2 @@
 defmodule Peridio.RAT do
-
 end

lib/peridio/rat/network.ex

@@ -1,12 +1,12 @@
 defmodule Peridio.RAT.Network do
-
   alias Peridio.RAT.Network.CIDR
 
   @default_cidrs [
-    "172.16.0.0/12",
-    "192.168.0.0/16",
-    "10.0.0.0/8"
-  ] |> Enum.map(&CIDR.from_string!/1)
+                   "172.16.0.0/12",
+                   "192.168.0.0/16",
+                   "10.0.0.0/8"
+                 ]
+                 |> Enum.map(&CIDR.from_string!/1)
 
   @default_ports []
 
@@ -17,15 +17,15 @@ defmodule Peridio.RAT.Network do
     reserved_cidrs = reserved_cidrs()
 
     {reserved, available} =
-      Enum.reduce(cidrs, {[], []}, fn(cidr, {reserved, available}) ->
+      Enum.reduce(cidrs, {[], []}, fn cidr, {reserved, available} ->
         case Enum.filter(reserved_cidrs, &CIDR.contains?(cidr, &1)) do
           [] -> {reserved, [cidr | available]}
           reservations -> {Enum.map(reservations, &{&1, cidr}) ++ reserved, available}
         end
       end)
 
     available_from_reserved =
-      Enum.map(reserved, fn({reservation, cidr}) ->
+      Enum.map(reserved, fn {reservation, cidr} ->
         CIDR.difference(reservation, cidr) |> List.flatten()
       end)
 
@@ -36,14 +36,17 @@ defmodule Peridio.RAT.Network do
     case :inet.getifaddrs() do
       {:ok, addrs} ->
         resp =
-          Enum.reduce(addrs, [], fn(inets_interface, acc) ->
+          Enum.reduce(addrs, [], fn inets_interface, acc ->
             case CIDR.from_inets_interface(inets_interface) do
               {:ok, cidr} -> [cidr | acc]
               _e -> acc
             end
           end)
+
         resp
-      _error -> :error
+
+      _error ->
+        :error
     end
   end
 end

lib/peridio/rat/network/cidr.ex

@@ -1,11 +1,9 @@
 defmodule Peridio.RAT.Network.CIDR do
-  defstruct [
-    ip_start: nil,
-    ip_end: nil,
-    addresses: nil,
-    length: nil,
-    range: nil
-  ]
+  defstruct ip_start: nil,
+            ip_end: nil,
+            addresses: nil,
+            length: nil,
+            range: nil
 
   alias Peridio.RAT.Network.IP
 
@@ -19,17 +17,18 @@ defmodule Peridio.RAT.Network.CIDR do
     {:ok, cidr} = from_inets_interface(inet_if)
     cidr
   end
+
   def from_inets_interface({_if_name, if_opts}) do
     with {:ok, {_, _, _, _} = addr} <- Keyword.fetch(if_opts, :addr),
          {:ok, {_, _, _, _} = mask} <- Keyword.fetch(if_opts, :netmask) do
-
       ip_int = IP.tuple_to_integer(addr)
       mask_int = IP.tuple_to_integer(mask)
       ip_start = find_start_address(ip_int, mask_int)
 
       cidr_length = mask_to_length(mask_int)
       addresses = addresses(cidr_length)
       ip_end = ip_start + (addresses - 1)
+
       cidr =
         %__MODULE__{
           ip_start: IP.integer_to_tuple(ip_start),
@@ -38,6 +37,7 @@ defmodule Peridio.RAT.Network.CIDR do
           length: cidr_length,
           range: ip_start..ip_end
         }
+
       {:ok, cidr}
     else
       e -> {:error, e}
@@ -48,15 +48,16 @@ defmodule Peridio.RAT.Network.CIDR do
     {:ok, cidr} = from_string(cidr_string)
     cidr
   end
+
   def from_string(cidr_string) do
     with [ip_string, length_str] <- String.split(cidr_string, "/", parts: 2),
-          char_list <- String.to_charlist(ip_string),
-          {:ok, ip_start_tuple} <- :inet.parse_address(char_list),
-          {cidr_length, _} <- Integer.parse(length_str) do
-
+         char_list <- String.to_charlist(ip_string),
+         {:ok, ip_start_tuple} <- :inet.parse_address(char_list),
+         {cidr_length, _} <- Integer.parse(length_str) do
       ip_start = IP.tuple_to_integer(ip_start_tuple)
       addresses = addresses(cidr_length)
       ip_end = ip_start + (addresses - 1)
+
       cidr =
         %__MODULE__{
           ip_start: ip_start_tuple,
@@ -65,15 +66,18 @@ defmodule Peridio.RAT.Network.CIDR do
           length: cidr_length,
           range: ip_start..ip_end
         }
+
       {:ok, cidr}
     end
   end
 
   def from_ip_tuple_range({_, _, _, _} = ip_start, {_, _, _, _} = ip_end) do
     from_ip_range(IP.tuple_to_integer(ip_start)..IP.tuple_to_integer(ip_end))
   end
+
   def from_ip_range(_, acc \\ [])
   def from_ip_range(s_ip..e_ip, acc) when s_ip >= e_ip, do: acc
+
   def from_ip_range(ip_start..ip_end = range, acc) do
     max_range_prefix =
       Range.size(range)
@@ -85,7 +89,7 @@ defmodule Peridio.RAT.Network.CIDR do
     min_ip_prefix = ip_prefix_length(ip_start)
     cidr_prefix = max(max_range_prefix, min_ip_prefix)
     addresses = addresses(cidr_prefix)
-    cidr_ip_end = ip_start + (addresses - 1) |> round()
+    cidr_ip_end = (ip_start + (addresses - 1)) |> round()
 
     cidr =
       %__MODULE__{
@@ -95,6 +99,7 @@ defmodule Peridio.RAT.Network.CIDR do
         length: cidr_prefix,
         range: ip_start..cidr_ip_end
       }
+
     from_ip_range((cidr_ip_end + 1)..ip_end, [cidr | acc])
   end
 
@@ -103,25 +108,30 @@ defmodule Peridio.RAT.Network.CIDR do
     mask_int = IP.tuple_to_integer(mask)
     find_start_address(ip_int, mask_int)
   end
-  def find_start_address(ip_int, mask_int), do: (mask_int &&& ip_int)
+
+  def find_start_address(ip_int, mask_int), do: mask_int &&& ip_int
 
   def mask_to_length({a, b, c, d}) do
     <<mask_int::unsigned-integer-size(32)>> = <<a, b, c, d>>
     mask_to_length(mask_int)
   end
+
   def mask_to_length(mask_int) do
     msb_position =
       mask_int
       |> bxor(0xFFFFFFFF)
 
     case msb_position do
-      0 -> 32
+      0 ->
+        32
+
       pos ->
         pos =
           pos
           |> :math.log2()
           |> floor()
           |> round()
+
         32 - (pos + 1)
     end
   end
@@ -139,44 +149,44 @@ defmodule Peridio.RAT.Network.CIDR do
   # r:    [##]
   # ret: []
   def difference(%__MODULE__{range: l_start..l_end}, %__MODULE__{range: r_start..r_end})
-    when (l_start < r_start) and (l_end > r_end) do
+      when l_start < r_start and l_end > r_end do
     []
   end
 
   # l: [###]
   # r:  [###]
   # ret:  [#]
   def difference(%__MODULE__{range: l_start..l_end}, %__MODULE__{range: r_start..r_end})
-    when (l_end < r_end) and (l_start <= r_start) do
+      when l_end < r_end and l_start <= r_start do
     [(l_end + 1)..r_end] |> Enum.map(&from_ip_range/1) |> List.flatten()
   end
 
   # l:    [###]
   # r:   [###]
   # ret: [#]
   def difference(%__MODULE__{range: l_start..l_end}, %__MODULE__{range: r_start..r_end})
-    when (l_end > r_end) and (l_start >= r_start) do
+      when l_end > r_end and l_start >= r_start do
     [(r_end + 1)..l_end] |> Enum.map(&from_ip_range/1) |> List.flatten()
   end
 
   # l:    [##]
   # r:   [####]
   # ret: [#][#]
   def difference(%__MODULE__{range: l_start..l_end}, %__MODULE__{range: r_start..r_end})
-    when (l_start > r_start) and (l_end < r_end) do
-    [r_start..(l_start - 1), (l_end + 1)..r_end]
-    |> Enum.map(&from_ip_range/1) |> List.flatten()
+      when l_start > r_start and l_end < r_end do
+    [r_start..(l_start - 1), (l_end + 1)..r_end] |> Enum.map(&from_ip_range/1) |> List.flatten()
   end
 
   def ip_prefix_length(ip_int) do
     first_lsb = first_set_lsb_position(ip_int)
+
     (:math.pow(2, first_lsb) - 1)
     |> round()
     |> bxor(0xFFFFFFFF)
     |> mask_to_length()
   end
 
-  defp addresses(cidr_length) when is_integer(cidr_length), do: (0x100000000 >>> cidr_length)
+  defp addresses(cidr_length) when is_integer(cidr_length), do: 0x100000000 >>> cidr_length
 
   defp first_set_lsb_position(x) when x > 0 do
     lowest_set_bit = x &&& -x

lib/peridio/rat/network/ip.ex

@@ -1,5 +1,4 @@
 defmodule Peridio.RAT.Network.IP do
-
   def tuple_to_integer({a, b, c, d}) do
     <<ipv4_int::unsigned-integer-size(32)>> = <<a, b, c, d>>
     ipv4_int

lib/peridio/rat/wireguard/interface.ex

@@ -0,0 +1,9 @@
+defmodule Peridio.RAT.WireGuard.Interface do
+  defstruct [
+    :name,
+    :ip_address,
+    :port,
+    :private_key,
+    :public_key
+  ]
+end

lib/peridio/rat/wireguard/peer.ex

@@ -0,0 +1,7 @@
+defmodule Peridio.RAT.WireGuard.Peer do
+  defstruct [
+    :ip_address,
+    :port,
+    :public_key
+  ]
+end