home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / disk / misc / filecache / testcache.c < prev    next >
C/C++ Source or Header  |  1995-02-27  |  6KB  |  271 lines
  1. /**********************************/
  2. /* Programme de test de FileCache */
  3. /*        Sun Feb  7 16:04:58 1993        */
  4. /**********************************/
  5.  
  6. #include <exec/types.h>
  7. #include <exec/ports.h>
  8. #include "FileCache.h"
  9.  
  10. /* some prototypes */
  11. struct MsgPort *FindPort(char *);
  12. struct MsgPort *CreatePort(char *, ULONG);
  13.  
  14. /* the two ports and the message */
  15. struct FileCacheMsg msg;                /* the request message */
  16. struct MsgPort *ReplyPort;            /* reply port */
  17. struct MsgPort *FileCachePort;    /* request port */
  18.  
  19.  
  20. UBYTE  FileName[250];        /* Buffer for the filename */
  21.  
  22. STRPTR Dir[] = /* array of directory */
  23. {
  24.     "",                /* "" means current dir */
  25.     "ram:",
  26.     "include:",
  27.     NULL
  28.     /* NOTE the NULL at the end of the Directory list */
  29. };
  30.  
  31.  
  32. /* Errors replied by FileCache corresponding to FC_ERR_xxx in FileCache.h */
  33. STRPTR err_msg[]=
  34. {    "Ok",
  35.     "Not enough memory",
  36.     "Can't lock file",
  37.     "Can't cache a directory",
  38.     "Read error on file",
  39.     "File bigger than the cache",
  40.     "Can't open file",
  41.     "FileCache still in use",
  42.     "Update error",
  43.     "File not in cache",
  44.     "Bad command"
  45. };
  46.  
  47.  
  48. /* write the Menu */
  49. VOID PrintMenu()
  50. {
  51.     puts("\nMenu :");
  52.     puts("  1...Load a file");
  53.     puts("  2...Flush the cache");
  54.     puts("  3...Set the size of the cache");
  55.     puts("  4...Get info on cache");
  56.     puts("  5...Delete a file");
  57.     puts("  6...Quit FileCache");
  58.     puts("  7...Quit and kill FileCache");
  59. }
  60.  
  61.  
  62. /* some definitions for the menu */
  63. #define MENU_LOAD        '1'
  64. #define MENU_FLUSH    '2'
  65. #define MENU_SIZE        '3'
  66. #define MENU_INFO        '4'
  67. #define MENU_DELETE    '5'
  68. #define MENU_QUIT        '6'
  69. #define MENU_KILL        '7'
  70. #define MENU_FIRST    MENU_LOAD
  71. #define MENU_LAST        MENU_KILL
  72.  
  73.  
  74. /* Get the user choice */
  75. UBYTE GetUserChoice()
  76. {
  77.     UBYTE car;
  78.  
  79.     printf("    Your choice : ");
  80.     scanf("%c",&car);
  81.     return (car);
  82. }
  83.  
  84.  
  85. VOID main()
  86. {
  87.  
  88.     /* look out for FileCache server */
  89.     FileCachePort = FindPort(FILECACHEPORTNAME);
  90.     if (FileCachePort == NULL)
  91.     {
  92.         /* No FileCache Server */
  93.         puts("FileCache is not installed");
  94.         puts("Please run FileCache server an try again");
  95.         exit(0);
  96.     }
  97.  
  98.     /* Server is installed so creates the port for the replies */
  99.     ReplyPort = CreatePort(NULL, 0L);
  100.     if (ReplyPort == NULL)
  101.     {
  102.         puts("Can't allocate a reply port");
  103.         exit(0);
  104.     }
  105.  
  106.     BOOL finish, kill;
  107.  
  108.     /* init the struct fcm_Msg before sending a request */
  109.     msg.fcm_Msg.mn_Node.ln_Type = NT_MESSAGE;
  110.     msg.fcm_Msg.mn_Length = sizeof(struct FileCacheMsg);
  111.     msg.fcm_Msg.mn_ReplyPort = ReplyPort;
  112.  
  113.     /* First you must send a FC_CMD_GETTOKEN request to lock FileCache */
  114.     /* so you are sure that nobody will kill it. REMEMBER to UNLOCK    it */
  115.     /* after use. */
  116.  
  117.     /* Since the first FindPort, the port may have disappear so we must */
  118.     /* look for it again before sending the FC_CMD_GETTOKEN command. */
  119.     msg.fcm_Command = FC_CMD_GETTOKEN;
  120.  
  121.     Forbid();
  122.     if (FileCachePort = FindPort(FILECACHEPORTNAME))
  123.     {
  124.         /* The Server is still here */
  125.         PutMsg(FileCachePort, &msg);  /* send request to FileCache Server */
  126.         Permit();
  127.     }
  128.     else
  129.     {
  130.         /* the Port have disappear so good bye */
  131.         Permit();
  132.         DeletePort(ReplyPort);                /* delete the reply port */
  133.         puts("Sorry the FileCache Server is gone away !!!");
  134.         exit(0);
  135.     }
  136.  
  137.     WaitPort(ReplyPort);    /* wait for the reply */
  138.     GetMsg(ReplyPort);        /* remove the reply from msglist */
  139.  
  140.     /* Now the FileCache Server is locked so we don't need to FindPort it */
  141.     /* again */
  142.  
  143.     /* main loop */
  144.     finish = kill = FALSE;
  145.     while (!finish)
  146.     {
  147.         UBYTE choice;
  148.  
  149.         PrintMenu();
  150.  
  151.         /* get the user's choice */
  152.         do
  153.         {
  154.             choice = GetUserChoice();
  155.         }
  156.         while ( (choice < MENU_FIRST) || (choice > MENU_LAST) );
  157.  
  158.         /* reset the flags */
  159.         msg.fcm_Flags = 0;
  160.  
  161.         switch (choice)
  162.         {
  163.             case MENU_LOAD:
  164.                 printf("Enter filename : ");
  165.                 scanf("%s",FileName);
  166.                 msg.fcm_FileName = FileName;
  167.                 msg.fcm_Directory = Dir;
  168.                 msg.fcm_Flags = FC_MULTIPLEDIR;
  169.                 msg.fcm_Command = FC_CMD_LOAD;
  170.                 break;
  171.  
  172.             case MENU_FLUSH:
  173.                 msg.fcm_Command = FC_CMD_FLUSH;
  174.                 break;
  175.  
  176.             case MENU_SIZE:
  177.               ULONG size;
  178.  
  179.                 printf("Enter size of cache (in Kbytes) : ");
  180.                 scanf("%ld",&size);
  181.                 msg.fcm_CacheSize = size * 1024;
  182.                 msg.fcm_Command = FC_CMD_SETMEM;
  183.                 break;
  184.  
  185.             case MENU_INFO:
  186.                 msg.fcm_Command = FC_CMD_INFO;
  187.                 break;
  188.  
  189.             case MENU_DELETE:
  190.                 printf("Enter filename : ");
  191.                 scanf("%s",FileName);
  192.                 msg.fcm_FileName = FileName;
  193.                 msg.fcm_Directory = Dir;
  194.                 msg.fcm_Flags = FC_MULTIPLEDIR;
  195.                 msg.fcm_Command = FC_CMD_DELETE;
  196.                 break;
  197.  
  198.             case MENU_QUIT:
  199.                 finish = TRUE;
  200.                 msg.fcm_Command = FC_CMD_DELTOKEN;    /* unlock FileCache */
  201.                 break;
  202.  
  203.             case MENU_KILL:
  204.                 finish = TRUE;
  205.                 kill = TRUE;
  206.                 msg.fcm_Command = FC_CMD_DELTOKEN;    /* unlock FileCache */
  207.                 break;
  208.         }
  209.  
  210.       /* send a request to FileCache Server */
  211.         PutMsg(FileCachePort, &msg);
  212.  
  213.         /* Wait for the reply and remove it from msglist */
  214.         WaitPort(ReplyPort);
  215.         GetMsg(ReplyPort);
  216.  
  217.         if (choice == MENU_INFO)
  218.         {    
  219.             printf("\nCache size is %ld bytes\n", msg.fcm_CacheSize);
  220.             printf(" - %ld Bytes used for cache\n", msg.fcm_MemoryUsed);
  221.             printf(" - %ld Files in cache\n", msg.fcm_NbFiles);
  222.             printf(" - %ld Locks on FileCache\n",msg.fcm_NbLocks);
  223.         }
  224.  
  225.         /* print info for the file loaded */
  226.         if ((choice == MENU_LOAD) && (msg.fcm_Error == FC_ERR_OK))
  227.         {
  228.             printf("File ");
  229.  
  230.             /* if you use multiple dirs you'll find the correct dir with fcm_DirIndex */
  231.             if (msg.fcm_Flags & FC_MULTIPLEDIR)
  232.                 printf("%s", msg.fcm_Directory[msg.fcm_DirIndex]);
  233.  
  234.             printf("%s loaded successfully\n", msg.fcm_FileName);
  235.             printf("at address 0x%lx with size of %ld bytes.\n", msg.fcm_FileBuffer, msg.fcm_FileLength);
  236.         }
  237.  
  238.         /* print the error replied */
  239.         printf("%s\n",err_msg[msg.fcm_Error]);
  240.     }
  241.  
  242.     if (kill)
  243.     {
  244.         /* the FC_CMD_QUIT request must be send after you have unlocked */
  245.         /* FileCache else you will have a FC_ERR_INUSE error. */
  246.         /* The FC_CMD_QUIT request    will be effective if no other tasks */
  247.         /* have locked FileCache */
  248.  
  249.         msg.fcm_Command = FC_CMD_QUIT;
  250.         msg.fcm_Flags = 0;
  251.  
  252.         /* After unlocking FileCache; it can be killed by anybody so you must */
  253.         /* be sure that the port still exist before sending the request */
  254.  
  255.         Forbid();
  256.         if (FileCachePort = FindPort(FILECACHEPORTNAME))
  257.         {
  258.             PutMsg(FileCachePort, &msg);
  259.             Permit();
  260.             WaitPort(ReplyPort);
  261.             GetMsg(ReplyPort);
  262.             printf("%s\n",err_msg[msg.fcm_Error]);
  263.         }
  264.         else
  265.             Permit();
  266.     }
  267.  
  268.     /* delete the reply port */
  269.     DeletePort(ReplyPort);
  270. }
  271.