/*
 * 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 <intuition/intuition.h>

#include <libraries/commodities.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/commodities.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 "request.h"

#include "globals.h"

struct DosPacket *fh_listen(void)
{
	struct DosPacket *dp;
	struct MsgPort *reply;
	struct Message *msg;
	struct InfoData *id;
	struct FileHandle *fh;
	file_info *fi;
	b32 signals;
	split sd, sd2;
	lock *my_lock, *lock2;
	site *my_site;
	status_message *sm;
	b8 *s, *name;
	
	b32 pass_key = 0;
	boolean write_protect = false, disabled = false;
	
	signals = (1 << ftp_port->mp_SigBit) | (1 << status_control->mp_SigBit);
	
	while (1) {
		Wait(signals);
		
		while (sm = (status_message *)GetMsg(status_control)) {
			verify(sm, V_status_message);
			
			switch (sm->command) {
			case SM_KILL:
				ReplyMsg(&sm->header);
				return nil;
			case SM_SUSPEND:
				disabled = true;
				
				suspend_sites();
				
				break;
			case SM_RESUME:
				disabled = false;
				break;
			}
			ReplyMsg(&sm->header);
		}
		
		while (msg = GetMsg(ftp_port)) {
			dp = (struct DosPacket *)msg->mn_Node.ln_Name;
			
			reply = dp->dp_Port;
			
			truth(dp->dp_Link == msg);
			
			if (disabled && dp->dp_Type != action_IDLE) {
				dp->dp_Res1 = DOSFALSE;
				dp->dp_Res2 = ERROR_DEVICE_NOT_MOUNTED;
				
				dp->dp_Port = ftp_port;
				PutMsg(reply, dp->dp_Link);
				continue;
			}
			
			switch (dp->dp_Type) {
			case ACTION_NIL:
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;
				break;
			case ACTION_DIE:
				return dp;
			case ACTION_LOCATE_OBJECT:	/* Lock() */
				if (dp->dp_Arg3 != SHARED_LOCK && dp->dp_Arg3 != EXCLUSIVE_LOCK) {
					dp->dp_Res1 = 0;
					dp->dp_Res2 = ERROR_BAD_NUMBER;
					break;
				}
				
				if (!split_data((lock *)(dp->dp_Arg1 << 2), 
							(b8 *)(dp->dp_Arg2 << 2), &sd)) {
					/* might be ERROR_NO_FREE_STORE, but hey */
					dp->dp_Res1 = 0;
					dp->dp_Res2 = ERROR_INVALID_COMPONENT_NAME;
					break;
				}
				
				PutMsg(sd.port, dp->dp_Link);
				
				end_split(&sd);

				continue;
			case ACTION_RENAME_DISK:	/* Relabel() */
				name = (b8 *)(dp->dp_Arg1 << 2);
				s = (b8 *)allocate(name[0] + 2, V_bstr);
				if (!s) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_NO_FREE_STORE;
					break;
				}
				
				s[0] = name[0];
				memcpy(&s[1], &name[1], s[0]);
				s[1 + s[0]] = 0;
				
				/* perhaps should do some mutual exclusion here ... */
				ftp_volume->dol_Name = (b32)s >> 2;
				
				deallocate(volume_name, V_bstr);
				volume_name = s;
				
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;
				
				break;
			case ACTION_FREE_LOCK:		/* UnLock() */
			case ACTION_COPY_DIR:		/* DupLock() */
			case ACTION_EXAMINE_OBJECT:	/* Examine() */
			case ACTION_EXAMINE_NEXT:	/* ExNext() */
			case ACTION_PARENT:		/* ParentDir() */
			case ACTION_SET_DATE:		/* SetFileDate() */
				my_lock = (lock *)(dp->dp_Arg1 << 2);
				
				if (!my_lock) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_LOCK;
					break;
				}
				
				verify(my_lock, V_lock);
				
				PutMsg(my_lock->port, dp->dp_Link);
				continue;
			case ACTION_SET_PROTECT:
			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_INVALID_COMPONENT_NAME;
					break;
				}
				
				PutMsg(sd.port, dp->dp_Link);
				
				end_split(&sd);
				
				continue;
			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_INVALID_COMPONENT_NAME;
					break;
				}
				
				if (!split_data((lock *)(dp->dp_Arg3 << 2),
							(b8 *)(dp->dp_Arg4 << 2), &sd2)) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_COMPONENT_NAME;
					
					end_split(&sd);
					break;
				}
				
				if (sd.port == local_port &&
					!sd2.path) {	/* special case */
					
					PutMsg(local_port, dp->dp_Link);
					
					end_split(&sd);
					end_split(&sd2);
					continue;
				}
				
				if (sd.port != sd2.port) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_RENAME_ACROSS_DEVICES;
					
					end_split(&sd);
					end_split(&sd2);
					break;
				}
				
				PutMsg(sd.port, dp->dp_Link);
				
				end_split(&sd);
				end_split(&sd2);
				
				continue;
			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_INVALID_COMPONENT_NAME;
					break;
				}
				
				PutMsg(sd.port, dp->dp_Link);
				
				end_split(&sd);
				
				continue;
			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_INVALID_COMPONENT_NAME;
					break;
				}
				
				if (!sd.path)
				{
					PutMsg(local_port, dp->dp_Link);
				}
				else
				{
					PutMsg(sd.port, dp->dp_Link);
				}
				
				end_split(&sd);
				
				continue;
			case ACTION_DISK_INFO:
				id = (struct InfoData *)(dp->dp_Arg1 << 2);
				truth(id != nil);

				id->id_NumSoftErrors = 0;
				id->id_UnitNumber = 0;
				if (write_protect)
					id->id_DiskState = ID_WRITE_PROTECTED;
				else
					id->id_DiskState = ID_VALIDATED;
				id->id_NumBlocks = 1;
				id->id_NumBlocksUsed = 1;
				id->id_BytesPerBlock = 1024;
				id->id_DiskType = ID_DOS_DISK;
				id->id_VolumeNode = (b32)ftp_volume >> 2;
				id->id_InUse = 0;
				
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;

				break;
			case ACTION_INFO:
				id = (struct InfoData *)(dp->dp_Arg2 << 2);
				truth(id != nil);

				id->id_NumSoftErrors = 0;
				id->id_UnitNumber = 0;
				if (write_protect)
					id->id_DiskState = ID_WRITE_PROTECTED;
				else
					id->id_DiskState = ID_VALIDATED;
				id->id_NumBlocks = 1;
				id->id_NumBlocksUsed = 1;
				id->id_BytesPerBlock = 1024;
				id->id_DiskType = ID_DOS_DISK;
				id->id_VolumeNode = (b32)ftp_volume >> 2;
				id->id_InUse = 0;
				
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;

				break;
			case ACTION_SAME_LOCK:
				my_lock = (lock *)(dp->dp_Arg1 << 2);
				lock2 = (lock *)(dp->dp_Arg2 << 2);
				
				verify(my_lock, V_lock);
				verify(lock2, V_lock);
				
#ifdef SLDFKJ
				if (my_lock->port == local_port) {
					if (my_lock->rfsl == ftphosts_lock)
						{ show_string("lock 1 is ROOT"); }
					else
						{ show_string("lock 1 is local lock"); }
				} else {
					show_string(my_lock->fname);
				}
				
				if (lock2->port == local_port) {
					if (lock2->rfsl == ftphosts_lock)
						{ show_string("lock 2 is ROOT"); }
					else
						{ show_string("lock 2 is local lock"); }
				} else {
					show_string(lock2->fname);
				}
#endif
				
				if (my_lock->port != lock2->port) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_LOCK;
					break;
				}
				
				PutMsg(my_lock->port, dp->dp_Link);
				continue;
			case ACTION_READ:
			case ACTION_WRITE:
				fi = (file_info *)dp->dp_Arg1;
				
				verify(fi, V_file_info);
				
				PutMsg(fi->port, dp->dp_Link);
				
				continue;
			case ACTION_FINDUPDATE:
			case ACTION_FINDINPUT:
			case ACTION_FINDOUTPUT:
				if (!split_data((lock *)(dp->dp_Arg2 << 2), 
							(b8 *)(dp->dp_Arg3 << 2), &sd)) {
					/* might be ERROR_NO_FREE_STORE, but hey */
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_COMPONENT_NAME;
					break;
				}
				
				PutMsg(sd.port, dp->dp_Link);
				
				end_split(&sd);

				continue;
			case ACTION_END:
				fi = (file_info *)dp->dp_Arg1;
				
				verify(fi, V_file_info);
				
				PutMsg(fi->port, dp->dp_Link);
				
				continue;
			case ACTION_SEEK:
				fi = (file_info *)dp->dp_Arg1;
				
				verify(fi, V_file_info);
				
				PutMsg(fi->port, dp->dp_Link);
				
				continue;
			case ACTION_WRITE_PROTECT:
				if (write_protect && dp->dp_Arg1) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_DISK_WRITE_PROTECTED;
					break;
				} else if (!write_protect && !dp->dp_Arg1) {
					dp->dp_Res1 = DOSTRUE;
					dp->dp_Res2 = 0;
					break;
				} else if (!write_protect && dp->dp_Arg1) {
					dp->dp_Res1 = DOSTRUE;
					dp->dp_Res2 = 0;
					write_protect = 1;
					pass_key = dp->dp_Arg2;
					break;
				} else {
					if (pass_key == 0 || pass_key == dp->dp_Arg2) {
						dp->dp_Res1 = DOSTRUE;
						dp->dp_Res2 = 0;
						write_protect = 0;
						pass_key = 0;
						break;
					} else {
						dp->dp_Res1 = DOSFALSE;
						dp->dp_Res2 = ERROR_DISK_WRITE_PROTECTED;
						break;
					}
				}
				break;
			case ACTION_FH_FROM_LOCK:
				my_lock = (lock *)(dp->dp_Arg2 << 2);
				
				if (!my_lock) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_LOCK;
					break;
				}
				
				verify(my_lock, V_lock);
				
				PutMsg(my_lock->port, dp->dp_Link);
				continue;
			case ACTION_IS_FILESYSTEM:
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;
				break;
			case ACTION_COPY_DIR_FH:
			case ACTION_PARENT_FH:
//			case ACTION_EXAMINE_FH:
				fh = (struct FileHandle *)(dp->dp_Arg1 << 2);
				
				fi = (file_info *)fh->fh_Args;
				verify(fi, V_file_info);
				
				PutMsg(fi->port, dp->dp_Link);
				
				continue;
			case ACTION_EXAMINE_ALL:
				my_lock = (lock *)(dp->dp_Arg1 << 2);
				
				if (!my_lock) {
					dp->dp_Res1 = DOSFALSE;
					dp->dp_Res2 = ERROR_INVALID_LOCK;
					break;
				}
				
				verify(my_lock, V_lock);
				
				PutMsg(my_lock->port, dp->dp_Link);
				continue;
			case action_IDLE:
				my_site = (site *)dp->dp_Arg1;
				
				dp->dp_Port = ftp_port;
				PutMsg(reply, dp->dp_Link);	/* send the IDLE back */
				
				dp = &my_site->death_packet->sp_Pkt;
				dp->dp_Type = action_IDLE_DEATH;
				
				dp->dp_Port = startup_sync;
				PutMsg(my_site->port, dp->dp_Link);
				WaitPort(startup_sync); GetMsg(startup_sync);
				
				if (dp->dp_Res1) {
					my_lock = (lock *)dp->dp_Res2;
					while (my_lock) {
						adopt(my_lock, V_lock);
						my_lock = my_lock->next;
					}
					
					remove_site((site *)my_site);
				}
				
				continue;
			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);
		}
	}
}

void fh_ignore(void)
/* sits on our message port and cancels all actions */
{
	struct Message *msg;
	struct MsgPort *reply;
	struct DosPacket *dp;
	b32 signals;
	lock *l;
	
	signals = (1 << ftp_port->mp_SigBit);
	
	while (1) {
		Wait(signals);
		
		while (msg = GetMsg(ftp_port)) {
			dp = (struct DosPacket *)msg->mn_Node.ln_Name;
			
			if (dp->dp_Type == ACTION_FREE_LOCK) {
				l = (lock *)(dp->dp_Arg1 << 2);
				verify(l, V_lock);
				
				deallocate(l, V_lock);
				
				dp->dp_Res1 = DOSTRUE;
				dp->dp_Res2 = 0;
			} else {
				dp->dp_Res1 = DOSFALSE;
				dp->dp_Res2 = ERROR_ACTION_NOT_KNOWN;
			}
			
			reply = dp->dp_Port;
			dp->dp_Port = ftp_port;
			
			PutMsg(reply, dp->dp_Link);
		}
	}
}