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