home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 13 / CDA13.ISO / MISC / SRC / INSTALL / COMMANDS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-23  |  4.3 KB  |  242 lines
  1. #include <errno.h>
  2. #include <fcntl.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <sys/mount.h>
  7. #include <sys/stat.h>
  8. #include <sys/sysmacros.h>
  9. #include <unistd.h>
  10.  
  11. #include "commands.h"
  12. #include "fs.h"
  13.  
  14. static int copyfd(int to, int from);
  15.  
  16. static int copyfd(int to, int from) {
  17.     char buf[1024];
  18.     int size;
  19.  
  20.     while ((size = read(from, buf, sizeof(buf))) > 0) {
  21.     if (write(to, buf, size) != size) {
  22.         fprintf(stderr, "error writing output: %s\n", strerror(errno));
  23.         return 1;
  24.     }
  25.     }
  26.  
  27.     if (size < 0) {
  28.     fprintf(stderr, "error reading input: %s\n", strerror(errno));
  29.     return 1;
  30.     }
  31.  
  32.     return 0;
  33. }
  34.  
  35. static int catFile(char * filename) {
  36.     int fd;
  37.     int rc;
  38.  
  39.     fd = open(filename, O_RDONLY);
  40.     if (fd < 0) {
  41.     fprintf(stderr, "cannot open %s: %s\n", filename, strerror(errno));
  42.     return 1;
  43.     }
  44.  
  45.     rc = copyfd(0, fd);
  46.     close(fd);
  47.  
  48.     return rc;
  49. }
  50.  
  51. int catCommand(int argc, char ** argv) {
  52.     char ** argptr = argv + 1;
  53.     int rc;
  54.  
  55.     if (!*argptr) {
  56.     return copyfd(1, 0);
  57.     } else {
  58.     while (*argptr) {
  59.         rc = catFile(*argptr);
  60.         if (rc) return rc;
  61.         argptr++;
  62.     }
  63.     }
  64.  
  65.     return 0;
  66. }
  67.  
  68. int lsmodCommand(int argc, char ** argv) {
  69.     puts("Module:        #pages:  Used by:");
  70.     catFile("/proc/modules");
  71.  
  72.     return 0;
  73. }
  74.  
  75. #define MOUNT_USAGE fprintf(stderr, "usage: mount -t <fs> <device> <dir>\n" \
  76.             "       (if /dev/ is left off the device name, a " \
  77.             "temporary node will be created)\n")
  78.  
  79. int mountCommand(int argc, char ** argv) {
  80.     char * dev, * dir;
  81.     char * fs;
  82.  
  83.     if (argc < 2) {
  84.     return catFile("/proc/mounts");
  85.     } else if (argc == 3) {
  86.     if (strchr(argv[1], ':'))
  87.         fs = "nfs";
  88.     else
  89.         fs = "ext2";
  90.     dev = argv[1];
  91.     dir = argv[2];
  92.     } else if (argc != 5) {
  93.     MOUNT_USAGE;
  94.     return 1;
  95.     } else {
  96.     if (strcmp(argv[1], "-t")) {
  97.         MOUNT_USAGE;
  98.         return 1;
  99.     }
  100.     
  101.     fs = argv[2];
  102.     dev = argv[3];
  103.     dir = argv[4];
  104.  
  105.     }
  106.  
  107.     if (!strncmp(dev, "/dev/", 5) && access(dev, X_OK)) 
  108.     dev += 5;
  109.  
  110.     if (doMount(dev, dir, fs, 0, 1))
  111.     return 1;
  112.  
  113.     return 0;
  114. }
  115.  
  116. int umountCommand(int argc, char ** argv) {
  117.     if (argc != 2) {
  118.     fprintf(stderr, "umount expects a single argument\n");
  119.     return 1;
  120.     }
  121.  
  122.     if (umount(argv[1])) {
  123.     fprintf(stderr, "error unmounting %s: %s\n", argv[1], strerror(errno));
  124.     return 1;
  125.     }
  126.  
  127.     return 0;
  128. }
  129.  
  130. int mkdirCommand(int argc, char ** argv) {
  131.     char ** argptr = argv + 1;
  132.  
  133.     if (argc < 2) {
  134.     fprintf(stderr, "umount expects one or more arguments\n");
  135.     return 1;
  136.     }
  137.  
  138.     while (*argptr) {
  139.     if (mkdir(*argptr, 0755)) {
  140.         fprintf(stderr, "error creating directory %s: %s\n", *argptr,
  141.             strerror(errno));
  142.         return 1;
  143.     }
  144.  
  145.     argptr++;
  146.     }
  147.  
  148.     return 0;
  149. }
  150.  
  151. int mknodCommand(int argc, char ** argv) {
  152.     int major, minor;
  153.     char * path;
  154.     int mode = 0600;
  155.     char *end;
  156.  
  157.     if (argc != 5) {
  158.     fprintf(stderr, "usage: mknod <path> [b|c] <major> <minor>\n");
  159.     return 1;
  160.     }
  161.  
  162.     path = argv[1];
  163.     if (!strcmp(argv[2], "b")) 
  164.     mode |= S_IFBLK;
  165.     else if (!strcmp(argv[2], "c"))
  166.     mode |= S_IFCHR;
  167.     else {
  168.     fprintf(stderr, "unknown node type %s\n", argv[2]);
  169.     return 1;
  170.     } 
  171.  
  172.     major = strtol(argv[3], &end, 0);
  173.     if (*end) {
  174.     fprintf(stderr, "bad major number %s\n", argv[3]);
  175.     return 1;
  176.     }
  177.  
  178.     minor = strtol(argv[4], &end, 0);
  179.     if (*end) {
  180.     fprintf(stderr, "bad minor number %s\n", argv[4]);
  181.     return 1;
  182.     }
  183.  
  184.     if (mknod(path, mode, makedev(major, minor))) {
  185.     fprintf(stderr, "mknod failed: %s\n", strerror(errno));
  186.     return 1;
  187.     }
  188.  
  189.     return 0;
  190. }
  191.  
  192. int rmCommand(int argc, char ** argv) {
  193.     char ** argptr = argv + 1;
  194.  
  195.     if (argc < 2) {
  196.     fprintf(stderr, "rm expects one or more arguments "
  197.         "(no flags are supported");
  198.     return 1;
  199.     }
  200.  
  201.     while (*argptr) {
  202.     if (unlink(*argptr)) {
  203.         fprintf(stderr, "unlink of %s failed: %s\n", *argptr, 
  204.             strerror(errno));
  205.         return 1;
  206.     }
  207.  
  208.     argptr++;
  209.     }
  210.  
  211.     return 0;
  212. }
  213.  
  214. int chmodCommand(int argc, char ** argv) {
  215.     char ** argptr = argv + 2;
  216.     int mode;
  217.     char * end;
  218.  
  219.     if (argc < 3) {
  220.     fprintf(stderr, "usage: chmod <mode> <one or files>\n");
  221.     return 1;
  222.     }
  223.  
  224.     mode = strtol(argv[1], &end, 8);
  225.     if (*end) {
  226.     fprintf(stderr, "illegal mode %s\n", argv[1]);
  227.     return 1;
  228.     }
  229.  
  230.     while (*argptr) {
  231.     if (chmod(*argptr, mode)) {
  232.         fprintf(stderr, "error in chmod of %s to 0%o: %s\n", *argptr,
  233.             mode, strerror(errno));
  234.         return 1;
  235.     }
  236.  
  237.     argptr++;
  238.     }
  239.  
  240.     return 0;
  241. }
  242.