home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga Shareware Floppies / ma01.dms / ma01.adf / AddAssign / AddaInstall.c < prev    next >
C/C++ Source or Header  |  1992-04-26  |  10KB  |  499 lines
  1. /*
  2.     AddAssignInstall V1.04e
  3.     
  4.     (c) 1991 Alexander Rawass
  5.  
  6.     Alexander Rawass
  7.     Wilhelminenstr. 44
  8.     6700 Ludwigshafen 15
  9.     Germany
  10.     0621/57 75 98
  11. */
  12.  
  13. #include <libraries/dos.h>
  14. #include <libraries/dosextens.h>
  15. #include <exec/memory.h>
  16. #include <pragmas.h>
  17. #include <libraries/arp.h>
  18. #include <stdio.h>
  19.  
  20. #define    AR_USE_ARP
  21. #include "ar_defs.h"
  22.  
  23. #include "addassign.h"
  24.  
  25. #define    COM_MOVEQ    112
  26. #define    COM_BRA        24576
  27. #define    COM_JMP        0x4ef9
  28.  
  29. struct    vectentry {
  30.     BYTE    com_moveq;
  31.     BYTE    var_d0;
  32.     WORD    com_bra;
  33.     WORD    var_offset;
  34. }
  35. ;
  36.  
  37. struct    jumpvectentry {
  38.     UWORD    com_jmp;
  39.     ULONG    var_adress;
  40. }
  41. ;
  42.  
  43. LONG    _stack=4000;    /* for detaching from current cli process */
  44. LONG    _priority=0;
  45. LONG    _BackGroundIO=FALSE;
  46. STRPTR    _procname="AddAssignProcess V1.04e";
  47.  
  48. STRPTR    CLI_Help="\x1b[1mAddAssign Install V1.04e\x1b[0m - (c) 1991 Alexander Rawass\n";
  49.  
  50. struct    ArpBase        *ArpBase;
  51. struct    DosLibrary    *DosBase;
  52. struct    commandmessage    *waitmsg;
  53. struct    commandmessage    sendmsg;
  54. struct    MsgPort        *sendport,*waitport;
  55. struct    List        malist;
  56. struct    FileLock    *myout;
  57. struct    Process        *myproc;
  58.  
  59. BOOL    jmp_Lock,jmp_Open,jmp_LoadSeg;
  60.  
  61. CPTR    oldLock,oldOpen,oldCreateDir,oldLoadSeg;
  62.  
  63. LONG    oldLockd0,oldOpend0,oldCreateDird0,oldLoadSegd0;
  64.  
  65. LONG    Lockoffset=-84;
  66. LONG    Openoffset=-30;
  67. LONG    LoadSegoffset=-150;
  68.  
  69. extern int    xLock();
  70. extern int    xOpen();
  71. extern int    xLoadSeg();
  72.  
  73. extern int    dosLock();
  74. extern int    dosOpen();
  75. extern int    dosLoadSeg();
  76.  
  77. CPTR            NewLoadSeg(STRPTR name);
  78. struct    FileLock    *NewLock(STRPTR name,LONG mode);
  79. struct    FileHandle    *NewOpen(STRPTR name,LONG mode);
  80.  
  81. #pragma    regcall(NewLock(d1,d2))
  82. #pragma    regcall(NewOpen(d1,d2))
  83. #pragma    regcall(NewLoadSeg(d1))
  84.  
  85. #include "ar_funcs.c"
  86.  
  87. /**************************************************************/
  88.  
  89. struct    MoreAssign    *findmanode(assign,node)
  90. STRPTR            assign;
  91. struct    MoreAssign    *node;
  92. {
  93.     REG struct    MoreAssign    *manode;
  94.  
  95.     if(node==NULL){
  96.         manode=malist.lh_Head;
  97.     }
  98.     else{
  99.         manode=node;
  100.         manode=manode->ma_node.ln_Succ;
  101.     }
  102.     
  103.     while((manode!=(struct MoreAssign *)&malist.lh_Tail) && (!STREQU(assign,&(manode->ma_assignname)))){
  104.         manode=manode->ma_node.ln_Succ;
  105.     }
  106.     
  107.     if(manode==(struct MoreAssign *)&malist.lh_Tail){
  108.         return(NULL);
  109.     }
  110.     else{
  111.         return(manode);
  112.     }
  113. }
  114.  
  115. /**************************************************************/
  116.  
  117. struct    MoreAssign    *checklock(curlock,node)
  118. struct    FileLock    *curlock;
  119. struct    MoreAssign    *node;
  120. {
  121.     REG struct    MoreAssign    *manode;
  122.  
  123.     if(node==NULL){
  124.         manode=malist.lh_Head;
  125.     }
  126.     else{
  127.         manode=node;
  128.         manode=manode->ma_node.ln_Succ;
  129.     }
  130.  
  131.     while((manode!=(struct MoreAssign *)&malist.lh_Tail) && (CompareLock(curlock,manode->ma_assignlock)!=LCK_EQUAL)){
  132.         manode=manode->ma_node.ln_Succ;
  133.     }
  134.  
  135.     if(manode==(struct MoreAssign *)&malist.lh_Tail){
  136.         return(NULL);
  137.     }
  138.     else{
  139.         return(manode);
  140.     }
  141. }
  142.  
  143. /**************************************************************/
  144.  
  145. struct    FileLock    *NewLock(name,mode)
  146. STRPTR                name;
  147. LONG                mode;
  148. {
  149.     struct    FileLock        *block;
  150.     struct    FileLock        *curlock;
  151.     struct    MoreAssign        *manode;
  152.     char    volume[256];
  153.     char    pathname[256];
  154.     STRPTR    basename,path;
  155.  
  156.     block=dosLock(name,mode);
  157.     
  158.     if(block){
  159.         return(block);
  160.     }
  161.     else {
  162.         path=name;
  163.         VolumeName(path,volume);
  164.         
  165.         if(volume[0]!=EOS){
  166.             curlock=dosLock(volume,SHARED_LOCK);
  167.         }
  168.         else{
  169.             curlock=dosLock(volume,SHARED_LOCK);
  170.         }
  171.         
  172.         manode=NULL;
  173.         do{
  174.             manode=checklock(curlock,manode);
  175.             if(manode){
  176.                 basename=BaseName(path);
  177.                 strcpy(pathname,manode->ma_pathname);
  178.                 TackOn(pathname,basename);
  179.                 block=dosLock(pathname,mode);
  180.             }
  181.         }
  182.         while(block==NULL && manode!=NULL);
  183.  
  184.         UNLOCKC(curlock);    
  185.         return(block);
  186.     }
  187. }
  188.  
  189. /**************************************************************/
  190.  
  191. struct    FileHandle    *NewOpen(name,mode)
  192. STRPTR    name;
  193. LONG    mode;
  194. {
  195.     struct    FileHandle        *bhandle;
  196.     struct    MoreAssign        *manode;
  197.     char    volume[256];
  198.     char    pathname[256];
  199.     STRPTR    basename,path;
  200.     struct    FileLock    *curlock;
  201.     
  202.     bhandle=dosOpen(name,mode);
  203.     
  204.     if(bhandle){
  205.         return(bhandle);
  206.     }
  207.     else {
  208.         path=name;
  209.         VolumeName(path,volume);
  210.         
  211.         if(volume[0]!=EOS){
  212.             curlock=dosLock(volume,SHARED_LOCK);
  213.         }
  214.         else{
  215.             curlock=dosLock(volume,SHARED_LOCK);
  216.         }
  217.         
  218.         manode=NULL;
  219.         do{
  220.             manode=checklock(curlock,manode);
  221.             if(manode){
  222.                 basename=BaseName(path);
  223.                 strcpy(pathname,manode->ma_pathname);
  224.                 TackOn(pathname,basename);
  225.                 bhandle=dosOpen(pathname,mode);
  226.             }
  227.         }
  228.         while(bhandle==NULL && manode!=NULL);
  229.  
  230.         UNLOCKC(curlock);    
  231.         return(bhandle);
  232.     }
  233. }
  234.  
  235. /**************************************************************/
  236.  
  237. CPTR    NewLoadSeg(name)
  238. STRPTR    name;
  239. {
  240.     CPTR    ok;
  241.     struct    MoreAssign        *manode;
  242.     char    volume[256];
  243.     char    pathname[256];
  244.     STRPTR    basename,path;
  245.     struct    FileLock    *curlock;
  246.  
  247.     ok=dosLoadSeg(name);
  248.     
  249.     if(ok){
  250.         return(ok);
  251.     }
  252.     else {
  253.         path=name;
  254.         VolumeName(path,volume);
  255.         
  256.         if(volume[0]!=EOS){
  257.             curlock=dosLock(volume,SHARED_LOCK);
  258.         }
  259.         else{
  260.             curlock=dosLock(volume,SHARED_LOCK);
  261.         }
  262.         
  263.         manode=NULL;
  264.         do{
  265.             manode=checklock(curlock,manode);
  266.             if(manode){
  267.                 basename=BaseName(path);
  268.                 strcpy(pathname,manode->ma_pathname);
  269.                 TackOn(pathname,basename);
  270.                 ok=dosLoadSeg(pathname);
  271.             }
  272.         }
  273.         while(ok==NULL && manode!=NULL);
  274.  
  275.         UNLOCKC(curlock);    
  276.         return(ok);
  277.     }
  278.  
  279. }
  280.  
  281. /**************************************************************/
  282.  
  283. VOID    installvector(oldptr,oldd0ptr,offset,x,jmp_flag)
  284. CPTR    *oldptr;
  285. LONG    *oldd0ptr;
  286. LONG    offset;
  287. APTR    x;
  288. BOOL    *jmp_flag;
  289. {
  290.     struct    vectentry    *vectadr;
  291.     struct    jumpvectentry    *jve;
  292.  
  293.     vectadr=(LONG)DosBase+(LONG)offset;
  294.     jve=vectadr;
  295.     if(jve->com_jmp==COM_JMP){
  296.         *oldd0ptr=0;
  297.         *oldptr=jve->var_adress;
  298.         *jmp_flag=TRUE;
  299.     }
  300.     else{
  301.         *oldd0ptr=vectadr->var_d0;
  302.         *oldptr=(LONG)(&(vectadr->com_bra))+(LONG)(vectadr->var_offset)+2;
  303.         *jmp_flag=FALSE;
  304.     }
  305.     SetFunction(DosBase,offset,x);
  306. }
  307.  
  308. /**************************************************************/
  309.  
  310. VOID    removevector(old,oldd0,offset,x,jmp_flag)
  311. CPTR    old;
  312. LONG    oldd0,offset;
  313. APTR    x;
  314. BOOL    jmp_flag;
  315. {
  316.     struct    vectentry    *vectadr;
  317.     struct    jumpvectentry    *jve;
  318.  
  319.     vectadr=(LONG)DosBase+(LONG)offset;
  320.     jve=vectadr;
  321.     if(jmp_flag){
  322.         jve->com_jmp=COM_JMP;
  323.         jve->var_adress=old;
  324.     }
  325.     else{
  326.         vectadr->var_d0=oldd0;
  327.         vectadr->var_offset=old-(LONG)(&(vectadr->com_bra))-2;
  328.         vectadr->com_moveq=COM_MOVEQ;
  329.         vectadr->com_bra=COM_BRA;
  330.     }
  331. }
  332.  
  333. /**************************************************************/
  334.  
  335. VOID installpatch()
  336. {
  337.     struct    vectentry    *vectadr;
  338.     
  339.     DosBase=OpenLibrary(DOSNAME,0);
  340.     
  341.     MultiOff();
  342.  
  343.     installvector(&oldLock,&oldLockd0,Lockoffset,xLock,&jmp_Lock);
  344.     installvector(&oldOpen,&oldOpend0,Openoffset,xOpen,&jmp_Open);
  345.     installvector(&oldLoadSeg,&oldLoadSegd0,LoadSegoffset,xLoadSeg,&jmp_LoadSeg);
  346.  
  347.     MultiOn();
  348.     
  349.     CloseLibrary(DosBase);
  350.     
  351.     NewList(&malist);
  352. }
  353.  
  354. /**************************************************************/
  355.  
  356. VOID    removepatch()
  357. {
  358.     struct    vectentry    *vectadr;
  359.     struct    MoreAssign    *manode;    
  360.     
  361.     DosBase=OpenLibrary(DOSNAME,0);
  362.     
  363.     manode=RemTail(&malist);
  364.     while(manode){
  365.         UNLOCKC(manode->ma_assignlock);
  366.         FreeMem(manode,sizeof(struct MoreAssign));
  367.         manode=RemTail(&malist);
  368.     }
  369.     ;
  370.     
  371.     MultiOff();
  372.     
  373.     removevector(oldLock,oldLockd0,Lockoffset,xLock,jmp_Lock);
  374.     removevector(oldOpen,oldOpend0,Openoffset,xOpen,jmp_Open);
  375.     removevector(oldLoadSeg,oldLoadSegd0,LoadSegoffset,xLoadSeg,jmp_LoadSeg);
  376.     
  377.     DosBase->lib_Flags=LIBF_CHANGED;
  378.     SumLibrary(DosBase);
  379.     
  380.     MultiOn();
  381.     
  382.     CloseLibrary(DosBase);
  383. }
  384.  
  385. /**************************************************************/
  386.  
  387. VOID    addassign(assign,path,lock)
  388. STRPTR    assign,path;
  389. struct    FileLock    *lock;
  390. {
  391.     struct    MoreAssign    *manode;
  392.  
  393.     if(manode=AllocMem(sizeof(struct MoreAssign),MEMF_CLEAR)){
  394.         strncpy(&manode->ma_assignname,assign,10);
  395.         strncpy(&manode->ma_pathname,path,256);
  396.         manode->ma_assignlock=lock;
  397.         AddHead(&malist,manode);
  398.     }
  399.     else{
  400.         /* und was jetzt? */
  401.     }
  402. }
  403.  
  404. /**************************************************************/
  405.  
  406. VOID    closeall()
  407. {
  408.     if(myout){
  409.         CLOSEC(myout);
  410.         myproc=FindTask(NULL);
  411.         myproc->pr_COS=NULL;
  412.         myproc->pr_CIS=NULL;
  413.     }
  414.     exit(NULL);
  415. }
  416.  
  417. /**************************************************************/
  418.  
  419. VOID    openall()
  420. {
  421.     if(!(myout=Open("*",MODE_NEWFILE))){
  422.         closeall();
  423.     }
  424. }
  425.  
  426. /**************************************************************/
  427.  
  428. VOID main(argc,argv)
  429. int    argc;
  430. STRPTR    argv[];
  431. {
  432.     struct    FileLock    *block;
  433.  
  434.     openall();
  435.     
  436.     fprintf(myout,"\x1b[1mAddAssign Install V1.04e\x1b[0m - (c) 1991 Alexander Rawass\n");
  437.     
  438.     if(argc==2 && *argv[1]=='?'){
  439.         fprintf(myout,"Usage : %s [REMOVE]\n",argv[0]);
  440.         closeall();
  441.     }
  442.     
  443.     if(FindPort(waitportname)){
  444.         if(argc==1){
  445.             fprintf(myout,"\nERROR :  AddAssign V1.04e already installed\n");
  446.             closeall();
  447.         }
  448.         else if(argc==2){
  449.             StrUpper(argv[1]);
  450.             waitport=FindPort(waitportname);
  451.             sendport=CreatePort(sendportname,0);
  452.             sendmsg.cmsg_message.mn_Node.ln_Type=NT_MESSAGE;
  453.             sendmsg.cmsg_message.mn_ReplyPort=sendport;
  454.             sendmsg.cmsg_message.mn_Length=sizeof(struct commandmessage);
  455.             if(STREQU(argv[1],"REMOVE")){
  456.                 fprintf(myout,"\nremoving AddAssign V1.04e\n");
  457.             }
  458.             sendmsg.cmsg_command="remove";
  459.             PutMsg(waitport,&sendmsg);
  460.             waitmsg=WaitPort(sendport);
  461.             waitmsg=GetMsg(sendport);
  462.             DeletePort(sendport);
  463.             closeall();
  464.         }
  465.     }
  466.     else{
  467.         fprintf(myout,"\ninstalling AddAssign V1.04e\n");
  468.  
  469.         installpatch();
  470.         
  471.         waitport=CreatePort(waitportname,0);
  472.  
  473.         CLOSEC(myout);
  474. /*        myproc=FindTask(NULL);
  475.         myproc->pr_COS=NULL;
  476.         myproc->pr_CIS=NULL;
  477. */
  478.         do{
  479.             waitmsg=WaitPort(waitport);
  480.             GetMsg(waitport);
  481.             if(STREQU(waitmsg->cmsg_command,"addassign")){
  482.                 addassign(waitmsg->cmsg_assign,waitmsg->cmsg_path,waitmsg->cmsg_lock);
  483.             }
  484.             else if(STREQU(waitmsg->cmsg_command,"list")){
  485.                 waitmsg->cmsg_assign=(STRPTR)&malist;
  486.             }
  487.             ReplyMsg(waitmsg);
  488.         }
  489.         while(!STREQU(waitmsg->cmsg_command,"remove"));
  490.  
  491.         removepatch();
  492.         
  493.         DeletePort(waitport);
  494.         
  495.         closeall();
  496.     }
  497. }
  498.  
  499.