/*
 * This source file is Copyright 1995 by Evan Scott.
 * All rights reserved.
 * Permission is granted to distribute this file provided no
 * fees beyond distribution costs are levied.
 */

#include <exec/types.h>
#include <exec/memory.h>
#include <exec/alerts.h>

#include <dos/dos.h>
#include <dos/dosextens.h>
#include <dos/dostags.h>

#include <proto/exec.h>
#include <proto/dos.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "evtypes.h"
#include "verify.h"
#include "tcp.h"

#include "site.h"
#include "ftp.h"
#include "split.h"
#include "local.h"

#include "globals.h"

#define DOSBase _local_DOSBase

struct DosLibrary *DOSBase;

BSTR ctobstr(b8 *s)
{
   b8 *z;
   int len;
   
   len = strlen(s);
   
   z = (b8 *)allocate(len + 1, V_bstr);
   if (!z) return 0;
   
   z[0] = len;

   if (len > 0) {
      memcpy(&z[1], s, len);
   }

   return (BSTR)((b32)z >> 2);
}

void free_bstr(BSTR b)
{
   deallocate((void *)(b << 2), V_bstr);
}

void lock_message(BPTR l, struct DosPacket *dp)
{
   struct FileLock *fl;
   
   fl = (struct FileLock *)(l << 2);
   
   PutMsg(fl->fl_Task, dp->dp_Link);
}

void __saveds local_handler(void)
{
   struct Process *me;
   struct Message *msg;
   struct DosPacket *dp;
   struct MsgPort *local, *reply, *sync;
   b32 signals;
   split sd, sd2;
   lock *locks, **slock, *new_lock, *nlock;
   b32 rfsl;   /* real file system lock */
   struct FileInfoBlock *fib;
   struct FileHandle *fh;
   file_info *fi;
   b32 o1, o2, o3, o4;     /* stores for original dp->dp_Arg1 etc */
   BSTR b, b2;
   
   locks = 0;
   
   mem_tracking_on();
   
   me = (struct Process *)FindTask(0l);
   
   local = &me->pr_MsgPort;
   
   WaitPort(local);
   msg = GetMsg(local);
   dp = (struct DosPacket *)msg->mn_Node.ln_Name;
   reply = dp->dp_Port;
   
   dp->dp_Port = local;
   
   sync = CreatePort(0, 0);
   if (!sync) {
      dp->dp_Res1 = DOSFALSE;
      dp->dp_Res2 = ERROR_NO_FREE_STORE;
      
      PutMsg(reply, dp->dp_Link);
      
      return;
   }

/* do I really need DOSBase open now that I'm packeting? */

   DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 36);
   if (!DOSBase) {
      DeletePort(sync);

      dp->dp_Res1 = DOSFALSE;
      dp->dp_Res2 = ERROR_INVALID_RESIDENT_LIBRARY;
      
      PutMsg(reply, dp->dp_Link);
      
      return;
   } else {
      dp->dp_Res1 = DOSTRUE;
   }
   dp->dp_Res2 = 0;
   
   PutMsg(reply, dp->dp_Link);

   signals = (1 << local->mp_SigBit);
   
   while (1) {
      Wait(signals);
      
      while (msg = GetMsg(local)) {
         dp = (struct DosPacket *)msg->mn_Node.ln_Name;
         reply = dp->dp_Port;
         
         truth(dp->dp_Link == msg);
         
         switch (dp->dp_Type) {
         case ACTION_DIE:
            /* close all locks */
            nlock = locks;
            while (nlock) {
               new_lock = nlock->next;
               
               if (nlock->rfsl != ftphosts_lock) 
                  UnLock(nlock->rfsl);
               
               disown(nlock, V_lock);
               nlock = new_lock;
            }
            
            CloseLibrary((struct Library *)DOSBase);
            DeletePort(sync);
            
            Forbid();
            dp->dp_Res1 = DOSTRUE;
            dp->dp_Res2 = (b32)locks;  /* so they can adopt them */
            
            PutMsg(reply, dp->dp_Link);
            
            check_memory();
            
            return;
         case ACTION_LOCATE_OBJECT:
            if (!split_data((lock *)(dp->dp_Arg1 << 2),
               (b8 *)(dp->dp_Arg2 << 2), &sd)) {
               dp->dp_Res1 = 0;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            new_lock = (lock *)allocate(sizeof(*new_lock), V_lock);
            if (!new_lock) {
               show_string("XX2");
               dp->dp_Res1 = 0;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;

               end_split(&sd);
               break;
            }
            
            if (!sd.path) {   /* they want the root */
               if (dp->dp_Arg3 == EXCLUSIVE_LOCK) {
                  deallocate(new_lock, V_lock);
                  
                  end_split(&sd);
                  
                  dp->dp_Res1 = 0;
                  dp->dp_Res2 = ERROR_OBJECT_IN_USE;
                  break;
               }
               
               rfsl = ftphosts_lock;
            } else {
               o1 = dp->dp_Arg1;
               o2 = dp->dp_Arg2;
               
               dp->dp_Arg1 = ftphosts_lock;
               b = ctobstr(sd.path);
               if (!b) {
                  deallocate(new_lock, V_lock);
                  
                  end_split(&sd);
                  
                  dp->dp_Res1 = 0;
                  dp->dp_Res2 = ERROR_NO_FREE_STORE;
                  break;
               }
               
               dp->dp_Arg2 = b;
               dp->dp_Port = sync;
               
               lock_message(ftphosts_lock, dp);
               WaitPort(sync); GetMsg(sync);
               
               dp->dp_Arg1 = o1;
               dp->dp_Arg2 = o2;
               
               free_bstr(b);
               
               rfsl = dp->dp_Res1;
            }

            if (!rfsl) {
               deallocate(new_lock, V_lock);

               end_split(&sd);
               break;
            }
            
            ensure(new_lock, V_lock);
            
            new_lock->port = local;
            
            new_lock->next = locks;
            locks = new_lock;
            
            new_lock->rfsl = rfsl;
            new_lock->fl.fl_Access = dp->dp_Arg3;
            new_lock->fl.fl_Task = ftp_port;
            new_lock->fl.fl_Volume = (b32)ftp_volume >> 2;
            
            end_split(&sd);
            
            dp->dp_Res1 = (b32)new_lock >> 2;
            dp->dp_Res2 = 0;
            
            break;
         case ACTION_FREE_LOCK:
            slock = &locks;
            
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            
            while (*slock && *slock != new_lock) {
               slock = &(*slock)->next;
            }
            if (!*slock) {
               show_string("Free lock failed");
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_INVALID_LOCK;
               break;
            }

            verify(new_lock, V_lock);
            
            *slock = new_lock->next;
            
            if (new_lock->rfsl != ftphosts_lock) {
               dp->dp_Port = sync;
            
               o1 = dp->dp_Arg1;
               dp->dp_Arg1 = new_lock->rfsl;
            
               lock_message(new_lock->rfsl, dp);
               WaitPort(sync); GetMsg(sync);
            
               dp->dp_Arg1 = o1;
            }
            
            deallocate(new_lock, V_lock);
            
            dp->dp_Res1 = DOSTRUE;
            dp->dp_Res2 = 0;
            
            break;
         case ACTION_DELETE_OBJECT:
            if (!split_data((lock *)(dp->dp_Arg1 << 2),
               (b8 *)(dp->dp_Arg2 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            o1 = dp->dp_Arg1;
            o2 = dp->dp_Arg2;
            
            dp->dp_Arg1 = ftphosts_lock;
            b = ctobstr(sd.path);
            if (!b) {
               end_split(&sd);
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            dp->dp_Arg2 = b;
            
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            dp->dp_Arg2 = o2;
            
            free_bstr(b);
            
            end_split(&sd);
            
            break;
         case ACTION_RENAME_OBJECT:
            if (!split_data((lock *)(dp->dp_Arg1 << 2),
               (b8 *)(dp->dp_Arg2 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            if (!split_data((lock *)(dp->dp_Arg3 << 2),
               (b8 *)(dp->dp_Arg4 << 2), &sd2)) {
               end_split(&sd);
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            o1 = dp->dp_Arg1;
            o2 = dp->dp_Arg2;
            o3 = dp->dp_Arg3;
            o4 = dp->dp_Arg4;
            
            if (!sd2.path) {  /* this is rename Unnamed1 to "ucc.gu.uwa..." */
               if (sd2.work) deallocate(sd2.work, V_cstr);
               sd2.work = (b8 *)allocate(strlen(sd2.port->mp_Node.ln_Name) + 1, V_cstr);
               if (!sd2.work) {
                  dp->dp_Res1 = DOSFALSE;
                  dp->dp_Res2 = ERROR_NO_FREE_STORE;
                  
                  end_split(&sd);
                  end_split(&sd2);
                  break;
               }
               strcpy(sd2.work, sd2.port->mp_Node.ln_Name);
               sd2.path = sd2.work;
            }
            
            b = ctobstr(sd.path);
            b2 = ctobstr(sd2.path);
            
            if (!b || !b2) {
               if (b) free_bstr(b);
               if (b2) free_bstr(b2);
               
               end_split(&sd);
               end_split(&sd2);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               
               break;
            }

            dp->dp_Arg1 = ftphosts_lock;
            dp->dp_Arg2 = b;
            dp->dp_Arg3 = ftphosts_lock;
            dp->dp_Arg4 = b2;
            
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            dp->dp_Arg2 = o2;
            dp->dp_Arg3 = o3;
            dp->dp_Arg4 = o4;
            
            free_bstr(b);
            free_bstr(b2);
            
            end_split(&sd);
            end_split(&sd2);
            
            break;
         case ACTION_COPY_DIR:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            verify(new_lock, V_lock);
            
            rfsl = new_lock->rfsl;

            new_lock = (lock *)allocate(sizeof(*new_lock), V_lock);
            if (!new_lock) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               show_string("DupLock failed 1");
               break;
            }
            
            if (rfsl != ftphosts_lock) {
               o1 = dp->dp_Arg1;
               dp->dp_Arg1 = rfsl;

               dp->dp_Port = sync;
            
               lock_message(rfsl, dp);
               WaitPort(sync); GetMsg(sync);
            
               rfsl = dp->dp_Res1;
               dp->dp_Arg1 = o1;
            }
            
            if (!rfsl) {
               deallocate(new_lock, V_lock);
               show_string("DupLock failed 2");
               break;
            }
            
            ensure(new_lock, V_lock);
            
            new_lock->port = local;
            new_lock->next = locks;
            locks = new_lock;
            
            new_lock->rfsl = rfsl;
            new_lock->fl.fl_Access = SHARED_LOCK;
            new_lock->fl.fl_Task = ftp_port;
            new_lock->fl.fl_Volume = (b32)ftp_volume >> 2;
            
            dp->dp_Res1 = (b32)new_lock >> 2;
            dp->dp_Res2 = 0;
            
            break;
         case ACTION_SET_PROTECT:
            if (!split_data((lock *)(dp->dp_Arg2 << 2),
               (b8 *)(dp->dp_Arg3 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            o2 = dp->dp_Arg2;
            o3 = dp->dp_Arg3;
            
            dp->dp_Arg2 = ftphosts_lock;
            b = ctobstr(sd.path);
            if (!b) {
               end_split(&sd);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            dp->dp_Arg3 = b;
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg2 = o2;
            dp->dp_Arg3 = o3;
            
            free_bstr(b);
            
            end_split(&sd);
            
            break;
         case ACTION_CREATE_DIR:
            if (!split_data((lock *)(dp->dp_Arg1 << 2),
               (b8 *)(dp->dp_Arg2 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            o1 = dp->dp_Arg1;
            o2 = dp->dp_Arg2;
            
            dp->dp_Arg1 = ftphosts_lock;
            b = ctobstr(sd.path);
            if (!b) {
               end_split(&sd);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            dp->dp_Arg2 = b;
            
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            dp->dp_Arg2 = o2;
            
            free_bstr(b);
            
            end_split(&sd);
            
            break;
         case ACTION_EXAMINE_OBJECT:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            fib = (struct FileInfoBlock *)(dp->dp_Arg2 << 2);
            
            verify(new_lock, V_lock);
            truth(fib != nil);
            
            o1 = dp->dp_Arg1;
            dp->dp_Arg1 = new_lock->rfsl;
            dp->dp_Port = sync;
            
            lock_message(new_lock->rfsl, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            if (!dp->dp_Res1) break;
            
            if (new_lock->rfsl == ftphosts_lock) {
               strcpy(fib->fib_FileName, volume_name);
            }
            
            break;
         case ACTION_EXAMINE_NEXT:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            fib = (struct FileInfoBlock *)(dp->dp_Arg2 << 2);
            
            verify(new_lock, V_lock);
            truth(fib != nil);
            
            o1 = dp->dp_Arg1;
            dp->dp_Arg1 = new_lock->rfsl;
            dp->dp_Port = sync;
            
            lock_message(new_lock->rfsl, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            break;
         case ACTION_SET_COMMENT:
            if (!split_data((lock *)(dp->dp_Arg2 << 2),
               (b8 *)(dp->dp_Arg3 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            o2 = dp->dp_Arg2;
            o3 = dp->dp_Arg3;
            
            dp->dp_Arg2 = ftphosts_lock;
            b = ctobstr(sd.path);
            if (!b) {
               end_split(&sd);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            dp->dp_Arg3 = b;
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg2 = o2;
            dp->dp_Arg3 = o3;
            
            free_bstr(b);
            
            end_split(&sd);
            
            break;
         case ACTION_PARENT:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            
            verify(new_lock, V_lock);
            
            if (new_lock->rfsl == ftphosts_lock) {
               dp->dp_Res1 = 0;
               dp->dp_Res2 = 0;
               break;
            }
            /* fall through */
         case ACTION_PARENT_FH:
            new_lock = (lock *)allocate(sizeof(*new_lock), V_lock);
            if (!new_lock) {
               dp->dp_Res1 = 0;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;

               break;
            }
            
            ensure(new_lock, V_lock);
            
            new_lock->port = local;
            
            new_lock->next = locks;
            locks = new_lock;
            
            new_lock->rfsl = ftphosts_lock;
            new_lock->fl.fl_Access = SHARED_LOCK;
            new_lock->fl.fl_Task = ftp_port;
            new_lock->fl.fl_Volume = (b32)ftp_volume >> 2;
            
            dp->dp_Res1 = (b32)new_lock >> 2;
            dp->dp_Res2 = 0;
            
            break;
         case ACTION_SET_DATE:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            
            verify(new_lock, V_lock);
            
            o1 = dp->dp_Arg1;
            dp->dp_Arg1 = new_lock->rfsl;
            
            dp->dp_Port = sync;
            lock_message(new_lock->rfsl, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            break;
         case ACTION_SAME_LOCK:
            new_lock = (lock *)(dp->dp_Arg1 << 2);
            
            verify(new_lock, V_lock);
            
            if (new_lock->rfsl == ftphosts_lock) {
               new_lock = (lock *)(dp->dp_Arg2 << 2);
               
               verify(new_lock, V_lock);
               
               if (new_lock->rfsl == ftphosts_lock) {
                  dp->dp_Res1 = DOSTRUE;
               } else {
                  dp->dp_Res1 = DOSFALSE;
               }
               dp->dp_Res2 = 0;
               break;
            }
            
            rfsl = new_lock->rfsl;
            
            new_lock = (lock *)(dp->dp_Arg2 << 2);
            
            verify(new_lock, V_lock);
            
            o1 = dp->dp_Arg1;
            o2 = dp->dp_Arg2;
            
            dp->dp_Arg1 = rfsl;
            dp->dp_Arg2 = new_lock->rfsl;
            
            dp->dp_Port = sync;
            lock_message(rfsl, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            dp->dp_Arg2 = o2;
            
            break;
         case ACTION_READ:
         case ACTION_WRITE:
            fi = (file_info *)dp->dp_Arg1;
            verify(fi, V_file_info);
            
            o1 = dp->dp_Arg1;
            dp->dp_Arg1 = fi->rfarg;
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            break;
         case ACTION_FINDUPDATE:
         case ACTION_FINDINPUT:
         case ACTION_FINDOUTPUT:
            if (!split_data((lock *)(dp->dp_Arg2 << 2),
               (b8 *)(dp->dp_Arg3 << 2), &sd)) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            fi = (file_info *)allocate(sizeof(*fi), V_file_info);
            if (!fi) {
               end_split(&sd);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            ensure(fi, V_file_info);
            
            fh = (struct FileHandle *)(dp->dp_Arg1 << 2);
            
            truth(fh != nil);
            
            o2 = dp->dp_Arg2;
            o3 = dp->dp_Arg3;
            
            dp->dp_Arg2 = ftphosts_lock;
            b = ctobstr(sd.path);
            if (!b) {
               deallocate(fi, V_file_info);
               end_split(&sd);
               
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            dp->dp_Arg3 = b;
            
            dp->dp_Port = sync;
            
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg2 = o2;
            dp->dp_Arg3 = o3;
            
            free_bstr(b);
            
            if (dp->dp_Res1) {
               fh->fh_Type = ftp_port;
               fi->rfarg = fh->fh_Args;
               fh->fh_Args = (b32)fi;
               fi->port = local;
               fi->type = dp->dp_Type;
            } else {
               deallocate(fi, V_file_info);
            }
            
            end_split(&sd);
            
            break;
         case ACTION_END:
            fi = (file_info *)dp->dp_Arg1;
            
            verify(fi, V_file_info);
            
            o1 = dp->dp_Arg1;
            dp->dp_Arg1 = fi->rfarg;
            
            dp->dp_Port = sync;
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            deallocate(fi, V_file_info);
            
            break;
         case ACTION_SEEK:
            fi = (file_info *)dp->dp_Arg1;
            
            verify(fi, V_file_info);
            
            o1 = dp->dp_Arg1;
            
            dp->dp_Arg1 = fi->rfarg;
            
            dp->dp_Port = sync;
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg1 = o1;
            
            break;
         case ACTION_FH_FROM_LOCK:
            fh = (struct FileHandle *)(dp->dp_Arg1 << 2);
            nlock = (lock *)(dp->dp_Arg2 << 2);
            
            verify(nlock, V_lock);
            truth(fh != nil);

            fi = (file_info *)allocate(sizeof(*fi), V_file_info);
            if (!fi) {
               dp->dp_Res1 = DOSFALSE;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;
               break;
            }
            
            ensure(fi, V_file_info);
            
            o2 = dp->dp_Arg2;
            
            dp->dp_Arg2 = nlock->rfsl;
            
            dp->dp_Port = sync;
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            dp->dp_Arg2 = o2;
            
            if (dp->dp_Res1) {
               fh->fh_Type = ftp_port;
               fi->rfarg = fh->fh_Args;
               fh->fh_Args = (b32)fi;
               fi->port = local;
               fi->type = dp->dp_Type;
            } else {
               deallocate(fi, V_file_info);
            }
            
            break;
         case ACTION_COPY_DIR_FH:
            fh = (struct FileHandle *)(dp->dp_Arg1 << 2);
            fi = (file_info *)fh->fh_Args;
            
            new_lock = (lock *)allocate(sizeof(*new_lock), V_lock);
            if (!new_lock) {
               dp->dp_Res1 = 0;
               dp->dp_Res2 = ERROR_NO_FREE_STORE;

               break;
            }
            
            ensure(new_lock, V_lock);
            
            new_lock->port = local;
            
            new_lock->fl.fl_Access = SHARED_LOCK;
            new_lock->fl.fl_Task = ftp_port;
            new_lock->fl.fl_Volume = (b32)ftp_volume >> 2;
            
            verify(fi, V_file_info);
            
            fh->fh_Args = fi->rfarg;
            
            dp->dp_Port = sync;
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            fh->fh_Args = (b32)fi;
            
            if (dp->dp_Res1) {
               new_lock->rfsl = dp->dp_Res1;

               new_lock->next = locks;
               locks = new_lock;
            
               dp->dp_Res1 = (b32)new_lock >> 2;
               dp->dp_Res2 = 0;
            } else {
               deallocate(new_lock, V_lock);
            }
            
            break;
         case ACTION_EXAMINE_FH:
            fh = (struct FileHandle *)(dp->dp_Arg1 << 2);
            
            fi = (file_info *)fh->fh_Args;
            
            verify(fi, V_file_info);
            
            fh->fh_Args = fi->rfarg;
            
            dp->dp_Port = sync;
            lock_message(ftphosts_lock, dp);
            WaitPort(sync); GetMsg(sync);
            
            fh->fh_Args = (b32)fi;
            
            break;
         default:
            show_int(dp->dp_Type);
            dp->dp_Res1 = DOSFALSE;
            dp->dp_Res2 = ERROR_ACTION_NOT_KNOWN;
            break;
         }
         
         dp->dp_Port = ftp_port;
         PutMsg(reply, dp->dp_Link);
      }
   }
}