Merge pull request 'format' (#15) from format into main

Reviewed-on: https://git.robur.coop/robur/mnet/pulls/15

Author: dinosaure

src/ipv6/neighbors.mli

@@ -1,13 +1,14 @@
 (** IPv6 Neighbor Cache.
 
-    The Neighbor Cache ({{:https://www.rfc-editor.org/rfc/rfc4861#section-5.1} RFC 4861 Section 5.1}})
-    stores information about individual neighbors to which traffic has been sent
-    recently. Each entry maps an IPv6 address to its link-layer (MAC) address,
-    along with reachability state used by the Neighbor Unreachability Detection
-    (NUD) algorithm.
-
-    When a packet needs to be sent to a neighbor whose MAC address is unknown,
-    a Neighbor Solicitation is sent and the packet is queued until a Neighbor
+    The Neighbor Cache
+    ({{:https://www.rfc-editor.org/rfc/rfc4861#section-5.1} RFC 4861 Section
+      5.1}) stores information about individual neighbors to which traffic has
+    been sent recently. Each entry maps an IPv6 address to its link-layer (MAC)
+    address, along with reachability state used by the Neighbor Unreachability
+    Detection (NUD) algorithm.
+
+    When a packet needs to be sent to a neighbor whose MAC address is unknown, a
+    Neighbor Solicitation is sent and the packet is queued until a Neighbor
     Advertisement is received. *)
 
 module Packet : sig

unikernels/echo/echo.ml

@@ -1,22 +1,22 @@
 module RNG = Mirage_crypto_rng.Fortuna
 module Hash = Digestif.SHA1
-let ( let@ ) finally fn = Fun.protect ~finally fn
 
+let ( let@ ) finally fn = Fun.protect ~finally fn
 let rng () = Mirage_crypto_rng_mkernel.initialize (module RNG)
 let rng = Mkernel.map rng Mkernel.[]
 
-let source_of_flow ?(close= ignore) flow =
+let source_of_flow ?(close = ignore) flow =
   let init () = (flow, Bytes.create 0x7ff)
   and pull (flow, buf) =
     match Mnet.TCP.read flow buf with
-    | exception _ | 0 -> None
+    | (exception _) | 0 -> None
     | len ->
         let str = Bytes.sub_string buf 0 len in
         Some (str, (flow, buf))
   and stop (flow, _) = close flow in
   Flux.Source { init; pull; stop }
 
-let sink_of_flow ?(close= ignore) flow =
+let sink_of_flow ?(close = ignore) flow =
   let init () = flow
   and push flow str = Mnet.TCP.write flow str; Miou.yield (); flow
   and full = Fun.const false
@@ -31,20 +31,26 @@ let handler flow =
   Option.iter Flux.Source.dispose src;
   Mnet.TCP.close flow
 
-let rec clean_up orphans = match Miou.care orphans with
+let rec clean_up orphans =
+  match Miou.care orphans with
   | None | Some None -> ()
   | Some (Some prm) ->
       let result = Miou.await prm in
-      let fn err = Logs.err (fun m -> m "Unexpected error: %S" (Printexc.to_string err)) in
+      let fn err =
+        Logs.err (fun m -> m "Unexpected error: %S" (Printexc.to_string err))
+      in
       Result.iter_error fn result;
       clean_up orphans
 
-let rec terminate orphans = match Miou.care orphans with
+let rec terminate orphans =
+  match Miou.care orphans with
   | None -> ()
   | Some None -> Mkernel.sleep 100_000_000; terminate orphans
   | Some (Some prm) ->
       let result = Miou.await prm in
-      let fn err = Logs.err (fun m -> m "Unexpected error: %S" (Printexc.to_string err)) in
+      let fn err =
+        Logs.err (fun m -> m "Unexpected error: %S" (Printexc.to_string err))
+      in
       Result.iter_error fn result;
       terminate orphans
 
@@ -62,23 +68,29 @@ let run _quiet (cidrv4, gateway, ipv6) mode =
         match limit with
         | Some limit when limit <= 0 -> ()
         | None | Some _ ->
-          let flow = Mnet.TCP.accept tcp listen in
-          let _ = Miou.async ~orphans @@ fun () -> handler flow in
-          let limit = Option.map pred limit in
-          go orphans listen limit in
+            let flow = Mnet.TCP.accept tcp listen in
+            let _ = Miou.async ~orphans @@ fun () -> handler flow in
+            let limit = Option.map pred limit in
+            go orphans listen limit
+      in
       let orphans = Miou.orphans () in
       go orphans (Mnet.TCP.listen tcp port) limit;
       terminate orphans
   | `Client (edn, length) ->
-      let result = match edn with
+      let result =
+        match edn with
         | `Ipaddr edn -> Mnet_happy_eyeballs.connect_ip he [ edn ]
-        | `Domain domain_name -> Mnet_happy_eyeballs.connect_host he domain_name [ 9000 ] in
-      let flow = match result with
+        | `Domain domain_name ->
+            Mnet_happy_eyeballs.connect_host he domain_name [ 9000 ]
+      in
+      let flow =
+        match result with
         | Ok (_, flow) -> flow
-        | Error (`Msg msg) -> failwith msg in
+        | Error (`Msg msg) -> failwith msg
+      in
       let@ () = fun () -> Mnet.TCP.close flow in
       let buf = Bytes.create 0x7ff in
-      let rec go ctx0 ctx1 rem0 rem1  =
+      let rec go ctx0 ctx1 rem0 rem1 =
         let len = Int.min rem0 (Bytes.length buf) in
         Mirage_crypto_rng.generate_into buf len;
         Mnet.TCP.write flow (Bytes.to_string buf) ~off:0 ~len;
@@ -87,29 +99,27 @@ let run _quiet (cidrv4, gateway, ipv6) mode =
         let len = Mnet.TCP.read flow buf in
         let ctx1 = Digestif.SHA1.feed_bytes ctx1 buf ~off:0 ~len in
         let rem1 = rem1 - len in
-        if rem0 <= 0 && rem1 <= 0
-        then Digestif.SHA1.(get ctx0, get ctx1)
+        if rem0 <= 0 && rem1 <= 0 then Digestif.SHA1.(get ctx0, get ctx1)
         else if rem0 > 0 then go ctx0 ctx1 rem0 rem1
         else (* if rem1 > 0 *)
           let () = Mnet.TCP.shutdown flow `write in
-          remaining (Digestif.SHA1.get ctx0) ctx1 rem1 
+          remaining (Digestif.SHA1.get ctx0) ctx1 rem1
       and remaining hash0 ctx1 rem1 =
         match Mnet.TCP.read flow buf with
-        | 0 -> hash0, Digestif.SHA1.get ctx1
+        | 0 -> (hash0, Digestif.SHA1.get ctx1)
         | len ->
             let ctx1 = Digestif.SHA1.feed_bytes ctx1 buf ~off:0 ~len in
             let rem1 = rem1 - len in
             if rem1 > 0 then remaining hash0 ctx1 rem1
-            else hash0, Digestif.SHA1.get ctx1
+            else (hash0, Digestif.SHA1.get ctx1)
+      in
+      let hash0, hash1 =
+        go Digestif.SHA1.empty Digestif.SHA1.empty length length
       in
-      let hash0, hash1 = go Digestif.SHA1.empty Digestif.SHA1.empty length length in
       if not (Digestif.SHA1.equal hash0 hash1) then exit 1
 
-let run_client _quiet mnet edn length =
-  run _quiet mnet (`Client (edn, length))
-
-let run_server _quiet mnet port limit =
-  run _quiet mnet (`Server (port, limit))
+let run_client _quiet mnet edn length = run _quiet mnet (`Client (edn, length))
+let run_server _quiet mnet port limit = run _quiet mnet (`Server (port, limit))
 
 open Cmdliner
 
@@ -201,44 +211,42 @@ let length =
   value & pos 1 int 4096 & info [] ~doc ~docv:"NUMBER"
 
 let limit =
-  let doc = "Number of clients that the server can handle. Then, it terminates." in
+  let doc =
+    "Number of clients that the server can handle. Then, it terminates."
+  in
   let open Arg in
   value & opt (some int) None & info [ "limit" ] ~doc ~docv:"NUMBER"
 
 let addr =
   let doc = "The address of the echo server." in
-  let parser str = match Ipaddr.with_port_of_string ~default:9000 str with
+  let parser str =
+    match Ipaddr.with_port_of_string ~default:9000 str with
     | Ok (ipaddr, port) -> Ok (`Ipaddr (ipaddr, port))
     | Error _ -> begin
         match Result.bind (Domain_name.of_string str) Domain_name.host with
         | Ok domain_name -> Ok (`Domain domain_name)
-        | Error _ -> error_msgf "Invalid echo server: %S" str end in
+        | Error _ -> error_msgf "Invalid echo server: %S" str
+      end
+  in
   let pp ppf = function
     | `Ipaddr (ipaddr, port) -> Fmt.pf ppf "%a:%d" Ipaddr.pp ipaddr port
-    | `Domain domain_name -> Domain_name.pp ppf domain_name in
+    | `Domain domain_name -> Domain_name.pp ppf domain_name
+  in
   let ipaddr_and_port = Arg.conv (parser, pp) in
   let open Arg in
   required & pos 0 (some ipaddr_and_port) None & info [] ~doc ~docv:"IP:PORT"
 
 let term_server =
   let open Term in
-  const run_server
-  $ setup_logs
-  $ Mnet_cli.setup
-  $ port
-  $ limit
+  const run_server $ setup_logs $ Mnet_cli.setup $ port $ limit
 
 let cmd_server =
   let info = Cmd.info "server" in
   Cmd.v info term_server
 
 let term_client =
   let open Term in
-  const run_client
-  $ setup_logs
-  $ Mnet_cli.setup
-  $ addr
-  $ length
+  const run_client $ setup_logs $ Mnet_cli.setup $ addr $ length
 
 let cmd_client =
   let info = Cmd.info "client" in