Meta: Add files to repository

System/Shell/Commands/aplay.HC

@@ -0,0 +1,35 @@
+I64 @shell_cmd_aplay(@shell* sh, I64 argc, U8** argv)
+{
+    U8 buf[512];
+    if (argc < 2) {
+        StrPrint(&buf, "Error reading file %s\n", argv[1]);
+        Stdio.WriteLine(sh, "Usage: aplay [OPTION]... [FILE]...\n");
+        return 1;
+    }
+    I64 i;
+    I64 size;
+    Sound* snd;
+    U8* filename = NULL;
+    for (i = 1; i < argc; i++) {
+        filename = @shell_expand_relative_path(sh, argv[i]);
+        System.Log(Fs, "filename: %s", filename);
+        if (FileSystem.PathExists(filename)) {
+            snd = Audio.SoundFromFile(filename);
+            if (!snd) {
+                StrPrint(&buf, "%s: Error playing audio file\n", filename);
+                Stdio.WriteLine(sh, &buf);
+                Free(filename);
+                return 1;
+            }
+            Audio.PlaySound(snd);
+            Audio.FreeSound(snd);
+            Free(filename);
+        } else {
+            StrPrint(&buf, "%s: No such file or directory\n", filename);
+            Stdio.WriteLine(sh, &buf);
+            Free(filename);
+            return 1;
+        }
+    }
+    return 0;
+}

System/Shell/Commands/cat.HC

@@ -0,0 +1,19 @@
+I64 @shell_cmd_cat(@shell* sh, I64 argc, U8** argv)
+{
+    if (argc < 2)
+        return 0;
+    I64 i;
+    I64 j;
+    I64 size = 0;
+    U8* filename = NULL;
+    U8* buf = NULL;
+    for (i = 1; i < argc; i++) {
+        filename = @shell_expand_relative_path(sh, argv[i]);
+        buf = FileSystem.ReadFile(filename, &size);
+        for (j = 0; j < size; j++)
+            FifoU8Ins(sh->output, buf[j]);
+        Free(buf);
+        Free(filename);
+    }
+    return 0;
+}

System/Shell/Commands/clear.HC

@@ -0,0 +1,9 @@
+I64 @shell_cmd_clear(@shell* sh, I64 argc, U8** argv)
+{
+    if (argc > 1) {
+        Stdio.WriteLine(sh, "esh: clear: too many arguments\n");
+        return 1;
+    }
+    Stdio.WriteLine(sh, "\x1b[2J\x1b[0;0H");
+    return 0;
+}

System/Shell/Commands/echo.HC

@@ -0,0 +1,10 @@
+I64 @shell_cmd_echo(@shell* sh, I64 argc, U8** argv)
+{
+    I64 i;
+    for (i = 1; i < argc; i++) {
+        Stdio.WriteLine(sh, argv[i]);
+        Stdio.WriteLine(sh, " ");
+    }
+    Stdio.WriteLine(sh, "\n");
+    return 0;
+}

System/Shell/Commands/esh.HC

@@ -0,0 +1,5 @@
+I64 @shell_cmd_esh(@shell* sh, I64 argc, U8** argv)
+{
+    @shell_input_loop(sh);
+    return 0;
+}

System/Shell/Commands/history.HC

@@ -0,0 +1,14 @@
+I64 @shell_cmd_history(@shell* sh, I64 argc, U8** argv)
+{
+    I64 i;
+    I64 j;
+    U8 buf[512];
+    for (i = 0; i < sh->history.pos; i++) {
+        StrPrint(&buf, "%05d  %s\n", i + 1, sh->history.entries[i]);
+        j = 0;
+        while (buf[j] == '0')
+            buf[j++] = ' ';
+        Stdio.WriteLine(sh, &buf);
+    }
+    return 0;
+}

System/Shell/Commands/ifconfig.HC

@@ -0,0 +1,47 @@
+#define ETHERNET_FRAME_SIZE 1400
+
+I64 @shell_cmd_ifconfig(@shell* sh, I64 argc, U8** argv)
+{
+    NetInfoRequest* req = @net_info_request;
+
+    U64 en0_mac = req->mac_address;
+    U32 en0_addr = req->ipv4_address;
+    U32 en0_mask = req->ipv4_netmask;
+    U32 en0_bcast = req->ipv4_address | ~req->ipv4_netmask;
+
+    U8 buf[512];
+
+    Stdio.WriteLine(sh, "en0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu %d\n",
+        ETHERNET_FRAME_SIZE - 18);
+
+    Stdio.WriteLine(sh,
+        "        inet %d.%d.%d.%d  netmask %d.%d.%d.%d  broadcast "
+        "%d.%d.%d.%d\n",
+        en0_addr.u8[3], en0_addr.u8[2], en0_addr.u8[1], en0_addr.u8[0],
+        en0_mask.u8[3], en0_mask.u8[2], en0_mask.u8[1], en0_mask.u8[0],
+        en0_bcast.u8[3], en0_bcast.u8[2], en0_bcast.u8[1], en0_bcast.u8[0]);
+
+    Stdio.WriteLine(sh,
+        "        ether %02x:%02x:%02x:%02x:%02x:%02x  txqueuelen 0  "
+        "(Ethernet)\n",
+        en0_mac.u8[5], en0_mac.u8[4], en0_mac.u8[3], en0_mac.u8[2], en0_mac.u8[1],
+        en0_mac.u8[0]);
+
+    Stdio.WriteLine(sh, "        RX packets %d  bytes %d\n", req->rx_frames,
+        req->rx_bytes);
+
+    Stdio.WriteLine(sh, "        RX errors %d  dropped %d  overruns %d  frame %d\n", 0,
+        0, 0, 0); // TODO
+
+    Stdio.WriteLine(sh, "        TX packets %d  bytes %d\n", req->tx_frames,
+        req->tx_bytes);
+
+    Stdio.WriteLine(sh,
+        "        TX errors %d  dropped %d overruns %d  carrier %d  "
+        "collisions %d\n",
+        0, 0, 0, 0, 0); // TODO
+
+    Stdio.WriteLine(sh, "\n");
+
+    return 0;
+}

System/Shell/Commands/ls.HC

@@ -0,0 +1,70 @@
+#define @shell_cmd_ls_opt_a 0
+#define @shell_cmd_ls_opt_l 1
+
+I64 @shell_cmd_ls_output(@shell* sh, U8* arg_path, I64 flags)
+{
+    U8 buf[512];
+    U8* path = @shell_expand_relative_path(sh, arg_path);
+    if (!FileSystem.PathExists(path)) {
+        StrPrint(&buf, "ls: cannot access '%s': No such file or directory\n", path);
+        Stdio.WriteLine(sh, &buf);
+        Free(path);
+        return 2;
+    }
+    @dir_entry* tmpf = NULL;
+    @dir_entry* tmpf2 = NULL;
+    tmpf = FileSystem.GetFiles(path);
+    if (tmpf)
+        while (tmpf) {
+            if (tmpf->type == DE_TYPE_DIR) {
+                StrCpy(&buf, "\x1b[1;34m");
+                Stdio.WriteLine(sh, &buf);
+            }
+            StrPrint(&buf, "%s\x1b[0m    %u\n", &tmpf->name, tmpf->size);
+            Stdio.WriteLine(sh, &buf);
+            tmpf2 = tmpf;
+            tmpf = tmpf->next;
+            Free(tmpf2);
+        }
+    Free(path);
+    return 0;
+}
+
+I64 @shell_cmd_ls(@shell* sh, I64 argc, U8** argv)
+{
+    U8 buf[512];
+    U8* options_list = "al";
+    U64 options_err = NULL;
+    I64 dir_cnt = 0;
+    I64 flags = NULL;
+    I64 rval = 0;
+    I64 i;
+    switch (@shell_parse_opts(sh, options_list, argc, argv, &flags, &options_err,
+        TRUE)) {
+    case SHELL_OPTS_ERR_INVALID_OPT:
+        StrPrint(&buf, "ls: invalid option -- '%s'\n", options_err);
+        Stdio.WriteLine(sh, &buf);
+        break;
+    default:
+        break;
+    }
+    if (options_err) {
+        Free(options_err);
+        return 2;
+    }
+
+    for (i = 1; i < argc; i++)
+        if (argv[i][0] != '-')
+            dir_cnt++;
+
+    if (!dir_cnt) {
+        return @shell_cmd_ls_output(sh, &sh->cwd, flags);
+    } else {
+        for (i = 1; i < argc; i++)
+            if (argv[i][0] != '-') {
+                rval = Max(rval, @shell_cmd_ls_output(sh, argv[i], flags));
+            }
+    }
+
+    return rval;
+}

System/Shell/Commands/nslookup.HC

@@ -0,0 +1,32 @@
+I64 @shell_cmd_nslookup(@shell* sh, I64 argc, U8** argv)
+{
+    if (argc < 2) {
+        // TODO: Interactive mode
+        return 0;
+    }
+    if (argc > 2) {
+        // TODO: Server argument
+    }
+
+    NetInfoRequest* req = @net_info_request;
+    U32 resolver_ip = req->dns_server_address;
+    Free(req);
+
+    Stdio.WriteLine(sh, "Server:         %d.%d.%d.%d\n", resolver_ip.u8[3],
+        resolver_ip.u8[2], resolver_ip.u8[1], resolver_ip.u8[0]);
+
+    Stdio.WriteLine(sh, "Address:        %d.%d.%d.%d#53\n\n", resolver_ip.u8[3],
+        resolver_ip.u8[2], resolver_ip.u8[1], resolver_ip.u8[0]);
+
+    U32 res_ip = @dns_query(argv[1]);
+
+    if (res_ip == U32_MAX) {
+        Stdio.WriteLine(sh, "** server can't find %s: NXDOMAIN\n\n", argv[1]);
+        return 1;
+    }
+    Stdio.WriteLine(sh, "Non-authoritative answer:\n");
+    Stdio.WriteLine(sh, "Name:   %s\n", argv[1]);
+    Stdio.WriteLine(sh, "Address: %d.%d.%d.%d\n\n", res_ip.u8[3], res_ip.u8[2],
+        res_ip.u8[1], res_ip.u8[0]);
+    return 0;
+}

System/Shell/Commands/open.HC

@@ -0,0 +1,8 @@
+I64 @shell_cmd_open(@shell* sh, I64 argc, U8** argv)
+{
+    if (argc < 2) {
+        Stdio.WriteLine(sh, "open: path required\n");
+        return 1;
+    }
+    return @systemstarter_open(sh, argc, argv);
+}

System/Shell/Commands/ping.HC

@@ -0,0 +1,58 @@
+I64 @shell_cmd_ping(@shell* sh, I64 argc, U8** argv)
+{
+    if (argc < 2) {
+        Stdio.WriteLine(sh, "ping: usage error: Destination address required\n");
+        return 1;
+    }
+    U8* host = argv[1];
+    if (!host || !StrLen(host)) {
+        Stdio.WriteLine(sh, "Invalid host specified\n");
+        return PING_ERR_INVALID_HOST;
+    }
+    I64 count = 4;
+
+    U32 addr = @dns_query(host);
+    if (addr == U32_MAX) {
+        Stdio.WriteLine(sh, "Host not found\n");
+        return PING_ERR_HOST_NOT_FOUND;
+    }
+
+    U16 iden = (RandU16 * SysTimerRead) & 0xFFFF;
+    I64 start_jiffies;
+    U32 reply = NULL;
+    I64 res = 0;
+    U16 seq = 0;
+    I64 loss = 0;
+
+    IcmpRequest* request = CAlloc(sizeof(IcmpRequest), Fs->code_heap);
+
+    Stdio.WriteLine(sh, "PING %s (%d.%d.%d.%d): %d data bytes\n",
+        host, addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0], PING_PAYLOAD_SIZE);
+
+    I64 i;
+    for (i = 0; i < count; i++) {
+        start_jiffies = cnts.jiffies;
+        reply = @icmp_echo_request(addr, iden, seq, request, i);
+        if (!reply) {
+            Stdio.WriteLine(sh, "Request timeout for icmp_seq %d\n", seq);
+            ++loss;
+            res = 1;
+        } else {
+            Stdio.WriteLine(sh, "%d bytes from %d.%d.%d.%d: icmp_seq=%d ttl=%d time=%d ms\n",
+                reply.u16[1], addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0], seq, reply.u16[0], cnts.jiffies - start_jiffies);
+        }
+        while (cnts.jiffies < start_jiffies + 1000 && i < (count - 1))
+            Sleep(1);
+        ++seq;
+    }
+
+    Free(request);
+
+    Stdio.WriteLine(sh, "--- %d.%d.%d.%d ping statistics ---\n", addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0]);
+    Stdio.WriteLine(sh, "%d packets transmitted, %d packets received, %0f",
+        seq, seq - loss, (loss * 1.0 / seq * 1.0) * 100);
+    Stdio.WriteLine(sh, "%c", 37);
+    Stdio.WriteLine(sh, " packet loss\n");
+
+    return res;
+}

System/Shell/Commands/poweroff.HC

@@ -0,0 +1,5 @@
+I64 @shell_cmd_poweroff(@shell* sh, I64 argc, U8** argv)
+{
+    System.PowerOff();
+    return 0;
+}

System/Shell/Commands/pwd.HC

@@ -0,0 +1,7 @@
+I64 @shell_cmd_pwd(@shell* sh, I64 argc, U8** argv)
+{
+    U8 buf[512];
+    StrPrint(&buf, "%s\n", &sh->cwd);
+    Stdio.WriteLine(sh, &buf);
+    return 0;
+}

System/Shell/Commands/reboot.HC

@@ -0,0 +1,5 @@
+I64 @shell_cmd_reboot(@shell* sh, I64 argc, U8** argv)
+{
+    Reboot;
+    return 0;
+}

System/Shell/Commands/sh.HC

@@ -0,0 +1,4 @@
+I64 @shell_cmd_sh(@shell* sh, I64 argc, U8** argv)
+{
+    return @shell_cmd_esh(sh, argc, argv);
+}

System/Shell/Commands/uname.HC

@@ -0,0 +1,81 @@
+#define @shell_cmd_uname_opt_s 0
+#define @shell_cmd_uname_opt_n 1
+#define @shell_cmd_uname_opt_r 2
+#define @shell_cmd_uname_opt_v 3
+#define @shell_cmd_uname_opt_m 4
+#define @shell_cmd_uname_opt_p 5
+#define @shell_cmd_uname_opt_i 6
+#define @shell_cmd_uname_opt_o 7
+#define @shell_cmd_uname_opt_a 8
+
+I64 @shell_cmd_uname(@shell* sh, I64 argc, U8** argv)
+{
+    I64 i;
+    CDateStruct* ds = CAlloc(sizeof(CDateStruct));
+    Date2Struct(ds, sys_compile_time);
+    U8* options_list = "snrvmpioa";
+    U64 options_err = NULL;
+    U8* ds_m = "JanFebMarAprMayJunJulAugSepOctNovDec";
+    U8* ds_d = "SunMonTueWedThuFriSat";
+    U8* ds_mm = "   ";
+    U8* ds_dd = "   ";
+    U8 buf[512];
+    I64 flags = NULL;
+    StrCpy(&buf, "");
+    if (argc < 2)
+        flags |= 1 << @shell_cmd_uname_opt_s;
+    switch (
+        @shell_parse_opts(sh, options_list, argc, argv, &flags, &options_err)) {
+    case SHELL_OPTS_ERR_INVALID_OPT:
+        StrPrint(&buf, "uname: invalid option -- '%s'\n", options_err);
+        Stdio.WriteLine(sh, &buf);
+        break;
+    case SHELL_OPTS_ERR_EXTRA_OPD:
+        StrPrint(&buf, "uname: extra operand '%s'\n", options_err);
+        Stdio.WriteLine(sh, &buf);
+        break;
+    default:
+        break;
+    }
+    if (options_err) {
+        Free(options_err);
+        Free(ds);
+        return 1;
+    }
+    if (flags & 1 << @shell_cmd_uname_opt_a)
+        flags = 0x01FF; // Set all options.
+    for (i = 0; i < 8; i++) {
+        switch (flags & 1 << i) {
+        case 1 << @shell_cmd_uname_opt_s:
+            String.Append(&buf, Define("DD_OS_NAME_VERSION"));
+            *StrLastOcc(&buf, "V") = NULL;
+            break;
+        case 1 << @shell_cmd_uname_opt_n:
+            String.Append(&buf, "%s ", &sh->session->hostname);
+            break;
+        case 1 << @shell_cmd_uname_opt_r:
+            String.Append(&buf, "%1.2f ", sys_os_version);
+            break;
+        case 1 << @shell_cmd_uname_opt_v:
+            MemCpy(ds_mm, ds_m + ((ds->mon - 1) * 3), 3);
+            MemCpy(ds_dd, ds_d + (ds->day_of_week * 3), 3);
+            String.Append(&buf, "%s %s %d %02d:%02d:%02d UTC %d ", ds_dd, ds_mm,
+                ds->day_of_mon, ds->hour, ds->min, ds->sec, ds->year);
+            break;
+        case 1 << @shell_cmd_uname_opt_m:
+        case 1 << @shell_cmd_uname_opt_p:
+        case 1 << @shell_cmd_uname_opt_i:
+            String.Append(&buf, "x86_64 ");
+            break;
+        case 1 << @shell_cmd_uname_opt_o:
+            String.Append(&buf, "Erythros ");
+            break;
+        default:
+            break;
+        }
+    }
+    Stdio.WriteLine(sh, &buf);
+    Stdio.WriteLine(sh, "\n");
+    Free(ds);
+    return 0;
+}

System/Shell/Commands/whoami.HC

@@ -0,0 +1,28 @@
+I64 @shell_cmd_whoami(@shell* sh, I64 argc, U8** argv)
+{
+    U8* options_list = "";
+    U64 options_err = NULL;
+    I64 flags = NULL;
+    I64 res = 0;
+    U8 buf[512];
+    switch (
+        @shell_parse_opts(sh, options_list, argc, argv, &flags, &options_err)) {
+    case SHELL_OPTS_ERR_INVALID_OPT:
+        StrPrint(&buf, "uname: unrecognized option -- '%s'\n", options_err);
+        Stdio.WriteLine(sh, &buf);
+        res = 1;
+        break;
+    case SHELL_OPTS_ERR_EXTRA_OPD:
+        StrPrint(&buf, "uname: extra operand '%s'\n", options_err);
+        Stdio.WriteLine(sh, &buf);
+        res = 1;
+        break;
+    default:
+        Stdio.WriteLine(sh, &sh->session->user.name);
+        Stdio.WriteLine(sh, "\n");
+        break;
+    }
+    if (options_err)
+        Free(options_err);
+    return res;
+}

System/Shell/Commands/wpset.HC

@@ -0,0 +1,24 @@
+I64 @shell_cmd_wpset(@shell* sh, I64 argc, U8** argv)
+{
+    U8 buf[512];
+    if (argc < 2) {
+        return 0;
+    }
+    I64 size = 0;
+    U64 fbuf = FileSystem.ReadFile(argv[1], &size);
+    if (!fbuf) {
+        StrPrint(&buf, "Error reading file %s\n", argv[1]);
+        Stdio.WriteLine(sh, &buf);
+        return 1;
+    }
+    Context2D* new = Image.BufferToContext2D(fbuf, size);
+    Free(fbuf);
+    if (!new) {
+        StrPrint(&buf, "Error in Image.BufferToContext2D\n");
+        Stdio.WriteLine(sh, &buf);
+        return 1;
+    }
+    Compositor.SetWallpaper(new);
+    DelContext2D(new);
+    return 0;
+}