home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 239.lha / amiga / src / server / scopy.c < prev    next >
C/C++ Source or Header  |  1989-05-02  |  4KB  |  209 lines
  1.  
  2. /*
  3.  *  SCOPY.C    V1.1
  4.  *
  5.  *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  6.  *
  7.  *  COPY SERVER FOR PUTFILES (DOWNLOADS, i.e. receives files)
  8.  *
  9.  *  The current version only accepts one connection at a time.    This server
  10.  *  handles downloading of data.  This server will eventually be replaced
  11.  *  by the SGCOPY server.  Currently the SGCOPY server only handles
  12.  *  uploads.
  13.  *
  14.  *  NOTE:   The DNET_WRITE enviroment variable must be 9 or higher or this
  15.  *        server will refuse connections.
  16.  *
  17.  *  Receive:
  18.  *        'V' NLEN NAME FILELEN       -receive compressed file    (V1.1)
  19.  *        'W' NLEN NAME FILELEN       -receive file
  20.  *        'X' NLEN NAME   0           -create and CD into directory
  21.  *        'Y'  0          0           -restore previous directory
  22.  *        'C' NLEN NAME   0           -set destination directory
  23.  *
  24.  *  length in 68000 longword format.
  25.  */
  26.  
  27. #include <stdio.h>
  28. #include <fcntl.h>
  29. #include "servers.h"
  30.  
  31. int Enable_Abort;
  32. char Buf[8192];
  33. char Buf2[8192];
  34.  
  35. typedef struct FileInfoBlock FIB;
  36. typedef struct Process PROC;
  37.  
  38. extern struct MsgPort *DListen();
  39. extern PROC *FindTask();
  40. extern char *AllocMem();
  41.  
  42. _main()
  43. {
  44.     struct MsgPort *port;
  45.     PROC    *myproc = FindTask(NULL);
  46.     long    chan;
  47.     long    savedir;
  48.     long    mask, rmask;
  49.  
  50.     Enable_Abort = 0;
  51.     if (myproc->pr_CLI) {
  52.     Version("SCopy", VERSION, SCOPY_VERSION);
  53.     _exit(0);
  54.     }
  55.  
  56.     port = DListen(PORT_FILECOPY);
  57.     {
  58.     struct Message *GetMsg();
  59.     register struct Message *msg;
  60.     register char *dir;
  61.  
  62.     WaitPort(&myproc->pr_MsgPort);
  63.     msg = GetMsg(&myproc->pr_MsgPort);
  64.     dir = (msg->mn_Node.ln_Name) ? msg->mn_Node.ln_Name : "";
  65.     savedir = Lock(dir, SHARED_LOCK);   /* duplicate current dir    */
  66.     ReplyMsg(msg);
  67.     }
  68.     if (!savedir) {
  69.     DUnListen(port);
  70.     _exit(1);
  71.     }
  72.     savedir = CurrentDir(savedir);              /* CD dup, returns original */
  73.     mask = SIGBREAKF_CTRL_C|(1 << port->mp_SigBit);
  74.     for (;;) {
  75.     long dupdir = DupLock(myproc->pr_CurrentDir);
  76.     rmask = Wait(mask);
  77.     if (rmask & SIGBREAKF_CTRL_C) {
  78.         UnLock(CurrentDir(dupdir));
  79.         break;
  80.     }
  81.     while (chan = DAccept(port)) {
  82.         if (GetEnvVal(DNET_WRITE) >= 9)
  83.         putdir(chan, "");
  84.         else
  85.         DWrite(chan, "S", 1);
  86.         DClose(chan);
  87.     }
  88.     UnLock(CurrentDir(dupdir));
  89.     }
  90.     UnLock(CurrentDir(savedir));                /* restore original         */
  91.     DUnListen(port);
  92. }
  93.  
  94. static char Name[128];
  95.  
  96. putdir(chan, dirname)
  97. char *dirname;
  98. {
  99.     FIB *fib;
  100.     long lock;
  101.     long oldlock;
  102.     long len;
  103.     int ret = -1;
  104.     unsigned char co, nl, rc;
  105.  
  106.     fib = (FIB *)AllocMem(sizeof(FIB), MEMF_PUBLIC);
  107.     if ((lock = Lock(dirname, SHARED_LOCK)) == NULL) {
  108.     if (lock = CreateDir(dirname)) {
  109.         UnLock(lock);
  110.         lock = Lock(dirname, SHARED_LOCK);
  111.     }
  112.     }
  113.     if (lock == NULL || !Examine(lock,fib) || fib->fib_DirEntryType < 0) {
  114.     if (lock)
  115.         UnLock(lock);
  116.     rc = 'N';
  117.     DWrite(chan, &rc, 1);
  118.     FreeMem(fib, sizeof(FIB));
  119.     return(1);
  120.     }
  121.     rc = 'Y';
  122.     DWrite(chan, &rc, 1);
  123.     oldlock = CurrentDir(lock);
  124.     while (DRead(chan, &co, 1) == 1) {
  125.     if (DRead(chan, &nl, 1) != 1 || DRead(chan, Name, nl) != nl)
  126.         break;
  127.     if (DRead(chan, &len, 4) != 4)
  128.         break;
  129.     switch(co) {
  130.     case 'C':
  131.         {
  132.         char co = 'N';
  133.         long lock = Lock(Name, SHARED_LOCK);    /* CD to dir */
  134.         if (!lock) {
  135.             if (lock = CreateDir(Name)) {       /* or create */
  136.             UnLock(lock);
  137.             lock = Lock(Name, SHARED_LOCK);
  138.             }
  139.         }
  140.         if (lock) {
  141.             co = 'Y';
  142.             UnLock(CurrentDir(lock));
  143.         }
  144.         DWrite(chan, &co, 1);
  145.         }
  146.         break;
  147.     case 'W':
  148.         if (putfile(chan, Name, len) < 0) {
  149.         ret = -1;
  150.         goto fail;
  151.         }
  152.         break;
  153.     case 'X':
  154.         if (putdir(chan, Name) < 0) {
  155.         ret = -1;
  156.         goto fail;
  157.         }
  158.         break;
  159.     case 'Y':
  160.         ret = 1;
  161.         co = 'Y';
  162.         DWrite(chan, &co, 1);
  163.         goto fail;
  164.     default:
  165.         co = 'N';
  166.         DWrite(chan, &co, 1);
  167.         break;
  168.     }
  169.     }
  170. fail:
  171.     UnLock(CurrentDir(oldlock));
  172.     FreeMem(fib, sizeof(FIB));
  173.     return(ret);
  174. }
  175.  
  176. putfile(chan, name, len)
  177. char *name;
  178. {
  179.     long fh = Open(name, 1006);
  180.     long n, r;
  181.     char rc;
  182.  
  183.     if (fh == NULL) {
  184.     rc = 'N';
  185.     DWrite(chan, &rc, 1);
  186.     return(0);
  187.     }
  188.     rc = 'Y';
  189.     DWrite(chan, &rc, 1);
  190.     while (len) {
  191.     r = (len > sizeof(Buf)) ? sizeof(Buf) : len;
  192.     n = DRead(chan, Buf, r);
  193.     if (n != r)
  194.         break;
  195.     if (Write(fh, Buf, n) != n)
  196.         break;
  197.     len -= n;
  198.     }
  199.     Close(fh);
  200.     if (len) {
  201.     unlink(name);
  202.     return(-1);
  203.     }
  204.     rc = 'Y';
  205.     DWrite(chan, &rc, 1);
  206.     return(0);
  207. }
  208.  
  209.