开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > 查看源码
sh.c
资源名称：sanos-src-1.2.6.zip　[点击查看]
上传用户：lyp3966
上传日期：2007-07-04
资源大小：1193k
文件大小：34k
源码类别：

Java编程

开发平台：

C/C++

sh.c：源码内容
  1. //
  2. // sh.c
  3. //
  4. // Shell
  5. //
  6. // Copyright (C) 2002 Michael Ringgaard. All rights reserved.
  7. //
  8. // Redistribution and use in source and binary forms, with or without
  9. // modification, are permitted provided that the following conditions
  10. // are met:
  11. // 
  12. // 1. Redistributions of source code must retain the above copyright 
  13. //    notice, this list of conditions and the following disclaimer.  
  14. // 2. Redistributions in binary form must reproduce the above copyright
  15. //    notice, this list of conditions and the following disclaimer in the
  16. //    documentation and/or other materials provided with the distribution.  
  17. // 3. Neither the name of the project nor the names of its contributors
  18. //    may be used to endorse or promote products derived from this software
  19. //    without specific prior written permission. 
  20. // 
  21. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  22. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23. // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24. // ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  25. // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26. // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27. // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28. // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29. // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30. // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
  31. // SUCH DAMAGE.
  32. // 
  34. #include <os.h>
  35. #include <stdio.h>
  36. #include <string.h>
  37. #include <stdlib.h>
  38. #include <os/version.h>
  40. unsigned char buffer[4096];
  42. unsigned char orig[4096];
  43. unsigned char pattern[4096];
  45. static void list_file(char *filename)
  46. {
  47.   int count;
  48.   int file;
  50.   if ((file = open(filename, 0)) < 0)
  51.   {
  52.     printf("%s: %sn", filename, strerror(file));
  53.     return;
  54.   }
  56.   while ((count = read(file, buffer, 4096)) > 0)
  57.   {
  58.     write(fdout, buffer, count);
  59.   }
  61.   close(file);
  62. }
  64. static void copy_file(char *srcfn, char *dstfn)
  65. {
  66.   char *data;
  67.   int count;
  68.   int f1;
  69.   int f2;
  71.   if ((f1 = open(srcfn, 0)) < 0)
  72.   {
  73.     printf("%s: %sn", srcfn, strerror(f1));
  74.     return;
  75.   }
  77.   if ((f2 = open(dstfn, O_CREAT)) < 0)
  78.   {
  79.     close(f1);
  80.     printf("%s: %sn", dstfn, strerror(f2));
  81.     return;
  82.   }
  84.   data = malloc(64 * K);
  85.   while ((count = read(f1, data, 64 * K)) > 0)
  86.   {
  87.     if (write(f2, data, count) != count)
  88.     {
  89.       printf("%s: error writing datan", dstfn);
  90.       break;
  91.     }
  92.   }
  93.   free(data);
  95.   if (count < 0) printf("%s: %sn", srcfn, strerror(count));
  96.   
  97.   close(f1);
  98.   close(f2);
  99. }
  101. static void list_dir(int argc, char **argv)
  102. {
  103.   char *dirname;
  104.   int verbose;
  105.   int i;
  106.   int dir;
  107.   struct dirent dirp;
  108.   struct stat buf;
  109.   struct tm tm;
  110.   char path[MAXPATH];
  111.   char *arg;
  112.   int col;
  114.   verbose = 0;
  115.   dirname = ".";
  116.   for (i = 1; i < argc; i++)
  117.   {
  118.     arg = argv[i];
  120.     if (*arg == '-')
  121.     {
  122.       while (*++arg)
  123.       {
  124. if (*arg == 'l') verbose = 1;
  125. if (*arg == 'w') verbose = 2;
  126.       }
  127.     }
  128.     else
  129.       dirname = arg;
  130.   }
  132.   if ((dir = opendir(dirname)) < 0)
  133.   {
  134.     printf("%s: %sn", dirname, strerror(dir));
  135.     return;
  136.   }
  138.   col = 0;
  139.   while (readdir(dir, &dirp, 1) > 0)
  140.   {
  141.     strcpy(path, dirname);
  142.     strcat(path, "/");
  143.     strcat(path, dirp.name);
  145.     if (stat(path, &buf) < 0) memset(&buf, 0, sizeof(struct stat));
  147.     if (verbose == 2)
  148.     {
  149.       if (col == 4)
  150.       {
  151. col = 0;
  152. //printf("n");
  153.       }
  155.       if (buf.mode & FS_DIRECTORY) strcat(dirp.name, "/");
  156.       printf("%-20s", dirp.name);
  157.       col++;
  158.     }
  159.     else
  160.     {
  161.       strcpy(path, dirname);
  162.       strcat(path, "/");
  163.       strcat(path, dirp.name);
  165.       if (stat(path, &buf) < 0) memset(&buf, 0, sizeof(struct stat));
  167.       if (verbose)
  168.       {
  169. printf("%8d %4d %1d %2d ", buf.quad.size_low, buf.ino, buf.nlink, buf.devno);
  171. _gmtime(&buf.ctime, &tm);
  172. printf("%02d/%02d/%04d %02d:%02d:%02d ", tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
  173.       }
  174.       else
  175.       {
  176. if (buf.mode & FS_DIRECTORY)
  177.   printf("         ");
  178. else
  179. {
  180.   if (buf.quad.size_high == 0 && buf.quad.size_low < 1*K)
  181.     printf("%6d B ", buf.quad.size_low);
  182.   else if (buf.quad.size_high == 0 && buf.quad.size_low < 1*M)
  183.     printf("%6dKB ", buf.quad.size_low / K);
  184.   else if (buf.quad.size_high == 0)
  185.     printf("%6dMB ", buf.quad.size_low / M);
  186.   else
  187.     printf("%6dGB ", (buf.quad.size_high << 2) | (buf.quad.size_low >> 30));
  188. }
  189.       }
  191.       _gmtime(&buf.mtime, &tm);
  192.       printf("%02d/%02d/%04d %02d:%02d:%02d ", tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
  194.       printf("%s", dirp.name);
  195.       if (buf.mode & FS_DIRECTORY) printf("/", dirp.name);
  197.       printf("n");
  198.     }
  199.   }
  201.   if (verbose == 2) printf("n");
  203.   close(dir);
  204. }
  206. static void remove_file(char *filename)
  207. {
  208.   int rc;
  210.   rc = unlink(filename); 
  211.   if (rc < 0)
  212.   {
  213.     printf("%s: %sn", filename, strerror(rc));
  214.     return;
  215.   }
  216. }
  218. static void move_file(char *oldname, char *newname)
  219. {
  220.   int rc;
  222.   rc = rename(oldname, newname);
  223.   if (rc < 0)
  224.   {
  225.     printf("%s: %sn", oldname, strerror(rc));
  226.     return;
  227.   }
  228. }
  230. static void change_dir(char *filename)
  231. {
  232.   int rc;
  234.   rc = chdir(filename); 
  235.   if (rc < 0)
  236.   {
  237.     printf("%s: %sn", filename, strerror(rc));
  238.     return;
  239.   }
  240. }
  242. static void make_dir(char *filename)
  243. {
  244.   int rc;
  246.   rc = mkdir(filename); 
  247.   if (rc < 0)
  248.   {
  249.     printf("%s: %sn", filename, strerror(rc));
  250.     return;
  251.   }
  252. }
  254. static void remove_dir(char *filename)
  255. {
  256.   int rc;
  258.   rc = rmdir(filename); 
  259.   if (rc < 0)
  260.   {
  261.     printf("%s: %sn", filename, strerror(rc));
  262.     return;
  263.   }
  264. }
  266. static void display_buffer(int f, char *buffer, int size)
  267. {
  268.   char *p;
  269.   char *q;
  270.   char *end;
  272.   p = buffer;
  273.   end = buffer + size;
  274.   while (p < end)
  275.   {
  276.     q = p;
  277.     while (q < end && *q != 'n') q++;
  279.     if (p != q) write(f, p, q - p);
  280.     if (q < end) 
  281.     {
  282.       write(f, "rn", 2);
  283.       q++;
  284.     }
  285.     p = q;
  286.   }
  287. }
  289. static void display_file(char *filename)
  290. {
  291.   int count;
  292.   int file;
  293.   int line;
  294.   char *start;
  295.   char *end;
  296.   char ch;
  298.   if ((file = open(filename, 0)) < 0)
  299.   {
  300.     printf("%s: %sn", filename, strerror(file));
  301.     return;
  302.   }
  304.   line = 0;
  305.   while ((count = read(file, buffer, 4096)) > 0)
  306.   {
  307.     start = end = buffer;
  308.     while (end < buffer + count)
  309.     {
  310.       if (line == 24)
  311.       {
  312. display_buffer(fdout, start, end - start);
  313. while (read(fdin, &ch, 1) <= 0);
  314. if (ch == 'x')
  315. {
  316.   close(file);
  317.   return;
  318. }
  319. start = end;
  320.         line = 0;
  321.       }
  322.       if (*end++ == 'n') line++;
  323.     }
  324.     display_buffer(fdout, start, end - start);
  325.   }
  327.   close(file);
  328. }
  330. static void show_date(int argc, char *argv[])
  331. {
  332.   time_t t;
  333.   struct tm tm;
  335.   t = time(NULL);
  336.   _gmtime(&t, &tm);
  338.   if (argc > 1)
  339.   {
  340.     char buffer[256];
  342.     strftime(buffer, 256, argv[1], &tm);
  343.     printf("%sn", buffer);
  344.   }
  345.   else
  346.     printf("Time is %04d/%02d/%02d %02d:%02d:%02dn", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
  347. }
  349. static void test_read_file(char *filename)
  350. {
  351.   int count;
  352.   int file;
  353.   char *data;
  354.   clock_t start;
  355.   clock_t time;
  356.   int bytes;
  358.   if ((file = open(filename, 0)) < 0)
  359.   {
  360.     printf("%s: %sn", filename, strerror(file));
  361.     return;
  362.   }
  364.   data = malloc(64 * K);
  366.   bytes = 0;
  367.   start = clock();
  368.   while ((count = read(file, data, 64 * K)) > 0)
  369.   {
  370.     bytes += count;
  371.   }
  372.   time = clock() - start;
  373.   if (time == 0) time = 1;
  375.   printf("%s: read %dKB in %d ms, %dKB/sn", filename, bytes / K, time, bytes / time);
  376.   
  377.   free(data);
  379.   if (count < 0) printf("%s: %sn", filename, strerror(count));
  381.   close(file);
  382. }
  384. static void test_write_file(char *filename, int size)
  385. {
  386.   int count;
  387.   int file;
  388.   char *data;
  389.   clock_t start;
  390.   clock_t time;
  391.   int bytes;
  393.   if ((file = open(filename, O_CREAT)) < 0)
  394.   {
  395.     printf("%s: %sn", filename, strerror(file));
  396.     return;
  397.   }
  399.   data = malloc(64 * K);
  401.   bytes = 0;
  402.   start = clock();
  403.   while (bytes < size)
  404.   {
  405.     if ((count = write(file, data, 64 * K)) <= 0)
  406.     {
  407.       printf("%s: error writing filen", filename);
  408.       break;
  409.     }
  411.     bytes += count;
  412.   }
  413.   time = clock() - start;
  414.   if (time == 0) time = 1;
  416.   printf("%s: wrote %dKB in %d ms, %dKB/sn", filename, bytes / K, time, bytes / time);
  417.   
  418.   free(data);
  420.   close(file);
  421. }
  423. struct critsect testcs;
  424. int count;
  425. int runs;
  426. long holdrand = 1L;
  428. static int rand()
  429. {
  430.   return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
  431. }
  433. static void __stdcall csthreadproc(void *arg)
  434. {
  435.   int n;
  437.   while (1)
  438.   {
  439.     enter(&testcs);
  441.     runs++;
  443.     n = count;
  445.     if (n != 0) printf("ERROR: count is %dn", n);
  447.     count++;
  448.     if (rand() < 100) sleep(rand() / 1000);
  449.     count--;
  451.     leave(&testcs);
  452.     //sleep(rand() / 10000);
  453.   }
  454. }
  456. static void cstest()
  457. {
  458.   int n;
  460.   mkcs(&testcs);
  462.   runs = 0;
  463.   for (n = 0; n < 10; n++)
  464.   {
  465.     beginthread(csthreadproc, 0, NULL, 0, NULL);
  466.   }
  468.   while (1)
  469.   {
  470.     sleep(1000);
  471.     printf("%d runsr", runs);
  472.   }
  474.   csfree(&testcs);
  475. }
  477. static void set_loglevel(char *arg, int level)
  478. {
  479.   int ll = 0;
  481.   while (*arg)
  482.   {
  483.     if (*arg == 'm') ll |= LOG_MODULE;
  484.     if (*arg == 'h') ll |= LOG_HEAP;
  485.     if (*arg == 't') ll |= LOG_APITRACE;
  486.     if (*arg == 'a') ll |= LOG_AUX;
  487.     if (*arg == 'x') ll |= LOG_SUBSYS_MASK;
  489.     arg++;
  490.   }
  492.   loglevel = ll | level;
  493. }
  495. static void idle_sleep(int ms)
  496. {
  497.   time_t t;
  498.   struct tm tm;
  499.   clock_t c;
  501.   t = time(NULL);
  502.   c = clock();
  503.   _gmtime(&t, &tm);
  504.   printf("Time is %04d/%02d/%02d %02d:%02d:%02d Clock is %dn", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, c);
  506.   printf("Sleep %d msn", ms);
  507.   sleep(ms);
  509.   t = time(NULL);
  510.   c = clock();
  511.   _gmtime(&t, &tm);
  512.   printf("Time is %04d/%02d/%02d %02d:%02d:%02d Clock is %dn", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, c);
  513. }
  515. static void busy_loop(int ms)
  516. {
  517.   time_t t;
  518.   struct tm tm;
  519.   clock_t c;
  521.   t = time(NULL);
  522.   c = clock();
  523.   _gmtime(&t, &tm);
  524.   printf("Time is %04d/%02d/%02d %02d:%02d:%02d Clock is %dn", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, c);
  526.   //while (clock() < c + ms);
  527.   {
  528.     int n;
  529.     for (n = 0; n < 100000000; n++) c += n;
  530.   }
  532.   t = time(NULL);
  533.   c = clock();
  534.   _gmtime(&t, &tm);
  535.   printf("Time is %04d/%02d/%02d %02d:%02d:%02d Clock is %dn", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, c);
  536. }
  538. static void exec_program(char *args)
  539. {
  540.   char pgm[MAXPATH];
  541.   char *p;
  542.   char *q;
  543.   hmodule_t hmod;
  544.   int rc;
  545.   int dotseen = 0;
  547.   p = args;
  548.   q = pgm;
  549.   while (*p != 0 && *p != ' ')
  550.   {
  551.     if (*p == '.') dotseen = 1;
  552.     if (*p == PS1 || *p == PS2) dotseen = 0;
  553.     *q++ = *p++;
  554.   }
  555.   *q++ = 0;
  556.   if (!dotseen) strcat(pgm, ".exe");
  558.   hmod = load(pgm);
  559.   if (hmod == NULL)
  560.   {
  561.     printf("%s: program not foundn", pgm);
  562.     return;
  563.   }
  565.   rc = exec(hmod, args);
  567.   if (rc != 0) printf("Exitcode: %dn", rc);
  568.   //unload(hmod);
  569. }
  571. static void __stdcall spawn_program(void *args)
  572. {
  573.   exec_program(args);
  574.   printf("%s: terminatedn", args);
  575.   free(args);
  576. }
  578. static void launch_program(char *args)
  579. {
  580.   while (*args != 0 && *args != ' ') args++;
  581.   while (*args == ' ') args++;
  583.   beginthread(spawn_program, 0, strdup(args), 0, NULL);
  584. }
  586. static void load_module(int argc, char **argv)
  587. {
  588.   char *pgm;
  589.   hmodule_t hmod;
  591.   if (argc < 2)
  592.   {
  593.     printf("usage: load <module>n");
  594.     return;
  595.   }
  596.   pgm = argv[1];
  598.   hmod = load(pgm);
  599.   if (hmod == NULL)
  600.   {
  601.     printf("%s: unable to load modulen", pgm);
  602.     return;
  603.   }
  604. }
  606. static void mount_device(int argc, char **argv)
  607. {
  608.   char *devname;
  609.   char *path;
  610.   char *type = "dfs";
  611.   char *opts = NULL;
  612.   int rc;
  614.   if (argc < 3)
  615.   {
  616.     printf("usage: mount <device> <path> [<type> [<options>]]n");
  617.     return;
  618.   }
  620.   devname = argv[1];
  621.   path = argv[2];
  622.   if (argc > 3) type = argv[3];
  623.   if (argc > 4) opts = argv[4];
  625.   rc = mount(type, path, devname, opts); 
  626.   if (rc < 0)
  627.   {
  628.     printf("%s: %sn", devname, strerror(rc));
  629.     return;
  630.   }
  631. }
  633. static void umount_device(int argc, char **argv)
  634. {
  635.   char *path;
  636.   int rc;
  638.   if (argc < 2)
  639.   {
  640.     printf("usage: umount <path>n");
  641.     return;
  642.   }
  644.   path = argv[1];
  646.   rc = umount(path);
  647.   if (rc < 0)
  648.   {
  649.     printf("%s: %sn", path, strerror(rc));
  650.     return;
  651.   }
  652. }
  654. static void format_device(int argc, char **argv)
  655. {
  656.   char *devname;
  657.   char *type = "dfs";
  658.   char *opts = NULL;
  659.   int rc;
  661.   if (argc < 2)
  662.   {
  663.     printf("usage: format <device> [<type> [<options>]]n");
  664.     return;
  665.   }
  667.   devname = argv[1];
  668.   if (argc > 2) type = argv[2];
  669.   if (argc > 3) opts = argv[3];
  671.   rc = format(devname, type, opts); 
  672.   printf("n");
  673.   if (rc < 0)
  674.   {
  675.     printf("%s: %sn", devname, strerror(rc));
  676.     return;
  677.   }
  678. }
  680. static void disk_usage(int argc, char **argv)
  681. {
  682.   int count;
  683.   int rc;
  684.   int n;
  685.   struct statfs *buf;
  686.   struct statfs *b;
  688.   count = getfsstat(NULL, 0);
  689.   if (count < 0)
  690.   {
  691.     printf("du: %sn", strerror(count));
  692.     return;
  693.   }
  695.   buf = (struct statfs *) malloc(count * sizeof(struct statfs));
  696.   rc = getfsstat(buf, count * sizeof(struct statfs));
  697.   if (rc < 0)
  698.   {
  699.     printf("du: %sn", strerror(rc));
  700.     return;
  701.   }
  703.   printf("type   mounted on mounted from          cache    total     used    avail filesn");
  704.   printf("------ ---------- -------------------- ------ -------- -------- -------- -----n");
  706.   for (n = 0; n < count; n++)
  707.   {
  708.     b = buf + n;
  710.     printf("%-7s%-11s%-20s", b->fstype, b->mntto, b->mntfrom);
  711.     if (b->blocks != -1)
  712.     {
  713.       printf("%6dK", b->cachesize / K);
  714.       if (b->blocks * (b->bsize / 512) / 2 > 10000)
  715. printf("%8dM", b->blocks * (b->bsize / 512) / 2000);
  716.       else
  717. printf("%8dK", b->blocks * (b->bsize / 512) / 2);
  719.       if ((b->blocks - b->bfree) * (b->bsize / 512) / 2 > 10000)
  720.         printf("%8dM", (b->blocks - b->bfree) * (b->bsize / 512) / 2000);
  721.       else
  722.         printf("%8dK", (b->blocks - b->bfree) * (b->bsize / 512) / 2);
  724.       if (b->bfree * (b->bsize / 512) / 2 > 10000)
  725.          printf("%8dM", b->bfree * (b->bsize / 512) / 2000);
  726.       else
  727.         printf("%8dK", b->bfree * (b->bsize / 512) / 2);
  729.       if (b->files != -1 && b->ffree != -1) printf(" %d/%d", b->files - b->ffree, b->files);
  730.     }
  732.     printf("n");
  733.   }
  735.   free(buf);
  736. }
  738. static void lookup(char *name)
  739. {
  740.   struct hostent *hp;
  741.   int i;
  743.   if (!name || !*name) return;
  745.   if (*name >= '0' && *name <= '9')
  746.   {
  747.     struct in_addr addr;
  748.     addr.s_addr = inet_addr(name);
  749.     if (addr.s_addr == INADDR_NONE)
  750.     {
  751.       printf("%s: %sn", name, strerror(errno));
  752.       return;
  753.     }
  755.     hp = gethostbyaddr((char *) &addr, sizeof(struct in_addr), AF_INET);
  756.   }
  757.   else
  758.     hp = gethostbyname(name);
  760.   if (!hp)
  761.   {
  762.     printf("%s: %sn", name, strerror(errno));
  763.     return;
  764.   }
  766.   if (hp->h_addrtype != AF_INET)
  767.   {
  768.     printf("unknown address type %dn", hp->h_addrtype);
  769.     return;
  770.   }
  772.   if (hp->h_length != sizeof(struct in_addr))
  773.   {
  774.     printf("unknown address length %dn", hp->h_length);
  775.     return;
  776.   }
  778.   printf("name: %sn", hp->h_name);
  779.   for (i = 0; hp->h_aliases[i] != NULL; i++) printf("alias: %sn", hp->h_aliases[i]);
  780.   for (i = 0; hp->h_addr_list[i] != NULL; i++) 
  781.   {
  782.     struct in_addr *addr = (struct in_addr *) (hp->h_addr_list[i]);
  783.     printf("address: %sn", inet_ntoa(*addr));
  784.   }
  785. }
  787. static int read_line(int f, char *buf)
  788. {
  789.   char c;
  790.   int rc;
  791.   int count;
  793.   count = 0;
  794.   while ((rc = read(f, &c, 1)) > 0)
  795.   {
  796.     if (c == 'r') continue;
  797.     if (c == 'n')
  798.     {
  799.       *buf++ = 0;
  800.       return count;
  801.     }
  802.     *buf++ = c;
  803.     count++;
  804.   }
  806.   *buf = 0;
  807.   return rc;
  808. }
  810. static int httpget(char *server, char *path, char *filename)
  811. {
  812.   struct hostent *hp;
  813.   struct sockaddr_in sin;
  814.   int s;
  815.   int rc;
  816.   int n;
  817.   int count;
  818.   int f;
  819.   char *buf;
  821.   hp = gethostbyname(server);
  822.   if (!hp) return errno;
  824.   s = socket(AF_INET, SOCK_STREAM, 0);
  825.   if (s < 0) return s;
  827.   memset(&sin, 0, sizeof(sin));
  828.   sin.sin_family = AF_INET;
  829.   memcpy(&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
  830.   sin.sin_port = htons(80);
  832.   rc = connect(s, (struct sockaddr *) &sin, sizeof(sin));
  833.   if (rc  < 0)
  834.   {
  835.     close(s);
  836.     return rc;
  837.   }
  839.   buf = malloc(8*K);
  840.   if (!buf) return -ENOMEM;
  842.   sprintf(buf, "GET %s HTTP/1.0rnHost: %srnrn", path, server);
  843.   rc = send(s, buf, strlen(buf), 0);
  844.   if (rc < 0)
  845.   {
  846.     close(s);
  847.     return rc;
  848.   }
  850.   while ((rc = read_line(s, buf)) > 0)
  851.   {
  852.     //printf("hdr %sn", buf);
  853.   }
  855.   if (rc < 0) return rc;
  857.   f = open(filename, O_CREAT);
  858.   if (f < 0)
  859.   {
  860.     close(s);
  861.     free(buf);
  862.     return f;
  863.   }
  865.   count = 0;
  866.   while ((n = recv(s, buf, 8*K, 0)) > 0)
  867.   {
  868.     write(f, buf, n);
  869.     count += n;
  870.     //printf("count %dn", count);
  871.   }
  873.   if (rc < 0)
  874.   {
  875.     close(s);
  876.     close(f);
  877.     free(buf);
  878.     return n;
  879.   }
  881.   close(s);
  882.   close(f);
  883.   free(buf);
  885.   return count;
  886. }
  888. static char *httpgetbuf(char *server, char *path)
  889. {
  890.   struct hostent *hp;
  891.   struct sockaddr_in sin;
  892.   int s;
  893.   int rc;
  894.   int n;
  895.   int len;
  896.   int left;
  897.   char *buf;
  898.   char *p;
  900.   hp = gethostbyname(server);
  901.   if (!hp) return NULL;
  903.   s = socket(AF_INET, SOCK_STREAM, 0);
  904.   if (s < 0) return NULL;
  906.   memset(&sin, 0, sizeof(sin));
  907.   sin.sin_family = AF_INET;
  908.   memcpy(&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
  909.   sin.sin_port = htons(80);
  911.   rc = connect(s, (struct sockaddr *) &sin, sizeof(sin));
  912.   if (rc  < 0)
  913.   {
  914.     close(s);
  915.     return NULL;
  916.   }
  918.   buf = malloc(4096);
  919.   if (!buf) return NULL;
  921.   sprintf(buf, "GET %s HTTP/1.0rnrn", path);
  922.   rc = send(s, buf, strlen(buf), 0);
  923.   if (rc < 0)
  924.   {
  925.     close(s);
  926.     return NULL;
  927.   }
  929.   len = 0;
  930.   while ((rc = read_line(s, buf)) > 0)
  931.   {
  932.     p = strchr(buf, ':');
  933.     if (p)
  934.     {
  935.       *p++ = 0;
  936.       while (*p == ' ') p++;
  937.       if (strcmp(buf, "Content-Length") == 0) len = atoi(p);
  938.     }
  939.   }
  941.   if (rc < 0) return NULL;
  943.   printf("length is %dn", len);
  944.   buf = realloc(buf, len + 1);
  946.   p = buf;
  947.   left = len;
  948.   while (left > 0 && (n = recv(s, p, left, 0)) > 0)
  949.   {
  950.     p += n;
  951.     left -= n;
  952.   }
  954.   *p = 0;
  956.   if (rc < 0)
  957.   {
  958.     close(s);
  959.     free(buf);
  960.     return NULL;
  961.   }
  963.   close(s);
  964.   return buf;
  965. }
  967. static void http(int argc, char **argv)
  968. {
  969.   char *server;
  970.   char *path;
  971.   char *filename;
  972.   int rc;
  973.   clock_t t;
  975.   server = "192.168.12.1";
  976.   path = "/";
  977.   filename = "/dev/null";
  978.   
  979.   if (argc >= 2) server = argv[1];
  980.   if (argc >= 3) path = argv[2];
  981.   if (argc >= 4) filename = argv[3];
  982.   
  983.   t = clock();
  984.   rc = httpget(server, path, filename);
  985.   if (rc < 0)
  986.     printf("error %d '%s' retrieving %s from %sn", rc, strerror(rc), path, server);
  987.   else
  988.   {
  989.     t = clock() - t;
  990.     if (t == 0) t = 1;
  991.     printf("received %d bytes in %d ms (%d KB/s)n", rc, t, rc / t);
  992.   }
  993. }
  995. static void download(int argc, char **argv)
  996. {
  997.   char *server;
  998.   char *src;
  999.   char *dst;
  1000.   char fn[256];
  1001.   char path[256];
  1002.   char *files;
  1003.   char *p, *q;
  1004.   int dir;
  1005.   int rc;
  1007.   server = "192.168.12.1";
  1008.   src = "/sanos";
  1009.   dst = "/usr";
  1010.   
  1011.   if (argc >= 2) server = argv[1];
  1012.   if (argc >= 3) src = argv[2];
  1013.   if (argc >= 4) dst = argv[3];
  1015.   sprintf(path, "%s/FILES", src);
  1017.   files = httpgetbuf(server, path);
  1018.   if (!files)
  1019.   {
  1020.     printf("error retrieving file list from %sn", server);
  1021.     return;
  1022.   }
  1024.   p = files;
  1025.   while (*p)
  1026.   {
  1027.     q = p;
  1028.     while (*q)
  1029.     {
  1030.       if (q[0] == 'r') break;
  1031.       if (q[0] == '/' && q[1] == 'r') break;
  1032.       q++;
  1033.     }
  1035.     if (*q == '/')
  1036.     {
  1037.       dir = 1;
  1038.       *q++ = 0;
  1039.     }
  1040.     else
  1041.       dir = 0;
  1043.     *q++ = 0;
  1045.     if (dir)
  1046.     {
  1047.       printf("create directory %sn", p);
  1048.       sprintf(fn, "%s/%s", dst, p);
  1049.       rc = mkdir(fn);
  1050.       if (rc < 0) printf("%s: error %d '%s' creating directoryn", fn, rc, strerror(rc));
  1051.     }
  1052.     else
  1053.     {
  1054.       printf("download file %sn", p);
  1055.       sprintf(fn, "%s/%s", dst, p);
  1056.       sprintf(path, "%s/%s", src, p);
  1057.       rc = httpget(server, path, fn);
  1058.       if (rc < 0) printf("%s: error %d '%s' downloading filen", fn, rc, strerror(rc));
  1059.     }
  1061.     if (*q == 'n') *q++ = 0;
  1062.     p = q;
  1063.   }
  1065.   free(files);
  1066. }
  1068. static void heap_stat()
  1069. {
  1070.   struct mallinfo m;
  1072.   m = mallinfo();
  1074.   printf("Non-mmapped space allocated from system .. : %12dn", m.arena);
  1075.   printf("Number of free chunks .................... : %12dn", m.ordblks);
  1076.   printf("Number of fastbin blocks ................. : %12dn", m.smblks);
  1077.   printf("Number of mmapped regions ................ : %12dn", m.hblks);
  1078.   printf("Space in mmapped regions ................. : %12dn", m.hblkhd);
  1079.   printf("Maximum total allocated space ............ : %12dn", m.usmblks);
  1080.   printf("Space available in freed fastbin blocks .. : %12dn", m.fsmblks);
  1081.   printf("Total allocated space .................... : %12dn", m.uordblks);
  1082.   printf("Total free space ......................... : %12dn", m.fordblks);
  1083.   printf("Top-most, releasable space ............... : %12dn", m.keepcost);
  1084. }
  1086. static void httpinit()
  1087. {
  1088. #if 0
  1089.   struct httpd_server *server;
  1091.   server = httpd_initialize(find_section(config, "httpd"));
  1093.   httpd_add_file_context(server, "/", "/usr/www", find_section(config, "webroot"));
  1094.   httpd_add_file_context(server, "/files", "/", find_section(config, "webfs"));
  1096.   httpd_add_resource_context(server, "/icons", hmod, NULL);
  1098.   httpd_start(server);
  1099. #endif
  1100. }
  1102. static void test1(int argc, char **argv)
  1103. {
  1104.   struct servent *sp;
  1105.   char **alias;
  1107.   sp = getservbyname("echo", "tcp");
  1108.   while (sp->s_name != NULL)
  1109.   {
  1110.     printf("%s %d/%s", sp->s_name, sp->s_port, sp->s_proto);
  1112.     alias = sp->s_aliases;
  1113.     while (*alias)
  1114.     {
  1115.       printf(" %s", *alias);
  1116.       alias++;
  1117.     }
  1118.     printf("n");
  1120.     sp++;
  1121.   }
  1122. }
  1124. #if 0
  1125. static void test(int argc, char **argv)
  1126. {
  1127.   char *server;
  1128.   int port;
  1129.   struct hostent *hp;
  1130.   struct sockaddr_in sin;
  1131.   int sock;
  1132.   int rc;
  1134.   //server = "20.45.152.54";
  1135.   server = "192.168.123.190";
  1136.   port = 999;
  1138.   if (argc >= 2) server = argv[1];
  1139.   if (argc >= 3) port = atoi(argv[2]);
  1141.   hp = gethostbyname(server);
  1142.   if (!hp) return;
  1144.   sock = socket(AF_INET, SOCK_STREAM, 0);
  1145.   if (sock < 0) return;
  1147.   memset(&sin, 0, sizeof(sin));
  1148.   sin.sin_family = AF_INET;
  1149.   memcpy(&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
  1150.   sin.sin_port = htons(port);
  1152.   rc = connect(sock, (struct sockaddr *) &sin, sizeof(sin));
  1153.   if (rc  < 0)
  1154.   {
  1155.     syslog(LOG_ERR, "error %d in connect: %sn", rc, strerror(rc));
  1156.     close(sock);
  1157.   }
  1159.   close(sock);
  1160. }
  1161. #endif
  1163. #if 0
  1164. static void test(int argc, char **argv)
  1165. {
  1166.   char *fmt = "test %%f=[%f] %%g=[%g] %%e=[%e]";
  1168.   if (argc > 1) fmt = argv[1];
  1169.   printf(fmt, -1.2345, 12345.6789, 0.0987654321, -123456);
  1170.   printf("n");
  1171. }
  1172. #endif
  1174. void __stdcall pipereader(void *arg)
  1175. {
  1176.   int f = (int) arg;
  1177.   char buf[128];
  1178.   int rc;
  1180.   while ((rc = read(f, buf, 128)) > 0)
  1181.   {
  1182.     printf("piperead: %d bytes [", rc);
  1183.     write(fdout, buf, rc);
  1184.     printf("]n");
  1185.   }
  1187.   printf("piperead: exit rc=%dn", rc);
  1188.   close(f);
  1189. }
  1191. static void pipetest(int argc, char **argv)
  1192. {
  1193.   int fildes[2];
  1194.   int hthread;
  1195.   int rc;
  1196.   int i;
  1198.   rc = pipe(fildes);
  1199.   if (rc < 0)
  1200.   {
  1201.     printf("error %d in pipe()n", rc);
  1202.     return;
  1203.   }
  1205.   hthread = beginthread(pipereader, 0, (void *) fildes[0], 0, NULL);
  1206.   close(hthread);
  1208.   for (i = 0; i < argc; i++)
  1209.   {
  1210.     printf("pipewrite: %d bytes [", strlen(argv[i]));
  1211.     write(fdout, argv[i], strlen(argv[i]));
  1212.     printf("]n");
  1214.     write(fildes[1], argv[i], strlen(argv[i]));
  1215.   }
  1217.   close(fildes[1]);
  1218. }
  1220. static void disktest(int argc, char **argv)
  1221. {
  1222.   int dev;
  1223.   int n;
  1224.   int rc;
  1226.   dev = open(argv[1], O_RDWR | O_DIRECT);
  1227.   if (dev < 0) 
  1228.   {
  1229.     printf("Error %d opening devicen", dev);
  1230.     return;
  1231.   }
  1233.   for (n = 1; n < atoi(argv[2]); n++)
  1234.   {
  1235.     printf("checking block %dn", n);
  1236.     
  1237.     rc = lseek(dev, n * 4096, SEEK_SET);
  1238.     if (rc < 0) printf("lseek returned %dn", rc);
  1240.     rc = read(dev, orig, 4096);
  1241.     if (rc < 0) printf("read returned %dn", rc);
  1243.     rc = lseek(dev, n * 4096, SEEK_SET);
  1244.     if (rc < 0) printf("lseek returned %dn", rc);
  1246.     memset(pattern, n & 0xFF, 4096);
  1247.     rc = write(dev, pattern, 4096);
  1248.     if (rc < 0) printf("write returned %dn", rc);
  1250.     rc = lseek(dev, n * 4096, SEEK_SET);
  1251.     if (rc < 0) printf("lseek returned %dn", rc);
  1253.     memset(buffer, 0, 4096);
  1254.     rc = read(dev, buffer, 4096);
  1255.     if (rc < 0) printf("read returned %dn", rc);
  1257.     if (memcmp(pattern, buffer, 4096) != 0) printf("error in test patternn");
  1259.     rc = lseek(dev, n * 4096, SEEK_SET);
  1260.     if (rc < 0) printf("lseek returned %dn", rc);
  1262.     rc = write(dev, orig, 4096);
  1263.     if (rc < 0) printf("write returned %dn", rc);
  1264.   
  1265.     rc = lseek(dev, n * 4096, SEEK_SET);
  1266.     if (rc < 0) printf("lseek returned %dn", rc);
  1268.     memset(buffer, 0, 4096);
  1269.     rc = read(dev, buffer, 4096);
  1270.     if (rc < 0) printf("read returned %dn", rc);
  1272.     if (memcmp(orig, buffer, 4096) != 0) printf("error in verifyn");
  1273.   }
  1275.   close(dev);
  1276. }
  1278. __inline long __declspec(naked) rdtscl()
  1279. {
  1280.   __asm { rdtsc }
  1281.   __asm { ret }
  1282. }
  1284. static void nop()
  1285. {
  1286.   long before;
  1287.   long after;
  1288.   long cycles;
  1289.   int i;
  1290.   long min;
  1291.   long max;
  1292.   long sum;
  1294.   if (!peb->fast_syscalls_supported)
  1295.   {
  1296.     printf("error: processor does not support sysenter/sysexitn");
  1297.     return;
  1298.   }
  1300.   peb->fast_syscalls_supported = 0;
  1301.   min = 0x7FFFFFFF;
  1302.   max = 0;
  1303.   sum = 0;
  1305.   for (i = 0; i < 1000; i++)
  1306.   {
  1307.     before = rdtscl();
  1308.     syscall(0,0);
  1309.     after = rdtscl();
  1311.     cycles = after - before;
  1312.     if (cycles < min) min = cycles;
  1313.     if (cycles > max) max = cycles;
  1314.     sum += cycles;
  1315.   }
  1317.   printf("syscall(0,0) with int 48: min/avg/max %d/%d/%d cyclesn", min, sum / 1000, max);
  1319.   peb->fast_syscalls_supported = 1;
  1320.   min = 0x7FFFFFFF;
  1321.   max = 0;
  1322.   sum = 0;
  1324.   for (i = 0; i < 1000; i++)
  1325.   {
  1326.     before = rdtscl();
  1327.     syscall(0,0);
  1328.     after = rdtscl();
  1330.     cycles = after - before;
  1331.     if (cycles < min) min = cycles;
  1332.     if (cycles > max) max = cycles;
  1333.     sum += cycles;
  1334.   }
  1336.   printf("syscall(0,0) with sysenter: min/avg/max %d/%d/%d cyclesn", min, sum / 1000, max);
  1337. }
  1339. static void divtesthandler(int signum, struct siginfo *info)
  1340. {
  1341.   printf("in handlern");
  1342.   info->ctxt.ecx = 10;
  1343. }
  1345. static void test(int argc, char **argv)
  1346. {
  1347.   signal(SIGFPE, divtesthandler);
  1348.   printf("100/0=%dn", 100 / atoi(argv[1]));
  1349.   signal(SIGFPE, SIG_DFL);
  1350. }
  1352. static void set_kprint(int enabled)
  1353. {
  1354.   ioctl(1, IOCTL_KPRINT_ENABLED, &enabled, 4);
  1355. }
  1357. static void beep()
  1358. {
  1359.   ioctl(1, IOCTL_BEEP, NULL, 0);
  1360. }
  1362. static void sound(int freq)
  1363. {
  1364.   ioctl(1, IOCTL_SOUND, &freq, 4);
  1365. }
  1367. static void play_file(int argc, char **argv)
  1368. {
  1369.   extern void play(char *song);
  1371. #if 0
  1372.   char buffer[4096];
  1373.   FILE *f;
  1375.   f = fopen("tunes.txt", "r");
  1376.   while (fgets(buffer, sizeof buffer, f))
  1377.   {
  1378.     printf("%sn", buffer);
  1379.     play(buffer);
  1380.   }
  1381.   fclose(f);
  1382. #endif
  1384.   //play("AxelF:d=4, o=5, b=160:f#, 8a., 8f#, 16f#, 8a#, 8f#, 8e, f#, 8c.6, 8f#, 16f#, 8d6, 8c#6, 8a, 8f#, 8c#6, 8f#6, 16f#, 8e, 16e, 8c#, 8g#, f#.");
  1385.   //play("dualingbanjos:d=4, o=5, b=200:8c#, 8d, e, c#, d, b4, c#, d#4, b4, p, 16c#6, 16p, 16d6, 16p, 8e6, 8p, 8c#6, 8p, 8d6, 8p, 8b, 8p, 8c#6, 8p, 8a, 8p, b, p, a4, a4, b4, c#, d#4, c#, b4, p, 8a, 8p, 8a, 8p, 8b, 8p, 8c#6, 8p, 8a, 8p, 8c#6, 8p, 8b");
  1386.   play("Entertainer:d=4, o=5, b=140:8d, 8d#, 8e, c6, 8e, c6, 8e, 2c.6, 8c6, 8d6, 8d#6, 8e6, 8c6, 8d6, e6, 8b, d6, 2c6, p, 8d, 8d#, 8e, c6, 8e, c6, 8e, 2c.6, 8p, 8a, 8g, 8f#, 8a, 8c6, e6, 8d6, 8c6, 8a, 2d6");
  1387.   //play("Barbiegirl:d=4,o=5,b=125:8g#,8e,8g#,8c#6,a,p,8f#,8d#,8f#,8b,g#,8f#,8e,p,8e,8c#,f#,c#,p,8f#,8e,g#,f#");
  1388.   //play("Muppets:d=4, o=5, b=250:c6, c6, a, b, 8a, b, g, p, c6, c6, a, 8b, 8a, 8p, g., p, e, e, g, f, 8e, f, 8c6, 8c, 8d, e, 8e, 8e, 8p, 8e, g, 2p, c6, c6, a, b, 8a, b, g, p, c6, c6, a, 8b, a, g., p, e, e, g, f, 8e, f, 8c6, 8c, 8d, e, 8e, d, 8d, c");
  1389. }
  1391. static void reboot()
  1392. {
  1393.   ioctl(1, IOCTL_REBOOT, NULL, 0);
  1394. }
  1396. static void kbdtest()
  1397. {
  1398.   int escs;
  1399.   unsigned char ch;
  1400.   int rc;
  1402.   escs = 0;
  1403.   while (1)
  1404.   {
  1405.     rc = read(gettib()->in, &ch, 1);
  1406.     if (rc != 1)
  1407.     {
  1408.       printf("Error %d in readn", rc);
  1409.       break;
  1410.     }
  1412.     if (ch == 0x1B) 
  1413.       escs++;
  1414.     else
  1415.       escs = 0;
  1417.     if (escs == 3) break;
  1419.     printf("[0x%02X]", ch);
  1420.   }
  1421.   printf("n");
  1422. }
  1424. void shell()
  1425. {
  1426.   char cmd[256];
  1427.   int argc;
  1428.   char **argv;
  1430.   while (1)
  1431.   {
  1432.     printf("%s$ ", getcwd(cmd, 256));
  1433.     if (readline(fdin, cmd, 256) < 0) break;
  1435.     argc = parse_args(cmd, NULL);
  1436.     if (argc)
  1437.     {
  1438.       argv = (char **) malloc(argc * sizeof(char *));
  1439.       parse_args(cmd, argv);
  1440.     
  1441.       if (strcmp(argv[0], "exit") == 0) 
  1442. break;
  1443.       else if (strcmp(argv[0], "ls") == 0 || strcmp(argv[0], "dir") == 0)
  1444. list_dir(argc, argv);
  1445.       else if (strcmp(argv[0], "cat") == 0 || strcmp(argv[0], "type") == 0)
  1446. list_file(argv[1]);
  1447.       else if (strcmp(argv[0], "cp") == 0 || strcmp(argv[0], "copy") == 0)
  1448. copy_file(argv[1], argv[2]);
  1449.       else if (strcmp(argv[0], "rm") == 0 || strcmp(argv[0], "del") == 0)
  1450. remove_file(argv[1]);
  1451.       else if (strcmp(argv[0], "mv") == 0 || strcmp(argv[0], "move") == 0)
  1452. move_file(argv[1], argv[2]);
  1453.       else if (strcmp(argv[0], "chdir") == 0 || strcmp(argv[0], "cd") == 0)
  1454. change_dir(argv[1]);
  1455.       else if (strcmp(argv[0], "mkdir") == 0 || strcmp(argv[0], "md") == 0)
  1456. make_dir(argv[1]);
  1457.       else if (strcmp(argv[0], "rmdir") == 0 || strcmp(argv[0], "rd") == 0)
  1458. remove_dir(argv[1]);
  1459.       else if (strcmp(argv[0], "mount") == 0)
  1460. mount_device(argc, argv);
  1461.       else if (strcmp(argv[0], "format") == 0)
  1462. format_device(argc, argv);
  1463.       else if (strcmp(argv[0], "umount") == 0)
  1464. umount_device(argc, argv);
  1465.       else if (strcmp(argv[0], "du") == 0)
  1466. disk_usage(argc, argv);
  1467.       else if (strcmp(argv[0], "date") == 0)
  1468. show_date(argc, argv);
  1469.       else if (strcmp(argv[0], "read") == 0)
  1470. test_read_file(argv[1]);
  1471.       else if (strcmp(argv[0], "more") == 0)
  1472. display_file(argv[1]);
  1473.       else if (strcmp(argv[0], "write") == 0)
  1474. test_write_file(argv[1], atoi(argv[2]) * K);
  1475.       else if (strcmp(argv[0], "disktest") == 0)
  1476. disktest(argc, argv);
  1477.       else if (strcmp(argv[0], "cls") == 0)
  1478. printf("f");
  1479.       else if (strcmp(argv[0], "log") == 0)
  1480. set_loglevel(argv[1], atoi(argv[2]));
  1481.       else if (strcmp(argv[0], "heapstat") == 0)
  1482. heap_stat();
  1483.       else if (strcmp(argv[0], "kp") == 0)
  1484. set_kprint(atoi(argv[1]));
  1485.       else if (strcmp(argv[0], "start") == 0)
  1486.         launch_program(cmd);
  1487.       else if (strcmp(argv[0], "load") == 0)
  1488. load_module(argc, argv);
  1489.       else if (strcmp(argv[0], "break") == 0)
  1490. dbgbreak();
  1491.       else if (strcmp(argv[0], "nop") == 0)
  1492. nop();
  1493.       else if (strcmp(argv[0], "sleep") == 0)
  1494. idle_sleep(atoi(argv[1]));
  1495.       else if (strcmp(argv[0], "loop") == 0)
  1496. busy_loop(atoi(argv[1]));
  1497.       else if (strcmp(argv[0], "lookup") == 0 || strcmp(argv[0], "nslookup") == 0)
  1498. lookup(argv[1]);
  1499.       else if (strcmp(argv[0], "http") == 0)
  1500. http(argc, argv);
  1501.       else if (strcmp(argv[0], "download") == 0)
  1502. download(argc, argv);
  1503.       else if (strcmp(argv[0], "reboot") == 0)
  1504. reboot();
  1505.       else if (strcmp(argv[0], "beep") == 0)
  1506. beep();
  1507.       else if (strcmp(argv[0], "sound") == 0)
  1508. sound(atoi(argv[1]));
  1509.       else if (strcmp(argv[0], "play") == 0)
  1510. play_file(argc, argv);
  1511.       else if (strcmp(argv[0], "test") == 0)
  1512. test(argc, argv);
  1513.       else if (strcmp(argv[0], "kbd") == 0)
  1514. kbdtest();
  1515.       else if (strcmp(argv[0], "cstest") == 0)
  1516. cstest();
  1517.       else
  1518. exec_program(cmd);
  1520.       free_args(argc, argv);
  1521.     }
  1522.   }
  1523. }
  1525. void __stdcall ttyd(void *arg)
  1526. {
  1527.   char *devname = (char *) arg;
  1528.   handle_t f;
  1529.   struct serial_config cfg;
  1531.   f = open(devname, O_RDWR);
  1532.   if (f < 0) 
  1533.   {
  1534.     syslog(LOG_INFO, "Error %d starting shell on device %sn", f, devname);
  1535.     endthread(1);
  1536.   }
  1538.   cfg.speed = 115200;
  1539.   cfg.databits = 8;
  1540.   cfg.stopbits = 1;
  1541.   cfg.rx_timeout = INFINITE;
  1542.   cfg.tx_timeout = INFINITE;
  1543.   cfg.parity = PARITY_NONE;
  1545.   ioctl(f, IOCTL_SERIAL_SETCONFIG, &cfg, sizeof(struct serial_config));
  1547.   syslog(LOG_INFO, "sh: starting shell on device %sn", devname);
  1549.   gettib()->in = f;
  1550.   gettib()->out = f;
  1551.   gettib()->err = f;
  1553.   shell();
  1555.   close(f);
  1556. }
  1558. void __stdcall telnet_task(void *arg)
  1559. {
  1560.   int s = (int) arg;
  1562.   gettib()->in = s;
  1563.   gettib()->out = s;
  1564.   gettib()->err = s;
  1566. #ifdef DEBUG
  1567.   printf("%s version %s (Debug Build %s %s)n", OSNAME, OSVERSION, __DATE__, __TIME__);
  1568. #else
  1569.   printf("%s version %s (Build %s %s)n", OSNAME, OSVERSION, __DATE__, __TIME__);
  1570. #endif
  1571.   printf("%snn", COPYRIGHT);
  1573.   shell();
  1575.   close(s);
  1576. }
  1578. void __stdcall telnetd(void *arg)
  1579. {
  1580.   int s;
  1581.   int client;
  1582.   int rc;
  1583.   struct sockaddr_in sin;
  1584.   int hthread;
  1586.   s = socket(AF_INET, SOCK_STREAM, 0);
  1587.   if (s < 0)
  1588.   {
  1589.     printf("telnetd: error %d in socketn", s);
  1590.     return;
  1591.   }
  1593.   sin.sin_len = sizeof(struct sockaddr_in);
  1594.   sin.sin_family = AF_INET;
  1595.   sin.sin_addr.s_addr = INADDR_ANY;
  1596.   sin.sin_port = htons(23);
  1597.   rc = bind(s, (struct sockaddr *) &sin, sizeof sin);
  1598.   if (rc < 0)
  1599.   {
  1600.     printf("telnetd: error %d in bindn", rc);
  1601.     return;
  1602.   }
  1604.   rc = listen(s, 5);
  1605.   if (rc < 0)
  1606.   {
  1607.     printf("telnetd: error %d in listenn", rc);
  1608.     return;
  1609.   }
  1611.   while (1)
  1612.   {
  1613.     struct sockaddr_in sin;
  1615.     client = accept(s, (struct sockaddr *) &sin, NULL);
  1616.     if (client < 0)
  1617.     {
  1618.       printf("telnetd: error %d in acceptn", client);
  1619.       return;
  1620.     }
  1622.     syslog(LOG_INFO, "telnetd: client connected from %an", &sin.sin_addr);
  1624.     hthread = beginthread(telnet_task, 0, (void *) client, 0, NULL);
  1625.     close(hthread);
  1626.   }
  1627. }
  1629. int main(int argc, char *argv[])
  1630. {
  1631.   //beginthread(ttyd, 0, "/dev/com4", 0, NULL);
  1632.   if (peb->ipaddr.s_addr != INADDR_ANY) beginthread(telnetd, 0, NULL, 0, NULL);
  1633.   shell();
  1634.   return 0;
  1635. }