transferfileclient.c

刚学VC时写的文件传输程序,全部用SocketAPI编写

#ifndef	__TRANSFER_FILE_CLIENT_C__
#define	__TRANSFER_FILE_CLIENT_C__


#include "function.h"
#include "TransferFile.h"

typedef SOCKET *			PSOCKET;

typedef struct _THREAD_CONTEXT{
	WORD					port;
	CHAR					ip[16];
	CHAR					fname[260];
	WORD					index;
	DEV_SHOWPROGRESSEVENT	event;
}THREAD_CONTEXT, *PTHREAD_CONTEXT;


typedef struct _TOUT_CONTEXT{
	PPROGRESS				progress;
	LPVOID					next;
}TOUT_CONTEXT, *PTOUT_CONTEXT;


DWORD						inet_ThreadID = 0;
DWORD						inet_dwExitCode = 0;
HANDLE						inet_Thread = INVALID_HANDLE_VALUE;
HANDLE						inet_Progress_Thread = INVALID_HANDLE_VALUE;
PTOUT_CONTEXT				inet_Progress_Timeout = NULL;
BOOL						inet_Lock_List = FALSE;


void net_InsertItemIntoTimeoutList(PPROGRESS item)
{
	PTOUT_CONTEXT p = inet_Progress_Timeout, pt = NULL;
	while (inet_Lock_List)
	{
		Sleep(1);
	}

	inet_Lock_List = TRUE;
	while (p)
	{
		pt = p;
		p = p->next;
	}
	p = malloc(sizeof(TOUT_CONTEXT));
	p->progress = item;
	p->next = NULL;
	if (!pt)
	{
		inet_Progress_Timeout = p;
	}
	else
	{
		pt->next = p;
	}
	inet_Lock_List = FALSE;
}

PTOUT_CONTEXT net_SearchItemFromTimeoutListByItem(PPROGRESS item)
{
	PTOUT_CONTEXT p = inet_Progress_Timeout;
	while (inet_Lock_List)
	{
		Sleep(1);
	}

	inet_Lock_List = TRUE;
	while (p)
	{
		if (p->progress == item)
		{
			break;
		}
		p = p->next;
	}
	inet_Lock_List = FALSE;
	return p;
}


PTOUT_CONTEXT net_SearchItemFromTimeoutListByIndex(WORD index)
{
	PTOUT_CONTEXT p = inet_Progress_Timeout;
	while (inet_Lock_List)
	{
		Sleep(1);
	}

	inet_Lock_List = TRUE;
	while (p)
	{
		if (p->progress->index == index)
		{
			break;
		}
		p = p->next;
	}
	inet_Lock_List = FALSE;
	return p;
}


void net_DisposeTimeoutListItemByItem(PPROGRESS item)
{
	PTOUT_CONTEXT p = inet_Progress_Timeout, pt = NULL;

	inet_Lock_List = TRUE;
	while (p)
	{
		if (p->progress == item)
		{
			if (!pt)	//delete the header
			{
				inet_Progress_Timeout = p->next;
			}
			else
			if (!p->next)	//delete the tail
			{
				if (pt)
				{
					pt->next = NULL;
				}
			}
			else
			{
				pt->next = p->next;
			}
			if (p->progress)
			{
				p->progress->flag = 1;
//				free(p->progress);
				p->progress = NULL;
			}
			free(p);
			p = NULL;
			break;
		}
		pt = p;
		p = p->next;
	}
	inet_Lock_List = FALSE;
}

void net_RemoveItemFromTimeoutListByIndex(WORD index)
{
	PTOUT_CONTEXT p = inet_Progress_Timeout, pt = NULL;
	while (p)
	{
		if (p->progress->index == index)
		{
			net_DisposeTimeoutListItemByItem(p->progress);
			break;
		}
		pt = p;
		p = p->next;
	}
}

void net_RemoveTimeoutList()
{
	PTOUT_CONTEXT p = inet_Progress_Timeout;
	while (inet_Lock_List)
	{
	}

	inet_Lock_List = TRUE;
	while (p)
	{
		net_DisposeTimeoutListItemByItem(p->progress);
		p = inet_Progress_Timeout;
	}
	inet_Lock_List = FALSE;
}



DWORD WINAPI inet_ShowProgress_Thread(LPVOID thread)
{
	BOOL complete = TRUE;
	HANDLE hwnd = inet_Progress_Thread;
	PTOUT_CONTEXT p = inet_Progress_Timeout;
	DEV_SHOWPROGRESSEVENT event;

	while (TRUE)
	{
		while (inet_Lock_List)
		{
			Sleep(1);
			continue;
		}

		complete = TRUE;
		inet_Lock_List = TRUE;
		p = inet_Progress_Timeout;
		if (!p)
		{
			break;
		}
		while (p)
		{
			if (!p->progress)
			{
				Sleep(1);
				p = p->next;
				continue;
			}
			complete = complete && (p->progress->flag);
			if (!(p->progress->flag & 0x80))	//not be locked
			{
				if (p->progress->totallen > 0)
				{
					p->progress->per = (BYTE)(p->progress->position * 100 / p->progress->totallen);
					if (p->progress->event)
					{
						event = (DEV_SHOWPROGRESSEVENT)p->progress->event;
						event(p->progress);
					}
				}
			}
			Sleep(1);
			p = p->next;
		}
		inet_Lock_List = FALSE;
		if (complete)
		{
			net_RemoveTimeoutList();
			break;
		}
	}

	if (GetExitCodeThread(inet_Progress_Thread, &inet_dwExitCode))
	{
		inet_Progress_Thread = INVALID_HANDLE_VALUE;
		TerminateThread(hwnd, inet_dwExitCode);
	}

	return 0;
}



DWORD WINAPI inet_SendFile_Thread(LPVOID thread)
{
	PINT ret = malloc(sizeof(int));
	PTHREAD_CONTEXT p = (PTHREAD_CONTEXT)thread;
	PDWORD timeout = NULL;
	PDWORD len = NULL;
	PCHAR filename = NULL;
	PBOOL tout = malloc(sizeof(BOOL));
	PTF_COMMAND cmd = NULL;
	PTRAN_THREAD tran = malloc(sizeof(TRAN_THREAD));
	PBYTE buf = NULL;
	PPROGRESS progress = malloc(sizeof(PROGRESS));

	memset(progress, 0, sizeof(PROGRESS));
	progress->event = p->event;
	progress->index = p->index;
	net_InsertItemIntoTimeoutList(progress);

	if (inet_Progress_Thread == INVALID_HANDLE_VALUE)
	{
		inet_Progress_Thread = CreateThread(
									NULL,
									0,
									&inet_ShowProgress_Thread,
									NULL,
									0,
									&inet_ThreadID);
	}


	memset(tran, 0, sizeof(TRAN_THREAD));
	tran->ctrl = malloc(sizeof(TRAN_CTRL));
	memset(tran->ctrl, 0, sizeof(TRAN_CTRL));
	tran->addr.sin_addr.S_un.S_addr = inet_addr(p->ip);
	tran->addr.sin_family = PF_INET;
	tran->addr.sin_port = htons(p->port);
	tran->sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
	if (tran->sock != INVALID_SOCKET)
	{
		*ret = connect(tran->sock, (struct sockaddr *)&tran->addr, sizeof(SOCKADDR_IN));
		if (*ret == 0)
		{
			filename = malloc(strlen(p->fname) + 1);
			ExtractFileName(p->fname, filename);
			tran->hfile = CreateFile(
											p->fname,
											GENERIC_READ | GENERIC_WRITE,
											FILE_SHARE_READ | FILE_SHARE_WRITE,
											NULL,
											OPEN_ALWAYS,
											FILE_ATTRIBUTE_NORMAL,
											NULL);
			tran->ctrl->fsize = GetFileSize(tran->hfile, NULL);
			*ret = sizeof(DWORD) + strlen(filename);
			cmd = malloc(sizeof(TF_COMMAND));
			INIT_CMD(cmd);
			cmd->cmd = TRAN_REQ_WRITE;
			cmd->opcode = TRAN_REQ_DATA;
			cmd->low = *ret % 256;
			cmd->high = *ret / 256;
			cmd->data = malloc(*ret);
			*(cmd->data + 0) = (BYTE)(tran->ctrl->fsize % 256);
			*(cmd->data + 1) = (BYTE)(tran->ctrl->fsize / 256);
			*(cmd->data + 2) = (BYTE)(tran->ctrl->fsize / (256 * 256));
			*(cmd->data + 3) = (BYTE)(tran->ctrl->fsize / (256 * 256 * 256));
			memcpy(cmd->data + 4, filename, strlen(filename));
			REPLY_REMOTE(tran->sock, cmd);
			free(filename);
			*tout = FALSE;
			len = malloc(sizeof(DWORD));
			progress->flag = 0x80;
			progress->position = 0;
			progress->totallen = tran->ctrl->fsize;
			timeout = malloc(sizeof(DWORD));
			progress->flag = 0x00;
			buf = malloc(128);
			cmd->data = malloc(TRAN_BUFFER_SIZE);
			*timeout = GetTickCount();
			while (!*tout)
			{
				ioctlsocket(tran->sock, FIONREAD, len);
				if (*len <= 0)
				{
					*tout = ((GetTickCount() - *timeout >= TRAN_TIMEOUT_TIME)?TRUE:FALSE);
					Sleep(1);
					continue;
				}
				*ret = recv(tran->sock, buf, *len, 0);
				memcpy(cmd, buf, 6);
		//		cmd->data = malloc(TRAN_BUFFER_SIZE);
		//		free(buf);

		//		cmd->bcc = *(buf + 6);
				if (cmd->opcode == RET_SUCCESS)
				{
					cmd->seq ++;
					if (tran->hfile != INVALID_HANDLE_VALUE)
					{
						ReadFile(
									tran->hfile,
									cmd->data,
									TRAN_BUFFER_SIZE,
									len,
									NULL);
						cmd->low = (BYTE)(*len % 256);
						cmd->high = (BYTE)(*len / 256);
						REPLY_REMOTE(tran->sock, cmd);
						progress->flag = 0x80;
						progress->position += *len;
						progress->flag = 0x00;
					}
					if (progress->position >= progress->totallen)
					{
						break;
					}
				}
				*tout = ((GetTickCount() - *timeout >= TRAN_TIMEOUT_TIME)?TRUE:FALSE);
				*timeout = GetTickCount();
				Sleep(1);
			}
			free(cmd->data);
			free(buf);
			free(cmd);
			free(len);
			free(timeout);
		}
	}
	progress->flag = 1;
//	net_RemoveItemFromTimeoutListByIndex(progress->index);

	free(ret);
	free(p);
	free(tout);
	free(tran);
//	free(progress);


	inet_Thread = GetCurrentThread();
	if (GetExitCodeThread(inet_Thread, &inet_dwExitCode))
	{
		TerminateThread(inet_Thread, inet_dwExitCode);
	}

	return RET_SUCCESS;
}



DWORD WINAPI net_SendFile(char * sip, WORD port, char * filename, DEV_SHOWPROGRESSEVENT event, WORD index)
{
	PTHREAD_CONTEXT p = malloc(sizeof(THREAD_CONTEXT));
	memset(p, 0, sizeof(THREAD_CONTEXT));
	memcpy(&p->fname, filename, strlen(filename));
	memcpy(&p->ip, sip, strlen(sip));
	p->port = port;
	p->event = event;
	p->index = index;
	CreateThread(
					NULL,
					0,
					&inet_SendFile_Thread,
					p,
					0,
					&inet_ThreadID);
	return RET_SUCCESS;
}



#endif	//__TRANSFER_FILE_CLIENT_C__