Initial commit

src/bin/finger.rs

@@ -0,0 +1,109 @@
+use clap::Parser;
+
+/// User information lookup program
+///
+/// The `finger` utility displays information about the system users.
+///
+///
+/// If no options are specified, finger defaults to the -l style output if operands are provided, otherwise to the -s style.
+/// Note that some fields may be missing, in either format, if information is not available for them.
+///
+/// If no arguments are specified, finger will print an entry for each user currently logged into the system.
+///
+/// Finger may be used to look up users on a remote machine.
+/// The format is to specify a user as “user@host”, or “@host”,
+/// where the default output format for the former is the -l style,
+/// and the default output format for the latter is the -s style.
+/// The -l option is the only option that may be passed to a remote machine.
+///
+/// If standard output is a socket, finger will emit a carriage return (^M) before every linefeed (^J).
+/// This is for processing remote finger requests when invoked by the daemon.
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Forces finger to use IPv4 addresses only.
+    #[arg(long, short = '4', conflicts_with = "ipv6")]
+    ipv4: bool,
+
+    /// Forces finger to use IPv6 addresses only.
+    #[arg(long, short = '6', conflicts_with = "ipv4")]
+    ipv6: bool,
+
+    /// Display the user's login name, real name, terminal name and write status
+    /// (as a ``*'' before the terminal name if write permission is denied),
+    /// idle time, login time, and either office location and office phone number,
+    /// or the remote host. If -o is given, the office location and office phone number
+    /// is printed (the default). If -h is given, the remote host is printed instead.
+    ///
+    /// Idle time is in minutes if it is a single integer, hours and minutes if a ``:''
+    /// is present, or days if a ``d'' is present. If it is an "*", the login time indicates
+    /// the time of last login. Login time is displayed as the day name if less than 6 days,
+    /// else month, day; hours and minutes, unless more than six months ago, in which case the year
+    /// is displayed rather than the hours and minutes.
+    ///
+    /// Unknown devices as well as nonexistent idle and login times are displayed as single asterisks.
+    #[arg(long, short, conflicts_with = "long")]
+    short: bool,
+
+    /// When used in conjunction with the -s option, the name of the remote host
+    /// is displayed instead of the office location and office phone.
+    #[arg(long, short, requires = "short", conflicts_with = "office")]
+    host: bool,
+
+    /// When used in conjunction with the -s option, the office location and
+    /// office phone information is displayed instead of the name of the remote host.
+    #[arg(long, short, requires = "short", conflicts_with = "host")]
+    office: bool,
+
+    /// This option restricts the gecos output to only the users' real name.
+    /// It also has the side-effect of restricting the output of the remote host
+    /// when used in conjunction with the -h option.
+    #[arg(long, short, requires = "short")]
+    gecos: bool,
+
+    /// Disable all use of the user accounting database.
+    #[arg(short = 'k')]
+    no_acct: bool,
+
+    /// Produce a multi-line format displaying all of the information
+    /// described for the -s option as well as the user's home directory,
+    /// home phone number, login shell, mail status, and the contents of
+    /// the files .forward, .plan, .project and .pubkey from the user's home directory.
+    ///
+    /// If idle time is at least a minute and less than a day, it is presented in the form ``hh:mm''.
+    /// Idle times greater than a day are presented as ``d day[s]hh:mm''
+    ///
+    /// Phone numbers specified as eleven digits are printed as ``+N-NNN-NNN-NNNN''.
+    /// Numbers specified as ten or seven digits are printed as the appropriate subset of that string.
+    /// Numbers specified as five digits are printed as ``xN-NNNN''.
+    /// Numbers specified as four digits are printed as ``xNNNN''.
+    ///
+    /// If write permission is denied to the device, the phrase ``(messages off)''
+    /// is appended to the line containing the device name. One entry per user is displayed with the -l option;
+    /// if a user is logged on multiple times, terminal information is repeated once per login.
+    ///
+    /// Mail status is shown as ``No Mail.'' if there is no mail at all,
+    /// ``Mail last read DDD MMM ## HH:MM YYYY (TZ)'' if the person has looked at their mailbox since new mail arriving,
+    /// or ``New mail received ...'', ``Unread since ...'' if they have new mail.
+    #[arg(long, short, conflicts_with = "short")]
+    long: bool,
+
+    /// Prevent the -l option of finger from displaying the contents of
+    /// the .forward, .plan, .project and .pubkey files.
+    #[arg(long, short, requires = "long")]
+    prevent_files: bool,
+
+    /// Prevent matching of user names. User is usually a login name;
+    /// however, matching will also be done on the users' real names,
+    /// unless the -m option is supplied. All name matching performed by finger is case insensitive.
+    #[arg(long, short = 'm')]
+    no_name_match: bool,
+
+    /// Output in JSON format
+    #[arg(long, short)]
+    json: bool,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}

src/bin/roowhod.rs

@@ -0,0 +1,4 @@
+fn main() {
+    unimplemented!()
+}
+

src/bin/rup.rs

@@ -0,0 +1,42 @@
+use clap::Parser;
+
+/// Remote status display.
+///
+/// `rup` displays a summary of the current system status of a particular host or all hosts on the local network.
+/// The output shows the current time of day, how long the system has been up, and the load averages.
+/// The load average numbers give the number of jobs in the run queue averaged over 1, 5 and 15 minutes.
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// The hosts to query.
+    hosts: Vec<String>,
+
+    /// For each host, report what its local time is.
+    /// This is useful for checking time syncronization on a network.
+    #[arg(long, short)]
+    date: bool,
+
+    /// Print time data in seconds (seconds of uptime or seconds since the epoch), for scripts.
+    #[arg(long, short)]
+    seconds: bool,
+
+    /// Sort the display alphabetically by host name.
+    #[arg(long, short)]
+    hostname: bool,
+
+    /// Sort the display by load average.
+    #[arg(long, short)]
+    load: bool,
+
+    /// Sort the display by uptime.
+    #[arg(long, short)]
+    uptime: bool,
+
+    /// Output in JSON format
+    #[arg(long, short)]
+    json: bool,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}

src/bin/ruptime.rs

@@ -0,0 +1,39 @@
+use clap::Parser;
+
+/// Show host status of local machines.
+///
+/// `ruptime` gives a status line like uptime for each machine on the local network;
+/// these are formed from packets broadcast by each host on the network once a minute.
+///
+/// Machines for which no status report has been received for 11 minutes are shown as being down.
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Users idle an hour or more are not counted unless the `-a` flag is given.
+    #[arg(long, short)]
+    all: bool,
+
+    /// Sort by load average.
+    #[arg(long, short)]
+    load: bool,
+
+    /// Reverses the sort order.
+    #[arg(long, short)]
+    reverse: bool,
+
+    /// Sort by uptime.
+    #[arg(long, short)]
+    time: bool,
+
+    /// Sort by number of users.
+    #[arg(long, short)]
+    users: bool,
+
+    /// Output in JSON format
+    #[arg(long, short)]
+    json: bool,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}

src/bin/rusers.rs

@@ -0,0 +1,35 @@
+use clap::Parser;
+
+/// Check who is logged in to machines on local network.
+///
+/// The `rusers` command produces output similar to `who`,
+/// but for the list of hosts or all machines on the local network.
+/// For each host responding to the rusers query,
+/// the host‐name with the names of the users currently logged on is printed on each line.
+/// The `rusers` command will wait for one minute to catch late responders.
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Print all machines responding even if no one is currently logged in
+    #[arg(long, short)]
+    all: bool,
+
+    /// Print a long format listing.
+    /// This includes:
+    ///   - the user name
+    ///   - the host name
+    ///   - the tty that the user is logged in to
+    ///   - the date and time the user logged in
+    ///   - the amount of time since the user typed on the keyboard
+    ///   - the remote host they logged in from (if applicable)
+    #[arg(long, short)]
+    long: bool,
+
+    /// Output in JSON format
+    #[arg(long, short)]
+    json: bool,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}

src/bin/rwall.rs

@@ -0,0 +1,20 @@
+use clap::Parser;
+
+/// Send a message to users logged on a host.
+///
+/// The `rwall` command sends a message to the users logged into the specified host.
+/// The message to be sent can be typed in and terminated with EOF or it can be in a file
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// The host to send the message to
+    host: String,
+
+    /// The file containing the message to be sent
+    #[arg(value_name = "PATH")]
+    file: Option<String>,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}

src/bin/rwho.rs

@@ -0,0 +1,26 @@
+use clap::Parser;
+
+/// Check who is logged in on local machines.
+///
+/// The `rwho` command produces output similar to `who`, but for all machines on the local network.
+/// If no report has been received from a machine for 11 minutes then rwho assumes the machine is down,
+/// and does not report users last known to be logged into that machine.
+///
+/// If a users hasn't typed to the system for a minute or more, then rwho reports this idle time.
+/// If a user hasn't typed to the system for an hour or more,
+/// then the user will be omitted from the output of `rwho` unless the `-a` flag is given.
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Print all machines responding even if no one is currently logged in
+    #[arg(long, short)]
+    all: bool,
+
+    /// Output in JSON format
+    #[arg(long, short)]
+    json: bool,
+}
+
+fn main() {
+    let _args = Args::parse();
+    unimplemented!()
+}