home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 3: The Continuation / 17-Bit_The_Continuation_Disc.iso / amigan / amigan 15 / defdisk / defdisk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-27  |  7.9 KB  |  290 lines
  1. /*
  2.  * DEFDISK.C
  3.  *
  4.  * A program to make a specified disk/directory the default system disk.
  5.  * It accomplishes this by resetting the DOS library structures to point
  6.  * to the new path. To use this program you will need to compile it as
  7.  * follows:
  8.  *        1> cc defdisk
  9.  *        1> ln defdisk.o -lc
  10.  *
  11.  * Real simple.  I used AZTEC C v3.40a, but I think that 3.30c or later would
  12.  * also work.  It should be possible to compile & build it under LATTICE as
  13.  * well, though I haven't tried.  Once the program is built, put it on your
  14.  * Workbench boot disk somewhere, load up your ram: disk or hard disk and
  15.  *
  16.  *        1> defdisk dh0:
  17.  *              or
  18.  *        1> defdisk dh0:bin
  19.  *
  20.  * Woila! the standard workbench assignments are now pointed at the hard
  21.  * disk. (SYS, C, L, DEVS, LIBS, FONTS)  The advantage to me in using this
  22.  * is that I don't have to load the Amiga DOS assign program 6 times to
  23.  * point the system at the hard disk.
  24.  *
  25.  * Author: J. K. Levie
  26.  *
  27.  * Version 1.0 31-Mar-1987
  28.  */
  29.  
  30. #include <stdio.h>
  31. #include <functions.h>
  32. #include <exec/types.h>
  33. #include <exec/exec.h>
  34. #include <libraries/dos.h>
  35. #include <libraries/dosextens.h>
  36.  
  37. extern void BtoCSTR();            /* forward ... */
  38. extern void CtoBSTR();            /* ... references */
  39.  
  40. struct DevInfo
  41. {
  42.    BPTR di_Next;
  43.    LONG di_Type;
  44.    APTR di_Task;
  45.    BPTR di_Lock;
  46.    BSTR di_Handler;
  47.    LONG di_StackSize;
  48.    LONG di_Priority;
  49.    LONG di_Startup;
  50.    BPTR di_SegList;
  51.    BPTR di_GlobVec;
  52.    BSTR di_Name;
  53. };
  54. struct DosLibrary *dosBase;
  55. struct RootNode *root;
  56. struct DosInfo *info;
  57. struct DevInfo *dev_head, *dev_ele;
  58. struct Lock *lock;
  59.  
  60. /*
  61.  * Define the logical to physical table.
  62.  */
  63. struct ASSIGNS
  64. {
  65.    char *log_name;            /* logical name to look for */
  66.    char *phy_name;            /* physical name to assign */
  67.    short success;            /* result 0=> failure, 1=> success */
  68. };
  69. struct ASSIGNS assigns[]=
  70. {
  71.    "SYS",   NULL,    0,
  72.    "C",     "c",     0,
  73.    "DEVS",  "devs",  0,
  74.    "LIBS",  "libs",  0,
  75.    "L",     "l",     0,
  76.    "S",     "s",     0,
  77.    "FONTS", "fonts", 0,
  78.    NULL,    NULL
  79. };
  80.  
  81.  
  82.  
  83.  
  84. main(argc, argv)
  85. int argc;
  86. char *argv[];
  87. {
  88.    char *ptr, *path;
  89.    register int len, n;
  90.  
  91.    /*
  92.     * See if we can get a lock on the new C directory, if we can't
  93.     * we won't even attempt to do the assigns.
  94.     */
  95.    path=argv[1];
  96.    if(argc!=2 || *path=='?')        /* correct arg cnt?  useage? */
  97.    {
  98.       printf("Usage: defdisk dev:[dir.../dir]\n");
  99.       exit(20);
  100.    }
  101.    /*
  102.     * Now we are ready to fill in the logical name table.  Handle the 
  103.     * Sys logical first since it will not have anything appended.  Then
  104.     * see if we will need to append a path separator to the user
  105.     * specified path.  We stop appending when we see the "T" logical.
  106.     */
  107.    assigns[0].phy_name=path;        /* Sys is special case */
  108.    len=1+strlen(path);            /* find length of physical name */
  109.    if(path[strlen(path)-1]!=':')    /* path specify the root of volume? */
  110.    {
  111.       len++;                /* room for path separator */
  112.       ptr=AllocMem((long)(len+1), MEMF_PUBLIC);
  113.       strcpy(ptr, path);        /* put user specified path in ... */
  114.       strcat(ptr, "/");            /* ... and path separator */
  115.       path=ptr;                /* point to new path */
  116.    }
  117.    /*
  118.     * Now fill in the rest of the table.  Allocate memory for the
  119.     * complete physical name and the directory specified in the table
  120.     * entry.  Then concatenate the path and the directory and set up
  121.     * the new pointer.
  122.     */
  123.    for(n=1; assigns[n].log_name[0]!=NULL; n++)
  124.    {
  125.       ptr=AllocMem((long)(len+strlen(assigns[n].log_name)), MEMF_PUBLIC);
  126.       strcpy(ptr, path);
  127.       strcat(ptr, assigns[n].phy_name);
  128.       assigns[n].phy_name=ptr;
  129.    }
  130.    /*
  131.     * Convert the logical names to B strings.
  132.     */
  133.    for(n=0; assigns[n].log_name!=NULL; n++) CtoBSTR(assigns[n].log_name);
  134.  
  135.    /*
  136.     * Now for a little paranoia.  I don't want to point the system
  137.     * somewhere that doesn't contain a C directory.
  138.     */
  139.    lock=Lock(assigns[1].phy_name, SHARED_LOCK);
  140.    if(lock==NULL)            /* are we sane? */
  141.    {
  142.       /*
  143.        * NO!  Makes no sense to set the system volume to something that
  144.        * doesn't contain a c directory.
  145.        */
  146.       printf("defdisk-F-%s does not contain a C directory\n",
  147.               assigns[1].phy_name);
  148.       exit(20);
  149.    }
  150.    UnLock(lock);            /* Okay unlock the c directory */
  151.  
  152.    /*
  153.     * Now open the resources we will need.
  154.     */
  155.    dosBase=(struct DosLibrary *)OpenLibrary(DOSNAME);
  156.    root=(struct RootNode *)dosBase->dl_Root;
  157.    info=(struct DosInfo *)BADDR(root->rn_Info);
  158.    dev_head=(struct DevInfo *)BADDR(info->di_DevInfo);
  159.  
  160.    Forbid();                /* only us & nobody else */
  161.    /*
  162.     * Walk the DevInfo list looking for the locigal names to change.  For
  163.     * each entry in the list we can check each of the entries in the
  164.     * logical name table.  As we find them reset each logical to point
  165.     * to the new system volume.
  166.     */
  167.    for(dev_ele=dev_head; dev_ele->di_Next;
  168.        dev_ele=(struct DevInfo *)BADDR(dev_ele->di_Next))
  169.    {
  170.       /*
  171.        * Check against each of the logical names in the table.
  172.        */
  173.       for(n=0; assigns[n].log_name!=NULL; n++)
  174.       {
  175.          /*
  176.           * See if this one matches.
  177.           */
  178.          if(Bstrcmp(BADDR(dev_ele->di_Name), assigns[n].log_name))
  179.          {
  180.             /*
  181.              * Name matches, is it the correct type?
  182.              */
  183.             if(dev_ele->di_Type!=DLT_DIRECTORY)
  184.             {
  185.                /*
  186.                 * No put logical name back to a C string and error out.
  187.                 */
  188.                BtoCSTR(assigns[n].log_name);
  189.                printf("defdisk-F-cannot reassign %s\n", assigns[n].log_name);
  190.                goto done;
  191.             }
  192.             /*
  193.              * Okay get a lock on the physical name for this logical.
  194.              */
  195.             lock=Lock(assigns[n].phy_name, SHARED_LOCK);
  196.             if(!lock)
  197.             {
  198.                /*
  199.                 * Whoops, failed somehow, tell the world about it.
  200.                 */
  201.                printf("defdisk-F-cannot get a lock on %s\n", assigns[n].phy_name);
  202.                goto done;
  203.             }
  204.             /*
  205.              * Time to clean up the old logical and point it to our
  206.              * physical name.
  207.              */
  208.             UnLock(dev_ele->di_Lock);
  209.             dev_ele->di_Lock=(BPTR)lock;
  210.             dev_ele->di_Task=(APTR)(DeviceProc(assigns[n].phy_name));
  211.             assigns[n].success=1;    /* flag that we did this one */
  212.          }
  213.       }
  214.    }
  215. done:
  216.    Permit();                /* release the system */
  217.    CloseLibrary(dosBase);        /* clean up */
  218.    
  219.    /*
  220.     * Now check to see that all of the assignments were made.
  221.     */
  222.    for(n=0; assigns[n].log_name!=NULL; n++)
  223.    {
  224.       if(assigns[n].success!=1) printf("defdisk-F-assignments failed\n");
  225.    }
  226. }
  227.  
  228.  
  229.  
  230. /*
  231.  * Bstrcmp(a, b)
  232.  *
  233.  * Compare two btrings for equality, case insensitive.
  234.  */
  235. Bstrcmp(a, b)
  236. char *a, *b;
  237. {
  238.    int len=(int)*a;            /* first char of B string is length */
  239.  
  240.    for(len++; len!=0; len--)        /* compare at most all */
  241.    {
  242.       if((*a&~0x20)!=(*b&~0x20)) return(0); /* quit if not equal */
  243.       a++;                /* point both ... */
  244.       b++;                /* ... at next character */
  245.    }
  246.    return(1);                /* they matched */
  247. }
  248.  
  249.  
  250.  
  251. /*
  252.  * BtoCSTR(bstr)
  253.  *
  254.  * Convert (in place) a B string to a C string.
  255.  */
  256. void BtoCSTR(bstr)
  257. char *bstr;
  258. {
  259.    register int i;
  260.    register UBYTE *bptr, *cptr;
  261.  
  262.    cptr=(UBYTE *)bstr;            /* point to input B string */
  263.    bptr=cptr;                /* output starts at B string len spot */
  264.    for(i=*bptr++; i!=0; i--) *cptr++=*bptr++; /* left shift the string */
  265.    *cptr='\0';                /* terminate it */
  266. }
  267.  
  268.  
  269.  
  270. /*
  271.  * CtoBSTR(cstr)
  272.  *
  273.  * Convert (in place) a C string to a B string.
  274.  */
  275. void CtoBSTR(cstr)
  276. char *cstr;
  277. {
  278.    register int i, len;
  279.    register UBYTE *cptr, *bptr;
  280.  
  281.    cptr=(UBYTE *)cstr;            /* pointer to input */
  282.    for(i=0; *cptr; i++, cptr++);    /* count & push pointer to input */
  283.    len=i;                /* save count */
  284.    bptr=cptr;                /* point at end of input */
  285.    cptr--;                /* back up over null */
  286.    while(i--) *bptr--=*cptr--;        /* right the string */
  287.    *bptr=(UBYTE)len;            /* stuff in the string length */
  288. }
  289.  
  290.