tftpserver.cpp

一个简单的tftp服务器

				sprintf(outPtr, "%u", val);
				outPtr += strlen(outPtr) + 1;
			}
			else if (!strcasecmp(inPtr, "tsize"))
			{
				strcpy(outPtr, inPtr);
				outPtr += strlen(outPtr) + 1;
				inPtr += strlen(inPtr) + 1;

				if (!fseek(req->file, 0, SEEK_END))
					req->tsize = ftell(req->file);

				sprintf(outPtr, "%u", req->tsize);
				outPtr += strlen(outPtr) + 1;
			}
			else if (!strcasecmp(inPtr, "timeout"))
			{
				strcpy(outPtr, inPtr);
				outPtr += strlen(outPtr) + 1;
				inPtr += strlen(inPtr) + 1;
				val = atoi(inPtr);

				if (val < 1)
					val = 1;
				else if (val > 255)
					val = 255;

				req->timeout = val;
				req->expiry = time(NULL) + req->timeout;
				sprintf(outPtr, "%u", val);
				outPtr += strlen(outPtr) + 1;
			}

			inPtr += strlen(inPtr) + 1;

			//printf("=%u\n", val);
		}

		errno = 0;
		req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->acout, (DWORD)outPtr - (DWORD)&req->acout, 0, (sockaddr*)&req->client, req->clientsize);
		//errno = WSAGetLastError();
	}
	else if (htons(datain->opcode) == 2)
	{
		req->acout.opcode = htons(4);
		req->acout.block = htons(0);
		errno = 0;
		req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->acout, 4, 0, (sockaddr*)&req->client, req->clientsize);
		//errno = WSAGetLastError();
	}

	if (errno)
	{
		sprintf(req->serverError.errormessage, "Communication Error");
		logMess(req, 1);
		req->attempt = UCHAR_MAX;

		if (req->file)
		{
			fclose(req->file);
			req->file = 0;
		}
		return errno;
	}

	if (ntohs(datain->opcode) == 1)
	{
		errno = 0;
		req->pkt[0] = (packet*)calloc(1, req->blksize + 4);
		req->pkt[1] = (packet*)calloc(1, req->blksize + 4);

		if (errno || !req->pkt[0] || !req->pkt[1])
		{
			strcpy(req->serverError.errormessage, "Memory Error");
			logMess(req, 1);
			req->attempt = UCHAR_MAX;
			return 1;
		}

		if (ftell(req->file) > 0)
			fseek(req->file, 0, SEEK_SET);

		req->pkt[0]->opcode = htons(3);
		req->pkt[0]->block = htons(1);
		req->bytesRead[0] = fread(&req->pkt[0]->buffer, 1, req->blksize, req->file);

		if (errno)
		{
			req->serverError.opcode = htons(5);
			req->serverError.errorcode = htons(1);
			strcpy(req->serverError.errormessage, "Invalid Path or No Access");
			req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->serverError, strlen(req->serverError.errormessage) + 5, 0, (sockaddr*)&req->client, req->clientsize);
			logMess(req, 1);
			req->attempt = UCHAR_MAX;

			if (req->file)
			{
				fclose(req->file);
				req->file = 0;
			}
			return errno;
		}

		if (req->bytesRead[0] == req->blksize)
		{
			req->pkt[1]->opcode = htons(3);
			req->pkt[1]->block = htons(2);
			req->bytesRead[1] = fread(&req->pkt[1]->buffer, 1, req->blksize, req->file);

			if (errno)
			{
				req->serverError.opcode = htons(5);
				req->serverError.errorcode = htons(1);
				strcpy(req->serverError.errormessage, "Invalid Path or No Access");
				req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->serverError, strlen(req->serverError.errormessage) + 5, 0, (sockaddr*)&req->client, req->clientsize);
				logMess(req, 1);
				req->attempt = UCHAR_MAX;

				if (req->file)
				{
					fclose(req->file);
					req->file = 0;
				}
				return errno;
			}

			if ((DWORD)req->bytesRead[1] < req->blksize)
			{
				fclose(req->file);
				req->file = 0;
			}
		}
		else
		{
			fclose(req->file);
			req->file = 0;
		}

		if (!req->bytesSent)
		{
			req->block = 1;
			return processSend(req);
		}
	}
	return 0;
}

int processSend(request *req)
{
	errno = 0;
	req->expiry = time(NULL) + req->timeout;

	if (ntohs(req->pkt[0]->block) == req->block)
	{
		errno = 0;
		req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)req->pkt[0], req->bytesRead[0] + 4, 0, (sockaddr*)&req->client, req->clientsize);
		memcpy(&req->acout, req->pkt[0], 4);
		//errno = WSAGetLastError();

		if (errno)
		{
			sprintf(req->serverError.errormessage, "Communication Error");
			logMess(req, 1);
			req->attempt = UCHAR_MAX;

			if (req->file)
			{
				fclose(req->file);
				req->file = 0;
			}
			return errno;
		}

		if (req->file)
		{
			req->tblock = ntohs(req->pkt[1]->block) + 1;
			if (req->tblock == req->block)
			{
				req->pkt[1]->block = htons(++req->tblock);
				req->bytesRead[1] = fread(&req->pkt[1]->buffer, 1, req->blksize, req->file);

				if (errno)
				{
					req->serverError.opcode = htons(5);
					req->serverError.errorcode = htons(1);
					strcpy(req->serverError.errormessage, "Invalid Path or No Access");
					req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->serverError, strlen(req->serverError.errormessage) + 5, 0, (sockaddr*)&req->client, req->clientsize);
					logMess(req, 1);
					req->attempt = UCHAR_MAX;

					if (req->file)
					{
						fclose(req->file);
						req->file = 0;
					}
					return errno;
				}
				else if (req->bytesRead[1] < req->blksize)
				{
					fclose(req->file);
					req->file = 0;
				}
			}
		}
	}
	else if (ntohs(req->pkt[1]->block) == req->block)
	{
		errno = 0;
		req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)req->pkt[1], req->bytesRead[1] + 4, 0, (sockaddr*)&req->client, req->clientsize);
		memcpy(&req->acout, req->pkt[1], 4);
		//errno = WSAGetLastError();

		if (errno)
		{
			sprintf(req->serverError.errormessage, "Communication Error");
			logMess(req, 1);
			req->attempt = UCHAR_MAX;

			if (req->file)
			{
				fclose(req->file);
				req->file = 0;
			}
			return errno;
		}

		if (req->file)
		{
			req->tblock = ntohs(req->pkt[0]->block) + 1;
			if (req->tblock == req->block)
			{
				req->pkt[0]->block = htons(++req->tblock);
				req->bytesRead[0] = fread(&req->pkt[0]->buffer, 1, req->blksize, req->file);

				if (errno)
				{
					req->serverError.opcode = htons(5);
					req->serverError.errorcode = htons(1);
					strcpy(req->serverError.errormessage, "Invalid Path or No Access");
					req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->serverError, strlen(req->serverError.errormessage) + 5, 0, (sockaddr*)&req->client, req->clientsize);
					logMess(req, 1);
					req->attempt = UCHAR_MAX;

					if (req->file)
					{
						fclose(req->file);
						req->file = 0;
					}
					return errno;
				}
				else if (req->bytesRead[0] < req->blksize)
				{
					fclose(req->file);
					req->file = 0;
				}
			}
		}
	}
	else //if (ntohs(req->pkt[0]->block) < req->block && ntohs(req->pkt[1]->block) < req->block)
	{
		req->attempt = UCHAR_MAX;
		sprintf(logBuff, "Client %s %s, %i Blocks Served", req->mapname, req->path, req->fblock );
		logMess(logBuff, 2);
	}

	return 0;
}

int processRecv(request *req)
{
	req->expiry = time(NULL) + req->timeout;
	errno = 0;
	req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->acout, 4, 0, (sockaddr*)&req->client, req->clientsize);
	//errno = WSAGetLastError();
	if (errno)
	{
		sprintf(req->serverError.errormessage, "Communication Error");
		logMess(req, 1);
		req->attempt = UCHAR_MAX;

		if (req->file)
		{
			fclose(req->file);
			req->file = 0;
		}

		return errno;
	}

	if (req->bytesRecd > 4 && !fwrite(&datain->buffer, req->bytesRecd - 4, 1, req->file))
	{
		req->serverError.opcode = htons(5);
		req->serverError.errorcode = htons(3);
		strcpy(req->serverError.errormessage, "Disk full or allocation exceeded");
		req->bytesSent = sendto(cfig.tftpConn[req->sockInd].sock, (const char*)&req->serverError, strlen(req->serverError.errormessage) + 5, 0, (sockaddr*)&req->client, req->clientsize);
		logMess(req, 1);
		req->attempt = UCHAR_MAX;

		if (req->file)
		{
			fclose(req->file);
			req->file = 0;
		}
		return 1;
	}

	//printf("%u\n", req->bytesRecd);

	if ((WORD)req->bytesRecd < req->blksize + 4)
	{
		sprintf(logBuff, "Client %s %s, %u Blocks Received", req->mapname, req->path, req->fblock);
		logMess(logBuff, 2);
		req->attempt = UCHAR_MAX;
		fclose(req->file);
		req->file = 0;
		return 0;
	}

	return 0;
}

char* myGetToken(char* buff, BYTE index)
{
	while (*buff)
	{
		if (index)
			index--;
		else
			break;

		buff += strlen(buff) + 1;
	}

	return buff;
}

WORD myTokenize(char *target, char *source, char *sep, bool whiteSep)
{
	bool found = true;
	char *dp = target;
	WORD kount = 0;

	while (*source)
	{
		if (sep && sep[0] && strchr(sep, (*source)))
		{
			found = true;
			source++;
			continue;
		}
		else if (whiteSep && *source <= 32)
		{
			found = true;
			source++;
			continue;
		}

		if (found)
		{
			if (target != dp)
			{
				*dp = 0;
				dp++;
			}
			kount++;
		}

		found = false;
		*dp = *source;
		dp++;
		source++;
	}

	*dp = 0;
	dp++;
	*dp = 0;

	//printf("%s\n", target);

	return kount;
}

char* myTrim(char *target, char *source)
{
	while ((*source) && (*source) <= 32)
		source++;

	int i = 0;

	for (; i < 511 && source[i]; i++)
		target[i] = source[i];

	target[i] = source[i];
	i--;

	for (; i >= 0 && target[i] <= 32; i--)
		target[i] = 0;

	return target;
}

void mySplit(char *name, char *value, char *source, char splitChar)
{
	int i = 0;
	int j = 0;
	int k = 0;

	for (; source[i] && j <= 510 && source[i] != splitChar; i++, j++)
	{
		name[j] = source[i];
	}

	if (source[i])
	{
		i++;
		for (; k <= 510 && source[i]; i++, k++)
		{
			value[k] = source[i];
		}
	}

	name[j] = 0;
	value[k] = 0;

	myTrim(name, name);
	myTrim(value, value);
	//printf("%s %s\n", name, value);
}

bool getSection(char *sectionName, char *buffer, BYTE serial, char *fileName)
{
	//printf("%s=%s\n",fileName,sectionName);
	char section[128];
	sprintf(section, "[%s]", sectionName);
	myUpper(section);
	FILE *f = fopen(fileName, "rt");
	char buff[512];
	BYTE found = 0;

	if (f)
	{
		while (fgets(buff, 511, f))
		{
			myUpper(buff);
			myTrim(buff, buff);

			if (strstr(buff, section) == buff)
			{
				found++;
				if (found == serial)
				{
					//printf("%s=%s\n",fileName,sectionName);
					while (fgets(buff, 511, f))
					{
						myTrim(buff, buff);

						if (strstr(buff, "[") == buff)
							break;

						if ((*buff) >= '0' && (*buff) <= '9' || (*buff) >= 'A' && (*buff) <= 'Z' || (*buff) >= 'a' && (*buff) <= 'z' || ((*buff) && strchr("/\\?*", (*buff))))
						{
							buffer += sprintf(buffer, "%s", buff);
							buffer++;
						}
					}
					break;
				}
			}
		}
		fclose(f);
	}

	*buffer = 0;
	*(buffer + 1) = 0;
	return (found == serial);
}

char *IP2String(char *target, DWORD ip)
{
	data15 inaddr;
	inaddr.ip = (unsigned int)ip;
	sprintf(target, "%u.%u.%u.%u", inaddr.octate[0], inaddr.octate[1], inaddr.octate[2], inaddr.octate[3]);
	return target;
}

char *myUpper(char *string)
{
	char diff = 'a' - 'A';

	WORD len = strlen(string);

	for (int i = 0; i < len; i++)
		if (string[i] >= 'a' && string[i] <= 'z')
			string[i] -= diff;

	return string;
}

char *myLower(char *string)
{
	char diff = 'a' - 'A';

	WORD len = strlen(string);

	for (int i = 0; i < len; i++)