Add network syscalls

doc/lisp.md

@@ -65,6 +65,7 @@ MOROS Lisp is a Lisp-1 dialect inspired by Scheme, Clojure, and Ruby!
 - `let`
 - `string.join` (aliased to `str.join`), `lines`, `words`, `chars`
 - `regex.match?`
+- `socket.connect`, `socket.listen`, `socket.accept`
 
 ### File Library
 - `read`, `write`, `append`
@@ -199,3 +200,4 @@ language and reading from the filesystem.
 
 ### Unreleased
 - Add file, number, string, and regex namespaces
+- Add socket functions

doc/network.md

@@ -61,14 +61,14 @@ The `dhcp` command configures the network automatically:
 The `host` command performs DNS lookups:
 
     > host example.com                                                                                 
-    example.com has address 93.184.216.34
+    93.184.216.34
 
 
 ## TCP
 
 The `tcp` command connects to TCP sockets:
 
-    > tcp time.nist.gov 13 --verbose
+    > tcp time.nist.gov:13 --verbose
     DEBUG: Connecting to 129.6.15.30:13
 
     58884 20-02-05 19:19:42 00 0 0  49.2 UTC(NIST) *
@@ -101,18 +101,16 @@ like the `netcat` command on Unix.
 
 For example the request made with `tcp` above is equivalent to this:
 
-    > socket time.nist.gov 13 --read-only
+    > socket time.nist.gov:13 --read-only
 
     59710 22-05-11 21:44:52 50 0 0 359.3 UTC(NIST) *
 
 And the request made with `http` is equivalent to that:
 
-    > socket moros.cc 80 --prompt
-    MOROS Socket v0.1.0
+    > socket moros.cc:80
+    GET /test.html HTTP/1.0
+    Host: moros.cc
 
-    > GET /test.html HTTP/1.0
-    > Host: moros.cc
-    > 
     HTTP/1.1 200 OK
     Server: nginx
     Date: Wed, 11 May 2022 21:46:34 GMT
@@ -136,27 +134,24 @@ And the request made with `http` is equivalent to that:
 
 Here's a connexion to a SMTP server to send a mail:
 
-    > socket 10.0.2.2 2500 --prompt
-    MOROS Socket v0.1.0
-
+    > socket 10.0.2.2:2500
     220 EventMachine SMTP Server
-    > EHLO moros.cc
+    HELO moros.cc
     250-Ok EventMachine SMTP Server
-    250-NO-SOLICITING
-    250 SIZE 20000000
-    > MAIL FROM:<vinc@moros.cc>
-    > RCPT TO:<alice@example.com>
+    MAIL FROM:<vinc@moros.cc>
     250 Ok
+    RCPT TO:<alice@example.com>
     250 Ok
-    > DATA
+    DATA
     354 Send it
-    > Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum nec
-    > diam vitae ex blandit malesuada nec a turpis.
-    > .
-    > QUIT
+    Subject: Test
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum nec
+    diam vitae ex blandit malesuada nec a turpis.
+    .
     250 Message accepted
+    QUIT
     221 Ok
 
 Sending a file to a server:
 
-    > socket 10.0.2.2 1234 <= /tmp/alice.txt
+    > socket 10.0.2.2:1234 <= /tmp/alice.txt

doc/shell.md

@@ -100,15 +100,15 @@ file while the standard error is kept:
     > time read foo.txt => /dev/null
 
 The standard output is implied as the source of a redirection, but it is
-possible to explicitly redirect a file handle to another (TODO):
+possible to explicitly redirect a handle to another (TODO):
 
     > time read foo.txt [1]=>[3]
 
-Or to redirect a file handle to a file:
+Or to redirect a handle to a file:
 
     > time read foo.txt [1]=> bar.txt
 
-Or to pipe a file handle to another command:
+Or to pipe a handle to another command:
 
     > time read foo.txt [1]-> write bar.txt
 
@@ -125,7 +125,7 @@ Redirections should be declared before piping (TODO):
 
     > write <= req.txt => /net/http/moros.cc -> find --line href -> sort
 
-NOTE: The following file handles are available when a process is created:
+NOTE: The following handles are available when a process is created:
 
 - `stdin(0)`
 - `stdout(1)`

doc/syscalls.md

@@ -69,3 +69,21 @@ The system will reboot with `0xcafe` and halt with `0xdead`.
 ```rust
 pub fn sleep(seconds: f64)
 ```
+
+## CONNECT (0xC)
+
+```rust
+pub fn connect(handle, usize, addr: &str, port: u16) -> isize
+```
+
+## LISTEN (0xD)
+
+```rust
+pub fn listen(handle, usize, port: u16) -> isize
+```
+
+## ACCEPT (0xE)
+
+```rust
+pub fn accept(handle, usize, addr: &str) -> isize
+```

src/api/fs.rs

@@ -9,9 +9,14 @@ use alloc::vec;
 
 pub use crate::sys::fs::{FileInfo, DeviceType};
 
+#[derive(Clone, Copy)]
+pub enum IO { Read, Write }
+
 pub trait FileIO {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, ()>;
     fn write(&mut self, buf: &[u8]) -> Result<usize, ()>;
+    fn close(&mut self);
+    fn poll(&mut self, event: IO) -> bool;
 }
 
 pub fn dirname(pathname: &str) -> &str {

src/api/syscall.rs

@@ -1,8 +1,12 @@
+use crate::api::fs::IO;
 use crate::api::process::ExitCode;
 use crate::syscall;
 use crate::sys::syscall::number::*;
 use crate::sys::fs::FileInfo;
 
+use smoltcp::wire::IpAddress;
+use smoltcp::wire::Ipv4Address;
+
 pub fn exit(code: ExitCode) {
     unsafe { syscall!(EXIT, code as usize) };
 }
@@ -106,6 +110,51 @@ pub fn halt() {
     stop(0xdead);
 }
 
+pub fn poll(list: &[(usize, IO)]) -> Option<(usize, IO)> {
+    let ptr = list.as_ptr() as usize;
+    let len = list.len();
+    let idx = unsafe { syscall!(POLL, ptr, len) } as isize;
+    if 0 <= idx && idx < len as isize {
+        Some(list[idx as usize])
+    } else {
+        None
+    }
+}
+
+pub fn connect(handle: usize, addr: IpAddress, port: u16) -> Result<(), ()> {
+    let buf = addr.as_bytes();
+    let ptr = buf.as_ptr() as usize;
+    let len = buf.len();
+    let res = unsafe { syscall!(CONNECT, handle, ptr, len, port) } as isize;
+    if res >= 0 {
+        Ok(())
+    } else {
+        Err(())
+    }
+}
+
+pub fn listen(handle: usize, port: u16) -> Result<(), ()> {
+    let res = unsafe { syscall!(LISTEN, handle, port) } as isize;
+    if res >= 0 {
+        Ok(())
+    } else {
+        Err(())
+    }
+}
+
+pub fn accept(handle: usize) -> Result<IpAddress, ()> {
+    let addr = IpAddress::v4(0, 0, 0, 0);
+    let buf = addr.as_bytes();
+    let ptr = buf.as_ptr() as usize;
+    let len = buf.len();
+    let res = unsafe { syscall!(ACCEPT, handle, ptr, len) } as isize;
+    if res >= 0 {
+        Ok(IpAddress::from(Ipv4Address::from_bytes(buf)))
+    } else {
+        Err(())
+    }
+}
+
 #[test_case]
 fn test_file() {
     use crate::sys::fs::{mount_mem, format_mem, dismount, OpenFlag};

src/sys/clock.rs

@@ -1,7 +1,7 @@
 use crate::api::clock::DATE_TIME_ZONE;
+use crate::api::fs::{FileIO, IO};
 use crate::sys;
 use crate::sys::cmos::CMOS;
-use crate::sys::fs::FileIO;
 
 use time::{OffsetDateTime, Duration};
 
@@ -31,9 +31,20 @@ impl FileIO for Uptime {
             Err(())
         }
     }
+
     fn write(&mut self, _buf: &[u8]) -> Result<usize, ()> {
         unimplemented!();
     }
+
+    fn close(&mut self) {
+    }
+
+    fn poll(&mut self, event: IO) -> bool {
+        match event {
+            IO::Read => true,
+            IO::Write => false,
+        }
+    }
 }
 
 // NOTE: This clock is monotonic
@@ -65,9 +76,20 @@ impl FileIO for Realtime {
             Err(())
         }
     }
+
     fn write(&mut self, _buf: &[u8]) -> Result<usize, ()> {
         unimplemented!();
     }
+
+    fn close(&mut self) {
+    }
+
+    fn poll(&mut self, event: IO) -> bool {
+        match event {
+            IO::Read => true,
+            IO::Write => false,
+        }
+    }
 }
 
 // NOTE: This clock is not monotonic

src/sys/cmos.rs

@@ -1,5 +1,5 @@
 use crate::api::clock::{DATE_TIME, DATE_TIME_LEN};
-use crate::sys::fs::FileIO;
+use crate::api::fs::{FileIO, IO};
 
 use alloc::string::String;
 use bit_field::BitField;
@@ -83,6 +83,16 @@ impl FileIO for RTC {
         CMOS::new().update_rtc(self);
         Ok(buf.len())
     }
+
+    fn close(&mut self) {
+    }
+
+    fn poll(&mut self, event: IO) -> bool {
+        match event {
+            IO::Read => true,
+            IO::Write => true,
+        }
+    }
 }
 
 pub struct CMOS {

src/sys/console.rs

@@ -1,5 +1,5 @@
+use crate::api::fs::{FileIO, IO};
 use crate::sys;
-use crate::sys::fs::FileIO;
 use alloc::string::String;
 use alloc::string::ToString;
 use core::fmt;
@@ -43,6 +43,16 @@ impl FileIO for Console {
         print_fmt(format_args!("{}", s));
         Ok(n)
     }
+
+    fn close(&mut self) {
+    }
+
+    fn poll(&mut self, event: IO) -> bool {
+        match event {
+            IO::Read => STDIN.lock().contains('\n'),
+            IO::Write => true,
+        }
+    }
 }
 
 pub fn cols() -> usize {