home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / listings / v_08_09 / 8n09074a < prev    next >
Text File  |  1990-06-01  |  7KB  |  343 lines
  1.  
  2. /*
  3.      +--------------------------------------------------------------+
  4.      |    @(#) bfs_apl.c   v1.0   90/04/02                            |
  5.      |                                                              |
  6.      |  Copyright (C) 1990, StonyBrook Technologies, Inc.,          |
  7.      |  All Rights Reserved.                                        |
  8.      |                                                              |
  9.      |  This Module contains Proprietary Information of             |
  10.      |  StonyBrook Technologies, Inc. and should be treated         |
  11.      |  as Confidential.                                            |
  12.      |                                                              |
  13.      +--------------------------------------------------------------+
  14.  
  15.  
  16.      bfs_apl.c - this is a library of routines for accessing the
  17.                  file server thru the client daemon.
  18.  
  19. */
  20.  
  21. #include <stdio.h>
  22. #include <sys/fcntl.h>
  23. #include <sys/types.h>
  24. #include <sys/stat.h>
  25. #include <errno.h>
  26. #include <sys/signal.h>
  27. #include "bfs.h"
  28.  
  29. int    afifo;              /* apl read fifo  (created by apl)    */
  30. int    afifow;             /* apl write fifo  (created by apl)   */
  31. int    cfifo;              /* apl write fifo (created by cmon    */
  32. int    alink = 0;          /* apl fifo link counter (close = 0 ) */
  33. char   afname[132];       /* apl fifo name - /tmp/AFIFO.pid     */
  34.  
  35. RFILE  rfile[MAX_RFILES];  /* apl file control blocks */
  36.  
  37.  
  38. /* rfopen procedure */
  39.  
  40. RFILE *rfopen(rfname, rftype)
  41. char *rfname;
  42. char *rftype;
  43. {
  44.   int ridx, fidx, result;
  45.   char *sname, *fname, *cptr;
  46.  
  47.   if(!alink) bfs_apl_init();
  48.  
  49.   sname = rfname;
  50.   for(cptr=rfname; *cptr; cptr++)
  51.     if(*cptr == '!')  {
  52.       *cptr = '\0'; 
  53.       fname = cptr+1;
  54.       for(ridx=0, fidx=-1; ridx<MAX_RFILES; ridx++)
  55.         if(rfile[ridx].state == -1) {
  56.           fidx = ridx;
  57.           break;
  58.         }
  59.       if(fidx != -1) {
  60.         if(arpc_fopen(fidx, sname, fname, rftype) != -1) {
  61.           strcpy(rfile[fidx].sname, sname);
  62.           strcpy(rfile[fidx].fname, fname);
  63.           strcpy(rfile[fidx].ftype, rftype);
  64.           rfile[fidx].state = fidx;
  65.           errno = 0;
  66.           *cptr = '!';
  67.           return(&rfile[fidx]);
  68.         } else {
  69.           *cptr = '!';
  70.           return(NULL);
  71.         }
  72.       } else {
  73.         *cptr = '!';
  74.         errno = EMFILE;
  75.         return(NULL);
  76.       }
  77.     }
  78.   errno = EINVAL;
  79.   return(NULL);
  80. }
  81.  
  82.  
  83. /* rfclose procedure */
  84.  
  85. int rfclose(rstream)
  86. RFILE *rstream;
  87. {
  88.   int result;
  89.  
  90.   if((rstream != NULL) && (rstream->state)) {
  91.     result = arpc_fclose(rstream->state);
  92.     rstream->state = -1;
  93.     return(result);
  94.   }
  95.   errno = EINVAL;
  96.   return(-1);
  97. }
  98.  
  99.  
  100. /* rfread procedure */
  101.  
  102. int rfread(ptr, size, nitems, rstream)
  103. char   *ptr;
  104. int     size;
  105. int     nitems;
  106. RFILE  *rstream;
  107. {
  108.   if((rstream != NULL) && (rstream->state)) 
  109.       return(arpc_fread(rstream->state, ptr, size, nitems));
  110.   errno = EINVAL;
  111.   return(-1); 
  112. }
  113.  
  114.  
  115. /* rfwrite procedure */
  116.  
  117. int rfwrite(ptr, size, nitems, rstream)
  118. char   *ptr;
  119. int     size;
  120. int     nitems;
  121. RFILE  *rstream;
  122. {
  123.   if((rstream != NULL) && (rstream->state)) 
  124.       return(arpc_fwrite(rstream->state, ptr, size, nitems));
  125.   errno = EINVAL;
  126.   return(-1); 
  127. }
  128.  
  129.  
  130. /* rfeof procedure */
  131.  
  132. int rfeof(rstream)
  133. RFILE  *rstream;
  134. {
  135.   if((rstream != NULL) && (rstream->state)) 
  136.       return(arpc_feof(rstream->state));
  137.   errno = EINVAL;
  138.   return(-1); 
  139. }
  140.  
  141.  
  142. /* arpc_fopen procedure */
  143.  
  144. arpc_fopen(fid, sname, fname, ftype)
  145. int fid;
  146. char *sname, *fname, *ftype;
  147. {
  148.   RPC_FOPEN_CMD_MSG focmd;
  149.   RPC_FOPEN_RSP_MSG forsp;
  150.  
  151.   if(!afifo_open()) 
  152.     return(-1);
  153.  
  154.   focmd.hdr.code = RPC_FOPEN_CMD;
  155.   focmd.hdr.csid = getpid();
  156.   focmd.hdr.ssid = fid;
  157.   focmd.hdr.dlen = sizeof(RPC_FOPEN_CMD_MSG) - sizeof(RPC_MSG);  
  158.  
  159.   strcpy(focmd.sname, sname);
  160.   strcpy(focmd.fname, fname);
  161.   strcpy(focmd.ftype, ftype);
  162.  
  163.   cfifo_write(&focmd, sizeof(RPC_FOPEN_CMD_MSG));
  164.   afifo_read(&forsp, sizeof(RPC_FOPEN_RSP_MSG));
  165.  
  166.   if(forsp.status == -1)
  167.     afifo_close();
  168.  
  169.   errno = forsp.errno;
  170.   return(forsp.status);
  171. }
  172.  
  173.  
  174. /* arpc_fclose procedure */
  175.  
  176. arpc_fclose(fid)
  177. int fid;
  178. {
  179.   RPC_FCLOSE_CMD_MSG fccmd;
  180.   RPC_FCLOSE_RSP_MSG fcrsp;
  181.  
  182.   fccmd.hdr.code = RPC_FCLOSE_CMD;
  183.   fccmd.hdr.csid = getpid();
  184.   fccmd.hdr.ssid = fid;
  185.   fccmd.hdr.dlen = 0;
  186.  
  187.   cfifo_write(&fccmd, sizeof(RPC_FCLOSE_CMD_MSG));
  188.   afifo_read(&fcrsp, sizeof(RPC_FCLOSE_RSP_MSG));
  189.  
  190.   afifo_close();
  191.  
  192.   errno = fcrsp.errno;
  193.   return(fcrsp.status);
  194. }
  195.  
  196.  
  197. /* arpc_fread procedure */
  198.  
  199. arpc_fread(fid, buf, size, nitems)
  200. int fid, size, nitems;
  201. char *buf;
  202. {
  203.   RPC_FREAD_CMD_MSG frcmd;
  204.   RPC_FREAD_RSP_MSG frrsp;
  205.  
  206.   frcmd.hdr.code = RPC_FREAD_CMD;
  207.   frcmd.hdr.csid = getpid();
  208.   frcmd.hdr.ssid = fid;
  209.   frcmd.hdr.dlen = 0;
  210.   frcmd.size = size;
  211.   frcmd.nitems = nitems;
  212.  
  213.   cfifo_write(&frcmd, sizeof(RPC_FREAD_CMD_MSG));
  214.   afifo_read(&frrsp, sizeof(RPC_FREAD_RSP_MSG));
  215.  
  216.   if(frrsp.hdr.dlen > 0)
  217.     afifo_read(buf, frrsp.hdr.dlen);
  218.  
  219.   errno = frrsp.errno;
  220.   return(frrsp.status);
  221. }
  222.  
  223.  
  224. /* arpc_fwrite procedure */
  225.  
  226. arpc_fwrite(fid, buf, size, nitems)
  227. int fid, size, nitems;
  228. char *buf;
  229. {
  230.   RPC_FWRITE_CMD_MSG fwcmd;
  231.   RPC_FWRITE_RSP_MSG fwrsp;
  232.   int len;
  233.  
  234.   len = size * nitems;
  235.   fwcmd.hdr.code = RPC_FWRITE_CMD;
  236.   fwcmd.hdr.csid = getpid();
  237.   fwcmd.hdr.ssid = fid;
  238.   fwcmd.hdr.dlen = len;
  239.   fwcmd.size = size;
  240.   fwcmd.nitems = nitems;
  241.  
  242.   cfifo_write(&fwcmd, sizeof(RPC_FWRITE_CMD_MSG));
  243.   cfifo_write(buf, len);
  244.   afifo_read(&fwrsp, sizeof(RPC_FWRITE_RSP_MSG));
  245.  
  246.   errno = fwrsp.errno;
  247.   return(fwrsp.status);
  248. }
  249.  
  250.  
  251. /* arpc_feof procedure */
  252.  
  253. arpc_feof(fid)
  254. int fid;
  255. {
  256.   RPC_FEOF_CMD_MSG fecmd;
  257.   RPC_FEOF_RSP_MSG fersp;
  258.  
  259.   fecmd.hdr.code = RPC_FEOF_CMD;
  260.   fecmd.hdr.csid = getpid();
  261.   fecmd.hdr.ssid = fid;
  262.   fecmd.hdr.dlen = 0;
  263.  
  264.   cfifo_write(&fecmd, sizeof(RPC_FEOF_CMD_MSG));
  265.   afifo_read(&fersp, sizeof(RPC_FEOF_RSP_MSG));
  266.  
  267.   errno = fersp.errno;
  268.   return(fersp.status);
  269. }
  270.  
  271.  
  272.  
  273. bfs_apl_init()
  274. {
  275.   int i;
  276.  
  277.   for(i=0; i<MAX_RFILES; i++) {
  278.     rfile[i].state = -1;
  279.     rfile[i].sname[0] = '\0';
  280.     rfile[i].fname[0] = '\0';
  281.     rfile[i].ftype[0] = '\0';
  282.   }
  283. }
  284.  
  285. afifo_open()
  286. {
  287.   int pid, flags;
  288.  
  289.   if(alink) {
  290.     alink++;
  291.     return(1); 
  292.   }
  293.  
  294.   pid = getpid();
  295.  
  296.   if((cfifo=open("/tmp/CFIFO", O_WRONLY)) != -1) {
  297.     sprintf(afname, "/tmp/AFIFO.%d", pid);
  298.     if(mknod(afname, S_IFIFO|0666, 0) == -1) 
  299.       return(0);
  300.     if((afifo=open(afname, O_RDONLY|O_NDELAY)) == -1) {
  301.         unlink(afname);
  302.         close(cfifo);
  303.         return(0);
  304.     }
  305.     flags = fcntl(afifo, F_GETFL, &flags);
  306.     flags &= ~O_NDELAY;
  307.     fcntl(afifo, F_SETFL, &flags);
  308.     afifow=open(afname, O_WRONLY);
  309.     alink = 1;
  310.     return(1);
  311.   } 
  312.   return(0); 
  313. }
  314.  
  315.  
  316. afifo_close()
  317. {
  318.   alink--;
  319.   if(!alink) {
  320.     close(cfifo);
  321.     close(afifo);
  322.     close(afifow);
  323.     unlink(afname);
  324.   }
  325.   return(1);
  326. }
  327.  
  328.  
  329. afifo_read(buf, cnt)
  330. char *buf;
  331. int cnt;
  332. {
  333.   return(read(afifo, buf, cnt));
  334. }
  335.  
  336.  
  337. cfifo_write(buf, cnt)
  338. char *buf;
  339. int cnt;
  340. {
  341.   return(write(cfifo, buf, cnt));
  342. }
  343.