sockmgr.cpp

远程控制系统,可以实现局域网内进行远程控制计算机,很方便,并且是学习用的非常好的资料.

		return SOCKMGR_BUFFER_LOCKED;

	switch (method)
	{
	case BUFFER_BEGIN:
		psim->sib.pointer = move;
		break;
	case BUFFER_CURRENT:
		psim->sib.pointer += move;
		break;
	case BUFFER_END:
		psim->sib.pointer = psim->sib.datalength + move;
		break;
	}

	return SOCKMGR_SUCCESS;
}

void CSockManager::CleanupBuffer(SOCKET sock)
{
	PSOCK_IO_MANAGER psim = (PSOCK_IO_MANAGER)GetSim(sock);

	if (psim == NULL)
		return;

	if (psim->siblock != BUFFER_LOCKED_NONE &&
		psim->siblock != BUFFER_LOCKED_USER)
		return;

	psim->sib.pointer = 0;
	psim->sib.datalength = 0;
}

char *CSockManager::GetErrorString()
{
	LPVOID lpMsgBuf;

	FormatMessage(	FORMAT_MESSAGE_ALLOCATE_BUFFER |
					FORMAT_MESSAGE_FROM_SYSTEM |
					FORMAT_MESSAGE_IGNORE_INSERTS,
					NULL,
					lastErrorCode,
					0,
					(LPTSTR)&lpMsgBuf,
					0,
					NULL
					);

	return (char *)lpMsgBuf;
}

int CSockManager::SendPack(SOCKET sock, char *buffer, int length, int flags)
{
	if (Inited == false)
	{
		InitializeCriticalSection(&SendCS);
		InitializeCriticalSection(&RecvCS);
		Inited = true;
	}

	PTEMP_BUFFER p = ptb;
	int result = SOCKMGR_PENDING;

	EnterCriticalSection(&SendCS);

	while (p != NULL)
	{
		if (p->sock == sock && p->method == 1)
			break;
		p = p->next;
	}

	if (p != NULL && buffer != NULL)
	{
		LeaveCriticalSection(&SendCS);
		return SOCKMGR_SOCK_LOCKED;
	}

	if (p == NULL)
	{
		if (buffer == NULL)
			return SOCKMGR_NOT_BUFFER;

		if (flags == 0)
		{
			p = (PTEMP_BUFFER)new char[sizeof(TEMP_BUFFER) + sizeof(PACK_TYPE_1) + length];

			if (p == NULL)
				return SOCKMGR_NOT_ENOUGH_MEMORY;

			p->sock = sock;
			p->buffer = (char *)p + sizeof(TEMP_BUFFER);
			p->length = sizeof(PACK_TYPE_1) + length;
			p->pointer = 0;
			p->method = 1;
			p->next = ptb;
			ptb = p;

			PPACK_TYPE_1 pack = (PPACK_TYPE_1)(p->buffer);
			pack->dwPackType = 0;
			pack->nPackSize = length;
			memcpy(pack->bPackData, buffer, length);
		}
		else
		{
			p = (PTEMP_BUFFER)new char[sizeof(TEMP_BUFFER) + sizeof(PACK_TYPE_2) + length + 0x1000];

			if (p == NULL)
				return SOCKMGR_NOT_ENOUGH_MEMORY;

			p->buffer = (char *)p + sizeof(TEMP_BUFFER);

			PPACK_TYPE_2 pack = (PPACK_TYPE_2)(p->buffer);

			if (flags & SOCKMGR_SEND_COMPRESS)
			{
				pack->bCompressed = TRUE;
				pack->nPackSize = Lz77Compress(p->buffer, buffer, length, 2);
			}
			else
			{
				pack->bCompressed = FALSE;
				pack->nPackSize = length;
			}

			if (flags & SOCKMGR_SEND_ENCRYPT)
			{
				rc5_encrypt(pack->bPackData, pack->bPackData, pack->nPackSize);
				pack->bEncrypted = TRUE;
			}
			else
			{
				pack->bEncrypted = FALSE;
			}

			pack->dwPackType = 1;
			pack->nOriginalSize = length;
			pack->dwCrc32 = crc32(0, pack->bPackData, pack->nPackSize);

			p->sock = sock;
			p->length = sizeof(PACK_TYPE_2) + pack->nPackSize;
			p->pointer = 0;
			p->method = 1;
			p->next = ptb;
			ptb = p;
		}
	}

	LeaveCriticalSection(&SendCS);

	int ret = send(p->sock, p->buffer + p->pointer, p->length - p->pointer, 0);

	if (ret == SOCKET_ERROR)
	{
		if (GetLastError() == WSAEWOULDBLOCK)
			return SOCKMGR_PENDING;
		else
		{
			result = SOCKMGR_SOCK_FAILED;
			goto cleanup;
		}
	}

	p->pointer += ret;

	if (p->pointer == p->length)
	{
		result = SOCKMGR_SUCCESS;
		goto cleanup;
	}

	return SOCKMGR_PENDING;

cleanup:
	EnterCriticalSection(&SendCS);

	for (PTEMP_BUFFER *prev = &ptb; *prev != NULL; prev = &((*prev)->next))
	{
		if ((*prev)->sock == sock && (*prev)->method == 1)
		{
			*prev = (*prev)->next;
			break;
		}
	}

	delete [] p;

	LeaveCriticalSection(&SendCS);

	return result;
}

int CSockManager::RecvPack(SOCKET sock, IoCallBack funback, LPVOID funparam)
{
	if (Inited == false)
	{
		InitializeCriticalSection(&SendCS);
		InitializeCriticalSection(&RecvCS);
		Inited = true;
	}

	PTEMP_BUFFER p = ptb;
	int result = SOCKMGR_PENDING;
	int ret;

	EnterCriticalSection(&RecvCS);

	while (p != NULL)
	{
		if (p->sock == sock && p->method == 2)
			break;
		p = p->next;
	}

	if (p == NULL)
	{
		p = new TEMP_BUFFER;

		if (p == NULL)
		{
			LeaveCriticalSection(&RecvCS);
			return SOCKMGR_NOT_ENOUGH_MEMORY;
		}

		p->sock = sock;
		p->buffer = (char *)HeapAlloc(GetProcessHeap(), 0, sizeof(PACK_TYPE_1));

		if (p->buffer == NULL)
		{
			delete p;
			LeaveCriticalSection(&RecvCS);
			return SOCKMGR_NOT_ENOUGH_MEMORY;
		}

		p->length = sizeof(PACK_TYPE_1);
		p->pointer = 0;
		p->method = 2;
		p->funback = funback;
		p->funparam = funparam;
		p->next = ptb;
		ptb = p;
	}

	LeaveCriticalSection(&RecvCS);

	if (p->pointer < sizeof(PACK_TYPE_1))
	{
		int ret = recv(p->sock, p->buffer + p->pointer, sizeof(PACK_TYPE_1) - p->pointer, 0);

		if (ret == SOCKET_ERROR)
		{
			if (GetLastError() == WSAEWOULDBLOCK)
				return SOCKMGR_PENDING;
			else
			{
				result = SOCKMGR_SOCK_FAILED;
				goto cleanup;
			}
		}

		p->pointer += ret;

		if (p->pointer < sizeof(PACK_TYPE_1))
			return SOCKMGR_PENDING;

		PPACK_TYPE_1 pack = (PPACK_TYPE_1)(p->buffer);
		p->length = (pack->dwPackType == 0 ? sizeof(PACK_TYPE_1) : sizeof(PACK_TYPE_2)) + pack->nPackSize;
		p->buffer = (char *)HeapReAlloc(GetProcessHeap(), 0, p->buffer, p->length);

		if (p->buffer == NULL)
		{
			result = SOCKMGR_NOT_ENOUGH_MEMORY;
			goto cleanup;
		}
	}

	ret = recv(p->sock, p->buffer + p->pointer, p->length - p->pointer, 0);

	if (ret == SOCKET_ERROR)
	{
		if (GetLastError() == WSAEWOULDBLOCK)
			return SOCKMGR_PENDING;
		else
		{
			result = SOCKMGR_SOCK_FAILED;
			goto cleanup;
		}
	}

	p->pointer += ret;

	if (p->pointer == p->length)
	{
		if (((PPACK_TYPE_1)p->buffer)->dwPackType == 0)
		{
			PPACK_TYPE_1 pack = (PPACK_TYPE_1)(p->buffer);
			PACK_INFO pi;

			pi.bCompress = false;
			pi.bEncrypt = false;
			pi.pData = (char *)pack->bPackData;
			pi.nDataSize = pack->nPackSize;
			pi.nPackSize = pack->nPackSize;

			if (p->funback != NULL)
			{
				p->funback(&pi, p->funparam);
				result = SOCKMGR_SUCCESS;
				goto cleanup;
			}
		}
		else
		{
			PPACK_TYPE_2 pack = (PPACK_TYPE_2)(p->buffer);
			PACK_INFO pi;

			pi.bCompress = pack->bCompressed ? true : false;
			pi.bEncrypt = pack->bEncrypted ? true : false;
			pi.pData = (char *)pack->bPackData;
			pi.nDataSize = pack->nOriginalSize;
			pi.nPackSize = pack->nPackSize;

			if (crc32(0, (char *)pack->bPackData, pack->nPackSize) != pack->dwCrc32)
			{
				result = SOCKMGR_PACK_CRC_FAILED;
				goto cleanup;
			}

			if (pack->bEncrypted != FALSE)
				rc5_decrypt(pack->bPackData, pack->bPackData, pack->nPackSize);

			if (pack->bCompressed != FALSE)
			{
				char *t = (char *)HeapAlloc(GetProcessHeap(), 0, pack->nOriginalSize);

				if (t == NULL)
				{
					result = SOCKMGR_NOT_ENOUGH_MEMORY;
					goto cleanup;
				}

				Lz77Decompress(t, pack->bPackData, pack->nPackSize);
				p->length = pack->nOriginalSize;
				HeapFree(GetProcessHeap(), 0, p->buffer);
				p->buffer = t;
				pi.pData = t;
			}

			if (p->funback != NULL)
			{
				p->funback(&pi, p->funparam);
				result = SOCKMGR_SUCCESS;
				goto cleanup;
			}
		}
	}
	return SOCKMGR_PENDING;

cleanup:
	EnterCriticalSection(&RecvCS);

	for (PTEMP_BUFFER *prev = &ptb; *prev != NULL; prev = &((*prev)->next))
	{
		if ((*prev)->sock == sock && (*prev)->method == 2)
		{
			*prev = (*prev)->next;
			break;
		}
	}

	if (p->buffer != NULL)
		HeapFree(GetProcessHeap(), 0, p->buffer);

	delete p;
	LeaveCriticalSection(&RecvCS);

	return result;
}

void CSockManager::InterruptSend(SOCKET sock)
{
	if (Inited == false)
		return;

	PTEMP_BUFFER p = NULL;

	EnterCriticalSection(&SendCS);

	for (PTEMP_BUFFER *prev = &ptb; *prev != NULL; prev = &((*prev)->next))
	{
		if ((*prev)->sock == sock && (*prev)->method == 1)
		{
			p = *prev;
			*prev = (*prev)->next;
			break;
		}
	}

	if (p != NULL)
		delete [] p;

	LeaveCriticalSection(&SendCS);
}

void CSockManager::InterruptRecv(SOCKET sock)
{
	if (Inited == false)
		return;

	PTEMP_BUFFER p = NULL;

	EnterCriticalSection(&RecvCS);

	for (PTEMP_BUFFER *prev = &ptb; *prev != NULL; prev = &((*prev)->next))
	{
		if ((*prev)->sock == sock && (*prev)->method == 2)
		{
			p = *prev;
			*prev = (*prev)->next;
			break;
		}
	}

	if (p != NULL)
	{
		if (p->buffer != NULL)
			HeapFree(GetProcessHeap(), 0, p->buffer);

		delete p;
	}

	LeaveCriticalSection(&RecvCS);
}