tftpd.cpp File Reference

#include <stdio.h>
#include <winsock2.h>
#include <process.h>
#include <time.h>
#include <tchar.h>
#include <ws2tcpip.h>
#include <limits.h>
#include <iphlpapi.h>
#include <math.h>
#include "tftpd.h"

Include dependency graph for tftpd.cpp:

Go to the source code of this file.

Functions
void WINAPI	ServiceControlHandler (DWORD controlCode)
void WINAPI	ServiceMain (DWORD, TCHAR *[])
void	runService ()
bool	stopService (SC_HANDLE service)
void	installService ()
void	uninstallService ()
void	printWindowsError ()
int	main (int argc, TCHAR *argv[])
void	runProg ()
void	closeConn ()
void	processRequest (void *lpParam)
bool	cleanReq (request *req)
bool	getSection (const char *sectionName, char *buffer, MYBYTE serial, char *fileName)
FILE *	openSection (const char *sectionName, MYBYTE serial, char *fileName)
char *	readSection (char *buff, FILE *f)
char *	myGetToken (char *buff, MYBYTE index)
MYWORD	myTokenize (char *target, char *source, char *sep, bool whiteSep)
char *	myTrim (char *target, char *source)
void	mySplit (char *name, char *value, char *source, char splitChar)
char *	IP2String (char *target, MYDWORD ip)
bool	isIP (char *string)
char *	myUpper (char *string)
char *	myLower (char *string)
void	init (void *lpParam)
bool	detectChange ()
void	getInterfaces (data1 *network)
bool	addServer (MYDWORD *array, MYDWORD ip)
MYDWORD *	findServer (MYDWORD *array, MYDWORD ip)
void	logMess (char *logBuff, MYBYTE logLevel)
void	logMess (request *req, MYBYTE logLevel)

Variables
char	serviceName [] = "TFTPServer"
char	displayName [] = "Open TFTP Server, MultiThreaded"
char	sVersion [] = "Open TFTP Server MultiThreaded Version 1.64 Windows Built 2001"
char	iniFile [_MAX_PATH]
char	logFile [_MAX_PATH]
char	lnkFile [_MAX_PATH]
char	tempbuff [256]
char	extbuff [_MAX_PATH]
char	logBuff [512]
char	fileSep = '\\'
char	notFileSep = '/'
MYWORD	blksize = 65464
char	verbatim = 0
MYWORD	timeout = 3
MYWORD	loggingDay
data1	network
data1	newNetwork
data2	cfig
HANDLE	tEvent
HANDLE	cEvent
HANDLE	sEvent
HANDLE	lEvent
MYBYTE	currentServer = UCHAR_MAX
MYWORD	totalThreads =0
MYWORD	minThreads =1
MYWORD	activeThreads =0
SERVICE_STATUS	serviceStatus
SERVICE_STATUS_HANDLE	serviceStatusHandle = 0
HANDLE	stopServiceEvent = 0

Function Documentation

addServer()

bool addServer	(	MYDWORD *	array,
		MYDWORD	ip
	)

Definition at line 2557 of file tftpd.cpp.

{
    for (MYBYTE i = 0; i < MAX_SERVERS; i++)
    {
        if (!ip || array[i] == ip)
            return 0;
        else if (!array[i])
        {
            array[i] = ip;
            return 1;
        }
    }
    return 0;
}

Referenced by getInterfaces().

cleanReq()

bool cleanReq

(

request *

req

)

Definition at line 1505 of file tftpd.cpp.

{
    //printf("cleaning\n");

    if (req->file)
        fclose(req->file);

    if (!(req->sock == INVALID_SOCKET))
    {
        //printf("Here\n");
        closesocket(req->sock);
    }

    if (req->pkt[0])
        free(req->pkt[0]);

    if (req->pkt[1])
        free(req->pkt[1]);

    WaitForSingleObject(cEvent, INFINITE);
    activeThreads--;
    SetEvent(cEvent);

    //printf("cleaned\n");

    return (totalThreads <= minThreads);
}

Referenced by processRequest().

closeConn()

void closeConn

(

)

Definition at line 481 of file tftpd.cpp.

{
    for (int i = 0; i < MAX_SERVERS && network.tftpConn[i].loaded; i++)
        if (network.tftpConn[i].ready)
            closesocket(network.tftpConn[i].sock);
}

Referenced by init(), runProg(), and ServiceMain().

detectChange()

bool detectChange

(

)

Definition at line 2428 of file tftpd.cpp.

{
    if (!cfig.failureCount)
    {
        if (cfig.ifspecified)
            return false;
    }

    MYDWORD eventWait = UINT_MAX;

    if (cfig.failureCount)
#ifdef __REACTOS__
        eventWait = 10000 * (1 << cfig.failureCount);
#else
        eventWait = 10000 * pow(2, cfig.failureCount);
#endif

    OVERLAPPED overlap;
    MYDWORD ret;
    HANDLE hand = NULL;
    overlap.hEvent = WSACreateEvent();

    ret = NotifyAddrChange(&hand, &overlap);

    if (ret != NO_ERROR)
    {
        if (WSAGetLastError() != WSA_IO_PENDING)
        {
            printf("NotifyAddrChange error...%d\n", WSAGetLastError());
            return true;
        }
    }

    if ( WaitForSingleObject(overlap.hEvent, eventWait) == WAIT_OBJECT_0 )
        WSACloseEvent(overlap.hEvent);

    network.ready = false;

    while (network.busy)
        Sleep(1000);

    if (cfig.failureCount)
    {
        sprintf(logBuff, "Retrying failed Listening Interfaces..");
        logMess(logBuff, 1);
    }
    else
    {
        sprintf(logBuff, "Network changed, re-detecting Interfaces..");
        logMess(logBuff, 1);
    }

    return true;
}

Referenced by init().

findServer()

MYDWORD* findServer	(	MYDWORD *	array,
		MYDWORD	ip
	)

Definition at line 2572 of file tftpd.cpp.

{
    if (ip)
    {
        for (MYBYTE i = 0; i < MAX_SERVERS && array[i]; i++)
        {
            if (array[i] == ip)
                return &(array[i]);
        }
    }
    return 0;
}

Referenced by init().

getInterfaces()

void getInterfaces

(

data1 *

network

)

Definition at line 2519 of file tftpd.cpp.

{
    memset(network, 0, sizeof(data1));

    SOCKET sd = WSASocket(PF_INET, SOCK_DGRAM, 0, 0, 0, 0);

    if (sd == INVALID_SOCKET)
        return;

    INTERFACE_INFO InterfaceList[MAX_SERVERS];
    unsigned long nBytesReturned;

    if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList,
                 sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR)
        return ;

    int nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);

    for (int i = 0; i < nNumInterfaces; ++i)
    {
        sockaddr_in *pAddress = (sockaddr_in*)&(InterfaceList[i].iiAddress);
        u_long nFlags = InterfaceList[i].iiFlags;

        if (pAddress->sin_addr.s_addr)
        {
            addServer(network->allServers, pAddress->sin_addr.s_addr);

            if (!(nFlags & IFF_POINTTOPOINT) && (nFlags & IFF_UP))
            {
                addServer(network->staticServers, pAddress->sin_addr.s_addr);
            }
        }
    }

    closesocket(sd);
}

Referenced by init().

getSection()

bool getSection	(	const char *	sectionName,
		char *	buffer,
		MYBYTE	serial,
		char *	fileName
	)

Definition at line 1533 of file tftpd.cpp.

{
    //printf("%s=%s\n",fileName,sectionName);
    char section[128];
    sprintf(section, "[%s]", sectionName);
    myUpper(section);
    FILE *f = fopen(fileName, "rt");
    char buff[512];
    MYBYTE 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);
}

init()

void init

(

void *

lpParam

)

Definition at line 1805 of file tftpd.cpp.

{
    memset(&cfig, 0, sizeof(cfig));

    GetModuleFileName(NULL, extbuff, _MAX_PATH);
    char *fileExt = strrchr(extbuff, '.');
    *fileExt = 0;
    sprintf(iniFile, "%s.ini", extbuff);
    sprintf(lnkFile, "%s.url", extbuff);
    fileExt = strrchr(extbuff, '\\');
    *fileExt = 0;
    fileExt++;
    sprintf(logFile, "%s\\log\\%s%%Y%%m%%d.log", extbuff, fileExt);

    FILE *f = NULL;
    char raw[512];
    char name[512];
    char value[512];

    if (verbatim)
    {
        cfig.logLevel = 2;
        printf("%s\n\n", sVersion);
    }
    else if ((f = openSection("LOGGING", 1, iniFile)))
    {
        cfig.logLevel = 1;
        tempbuff[0] = 0;

        while (readSection(raw, f))
        {
            if (!strcasecmp(raw, "None"))
                cfig.logLevel = 0;
            else if (!strcasecmp(raw, "Errors"))
                cfig.logLevel = 1;
            else if (!strcasecmp(raw, "All"))
                cfig.logLevel = 2;
            else
                sprintf(tempbuff, "Section [LOGGING], Invalid LogLevel: %s", raw);
        }
    }

    if (!verbatim && cfig.logLevel && logFile[0])
    {
        time_t t = time(NULL);
        tm *ttm = localtime(&t);
        loggingDay = ttm->tm_yday;
        strftime(extbuff, sizeof(extbuff), logFile, ttm);

        cfig.logfile = fopen(extbuff, "at");

        if (cfig.logfile)
        {
            WritePrivateProfileString("InternetShortcut","URL", extbuff, lnkFile);
            WritePrivateProfileString("InternetShortcut","IconIndex", "0", lnkFile);
            WritePrivateProfileString("InternetShortcut","IconFile", extbuff, lnkFile);
            sprintf(logBuff, "%s Starting..", sVersion);
            logMess(logBuff, 1);

            if (tempbuff[0])
                logMess(tempbuff, 0);
        }
    }

    MYWORD wVersionRequested = MAKEWORD(1, 1);
    WSAStartup(wVersionRequested, &cfig.wsaData);

    if (cfig.wsaData.wVersion != wVersionRequested)
    {
        sprintf(logBuff, "WSAStartup Error");
        logMess(logBuff, 1);
    }

    if ((f = openSection("HOME", 1, iniFile)))
    {
        while (readSection(raw, f))
        {
            mySplit(name, value, raw, '=');

            if (strlen(value))
            {
                if (!cfig.homes[0].alias[0] && cfig.homes[0].target[0])
                {
                    sprintf(logBuff, "Section [HOME], alias and bare path mixup, entry %s ignored", raw);
                    logMess(logBuff, 1);
                }
                else if (strchr(name, notFileSep) || strchr(name, fileSep) || strchr(name, '>') || strchr(name, '<') || strchr(name, '.'))
                {
                    sprintf(logBuff, "Section [HOME], invalid chars in alias %s, entry ignored", name);
                    logMess(logBuff, 1);
                }
                else if (name[0] && strlen(name) < 64 && value[0])
                {
#ifdef __REACTOS__
                    for (int i = 0; i < MAX_SERVERS; i++)
#else
                    for (int i = 0; i < 8; i++)
#endif
                    {
                        if (cfig.homes[i].alias[0] && !strcasecmp(name, cfig.homes[i].alias))
                        {
                            sprintf(logBuff, "Section [HOME], Duplicate Entry: %s ignored", raw);
                            logMess(logBuff, 1);
                            break;
                        }
                        else if (!cfig.homes[i].alias[0])
                        {
                            strcpy(cfig.homes[i].alias, name);
                            strcpy(cfig.homes[i].target, value);

                            if (cfig.homes[i].target[strlen(cfig.homes[i].target) - 1] != fileSep)
                            {
                                tempbuff[0] = fileSep;
                                tempbuff[1] = 0;
                                strcat(cfig.homes[i].target, tempbuff);
                            }

                            break;
                        }
                    }
                }
                else
                {
                    sprintf(logBuff, "Section [HOME], alias %s too large", name);
                    logMess(logBuff, 1);
                }
            }
            else if (!cfig.homes[0].alias[0] && !cfig.homes[0].target[0])
            {
                strcpy(cfig.homes[0].target, name);

                if (cfig.homes[0].target[strlen(cfig.homes[0].target) - 1] != fileSep)
                {
                    tempbuff[0] = fileSep;
                    tempbuff[1] = 0;
                    strcat(cfig.homes[0].target, tempbuff);
                }
            }
            else if (cfig.homes[0].alias[0])
            {
                sprintf(logBuff, "Section [HOME], alias and bare path mixup, entry %s ignored", raw);
                logMess(logBuff, 1);
            }
            else if (cfig.homes[0].target[0])
            {
                sprintf(logBuff, "Section [HOME], Duplicate Path: %s ignored", raw);
                logMess(logBuff, 1);
            }
            else
            {
                sprintf(logBuff, "Section [HOME], missing = sign, Invalid Entry: %s ignored", raw);
                logMess(logBuff, 1);
            }
        }
    }

    if (!cfig.homes[0].target[0])
    {
        GetModuleFileName(NULL, cfig.homes[0].target, UCHAR_MAX);
        char *iniFileExt = strrchr(cfig.homes[0].target, fileSep);
        *(++iniFileExt) = 0;
    }

    cfig.fileRead = true;

    if ((f = openSection("TFTP-OPTIONS", 1, iniFile)))
    {
        while (readSection(raw, f))
        {
            mySplit(name, value, raw, '=');

            if (strlen(value))
            {
                if (!strcasecmp(name, "blksize"))
                {
                    MYDWORD tblksize = atol(value);

                    if (tblksize < 512)
                        blksize = 512;
                    else if (tblksize > USHRT_MAX - 32)
                        blksize = USHRT_MAX - 32;
                    else
                        blksize = tblksize;
                }
                else if (!strcasecmp(name, "threadpoolsize"))
                {
                    minThreads = atol(value);
                    if (minThreads < 1)
                        minThreads = 0;
                    else if (minThreads > 100)
                        minThreads = 100;
                }
                else if (!strcasecmp(name, "timeout"))
                {
                    timeout = atol(value);
                    if (timeout < 1)
                        timeout = 1;
                    else if (timeout > UCHAR_MAX)
                        timeout = UCHAR_MAX;
                }
                else if (!strcasecmp(name, "Read"))
                {
                    if (strchr("Yy", *value))
                        cfig.fileRead = true;
                    else
                        cfig.fileRead = false;
                }
                else if (!strcasecmp(name, "Write"))
                {
                    if (strchr("Yy", *value))
                        cfig.fileWrite = true;
                    else
                        cfig.fileWrite = false;
                }
                else if (!strcasecmp(name, "Overwrite"))
                {
                    if (strchr("Yy", *value))
                        cfig.fileOverwrite = true;
                    else
                        cfig.fileOverwrite = false;
                }
                else if (!strcasecmp(name, "port-range"))
                {
                    char *ptr = strchr(value, '-');
                    if (ptr)
                    {
                        *ptr = 0;
                        cfig.minport = atol(value);
                        cfig.maxport = atol(++ptr);

                        if (cfig.minport < 1024 || cfig.minport >= USHRT_MAX || cfig.maxport < 1024 || cfig.maxport >= USHRT_MAX || cfig.minport > cfig.maxport)
                        {
                            cfig.minport = 0;
                            cfig.maxport = 0;

                            sprintf(logBuff, "Invalid port range %s", value);
                            logMess(logBuff, 1);
                        }
                    }
                    else
                    {
                        sprintf(logBuff, "Invalid port range %s", value);
                        logMess(logBuff, 1);
                    }
                }
                else
                {
                    sprintf(logBuff, "Warning: unknown option %s, ignored", name);
                    logMess(logBuff, 1);
                }
            }
        }
    }

    if ((f = openSection("ALLOWED-CLIENTS", 1, iniFile)))
    {
#ifdef __REACTOS__
        MYWORD i = 0;
#else
        int i = 0;
#endif

        while (readSection(raw, f))
        {
#ifdef __REACTOS__
            if (i < _countof(cfig.hostRanges))
#else
            if (i < 32)
#endif
            {
                MYDWORD rs = 0;
                MYDWORD re = 0;
                mySplit(name, value, raw, '-');
                rs = htonl(my_inet_addr(name));

                if (strlen(value))
                    re = htonl(my_inet_addr(value));
                else
                    re = rs;

                if (rs && rs != INADDR_NONE && re && re != INADDR_NONE && rs <= re)
                {
                    cfig.hostRanges[i].rangeStart = rs;
                    cfig.hostRanges[i].rangeEnd = re;
                    i++;
                }
                else
                {
                    sprintf(logBuff, "Section [ALLOWED-CLIENTS] Invalid entry %s in ini file, ignored", raw);
                    logMess(logBuff, 1);
                }
            }
        }
    }

    if (verbatim)
    {
        printf("starting TFTP...\n");
    }
    else
    {
        sprintf(logBuff, "starting TFTP service");
        logMess(logBuff, 1);
    }

    for (int i = 0; i < MAX_SERVERS; i++)
        if (cfig.homes[i].target[0])
        {
            sprintf(logBuff, "alias /%s is mapped to %s", cfig.homes[i].alias, cfig.homes[i].target);
            logMess(logBuff, 1);
        }

    if (cfig.hostRanges[0].rangeStart)
    {
        char temp[128];

#ifdef __REACTOS__
        for (MYWORD i = 0; i < _countof(cfig.hostRanges) && cfig.hostRanges[i].rangeStart; i++)
#else
        for (MYWORD i = 0; i <= sizeof(cfig.hostRanges) && cfig.hostRanges[i].rangeStart; i++)
#endif
        {
            sprintf(logBuff, "%s", "permitted clients: ");
            sprintf(temp, "%s-", IP2String(tempbuff, htonl(cfig.hostRanges[i].rangeStart)));
            strcat(logBuff, temp);
            sprintf(temp, "%s", IP2String(tempbuff, htonl(cfig.hostRanges[i].rangeEnd)));
            strcat(logBuff, temp);
            logMess(logBuff, 1);
        }
    }
    else
    {
        sprintf(logBuff, "%s", "permitted clients: all");
        logMess(logBuff, 1);
    }

    if (cfig.minport)
    {
        sprintf(logBuff, "server port range: %u-%u", cfig.minport, cfig.maxport);
        logMess(logBuff, 1);
    }
    else
    {
        sprintf(logBuff, "server port range: all");
        logMess(logBuff, 1);
    }

    sprintf(logBuff, "max blksize: %u", blksize);
    logMess(logBuff, 1);
    sprintf(logBuff, "default blksize: %u", 512);
    logMess(logBuff, 1);
    sprintf(logBuff, "default timeout: %u", timeout);
    logMess(logBuff, 1);
    sprintf(logBuff, "file read allowed: %s", cfig.fileRead ? "Yes" : "No");
    logMess(logBuff, 1);
    sprintf(logBuff, "file create allowed: %s", cfig.fileWrite ? "Yes" : "No");
    logMess(logBuff, 1);
    sprintf(logBuff, "file overwrite allowed: %s", cfig.fileOverwrite ? "Yes" : "No");
    logMess(logBuff, 1);

    if (!verbatim)
    {
        sprintf(logBuff, "logging: %s", cfig.logLevel > 1 ? "all" : "errors");
        logMess(logBuff, 1);
    }

    lEvent = CreateEvent(
        NULL,                  // default security descriptor
        FALSE,                 // ManualReset
        TRUE,                  // Signalled
        TEXT("AchalTFTServerLogEvent"));  // object name

    if (lEvent == NULL)
    {
        printf("CreateEvent error: %lu\n", GetLastError());
        exit(-1);
    }
    else if ( GetLastError() == ERROR_ALREADY_EXISTS )
    {
        sprintf(logBuff, "CreateEvent opened an existing Event\nServer May already be Running");
        logMess(logBuff, 0);
        exit(-1);
    }

    tEvent = CreateEvent(
        NULL,                  // default security descriptor
        FALSE,                 // ManualReset
        FALSE,                 // Signalled
        TEXT("AchalTFTServerThreadEvent"));  // object name

    if (tEvent == NULL)
    {
        printf("CreateEvent error: %lu\n", GetLastError());
        exit(-1);
    }
    else if ( GetLastError() == ERROR_ALREADY_EXISTS )
    {
        sprintf(logBuff, "CreateEvent opened an existing Event\nServer May already be Running");
        logMess(logBuff, 0);
        exit(-1);
    }

    sEvent = CreateEvent(
        NULL,                  // default security descriptor
        FALSE,                 // ManualReset
        TRUE,                  // Signalled
        TEXT("AchalTFTServerSocketEvent"));  // object name

    if (sEvent == NULL)
    {
        printf("CreateEvent error: %lu\n", GetLastError());
        exit(-1);
    }
    else if ( GetLastError() == ERROR_ALREADY_EXISTS )
    {
        sprintf(logBuff, "CreateEvent opened an existing Event\nServer May already be Running");
        logMess(logBuff, 0);
        exit(-1);
    }

    cEvent = CreateEvent(
        NULL,                  // default security descriptor
        FALSE,                 // ManualReset
        TRUE,                  // Signalled
        TEXT("AchalTFTServerCountEvent"));  // object name

    if (cEvent == NULL)
    {
        printf("CreateEvent error: %lu\n", GetLastError());
        exit(-1);
    }
    else if ( GetLastError() == ERROR_ALREADY_EXISTS )
    {
        sprintf(logBuff, "CreateEvent opened an existing Event\nServer May already be Running");
        logMess(logBuff, 0);
        exit(-1);
    }

    if (minThreads)
    {
        for (int i = 0; i < minThreads; i++)
        {
            _beginthread(
                  processRequest,                 // thread function
                  0,                            // default security attributes
                  NULL);                          // argument to thread function
        }

        sprintf(logBuff, "thread pool size: %u", minThreads);
        logMess(logBuff, 1);
    }

    for (int i = 0; i < MAX_SERVERS && network.tftpConn[i].port; i++)
    {
        sprintf(logBuff, "listening on: %s:%i", IP2String(tempbuff, network.tftpConn[i].server), network.tftpConn[i].port);
        logMess(logBuff, 1);
    }

    do
    {
        memset(&newNetwork, 0, sizeof(data1));

        bool bindfailed = false;

        if ((f = openSection("LISTEN-ON", 1, iniFile)))
        {
            MYBYTE i = 0;

            while (readSection(raw, f))
            {
                MYWORD port = 69;

                cfig.ifspecified = true;
                mySplit(name, value, raw, ':');

                if (value[0])
                    port = atoi(value);

                if(i < MAX_SERVERS)
                {
                    if (isIP(name))
                    {
                        MYDWORD addr = my_inet_addr(name);

                        if (!addr)
                        {
                            newNetwork.listenServers[0] = 0;
                            newNetwork.listenPorts[0] = port;
                            fclose(f);
                            break;
                        }
                        else if (!findServer(newNetwork.listenServers, addr))
                        {
                            newNetwork.listenServers[i] = addr;
                            newNetwork.listenPorts[i] = port;
                            i++;
                        }
                    }
                    else
                    {
                        sprintf(logBuff, "Warning: Section [LISTEN-ON], Invalid Interface Address %s, ignored", raw);
                        logMess(logBuff, 1);
                    }
                }
            }
        }

        if (!cfig.ifspecified)
        {
            sprintf(logBuff, "detecting Interfaces..");
            logMess(logBuff, 1);
            getInterfaces(&newNetwork);

            for (MYBYTE n = 0; n < MAX_SERVERS && newNetwork.staticServers[n]; n++)
            {
                newNetwork.listenServers[n] = newNetwork.staticServers[n];
                newNetwork.listenPorts[n] = 69;
            }
        }

        MYBYTE i = 0;

        for (int j = 0; j < MAX_SERVERS && newNetwork.listenPorts[j]; j++)
        {
            int k = 0;

            for (; k < MAX_SERVERS && network.tftpConn[k].loaded; k++)
            {
                if (network.tftpConn[k].ready && network.tftpConn[k].server == newNetwork.listenServers[j] && network.tftpConn[k].port == newNetwork.listenPorts[j])
                    break;
            }

            if (network.tftpConn[k].ready && network.tftpConn[k].server == newNetwork.listenServers[j] && network.tftpConn[k].port == newNetwork.listenPorts[j])
            {
                memcpy(&(newNetwork.tftpConn[i]), &(network.tftpConn[k]), sizeof(tftpConnType));

                if (newNetwork.maxFD < newNetwork.tftpConn[i].sock)
                    newNetwork.maxFD = newNetwork.tftpConn[i].sock;

                network.tftpConn[k].ready = false;
                //printf("%d, %s found\n", i, IP2String(tempbuff, newNetwork.tftpConn[i].server));
                i++;
                continue;
            }
            else
            {
                newNetwork.tftpConn[i].sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

                if (newNetwork.tftpConn[i].sock == INVALID_SOCKET)
                {
                    bindfailed = true;
                    sprintf(logBuff, "Failed to Create Socket");
                    logMess(logBuff, 1);
                    continue;
                }

                //printf("Socket %u\n", newNetwork.tftpConn[i].sock);

                errno = 0;
                newNetwork.tftpConn[i].addr.sin_family = AF_INET;
                newNetwork.tftpConn[i].addr.sin_addr.s_addr = newNetwork.listenServers[j];
                newNetwork.tftpConn[i].addr.sin_port = htons(newNetwork.listenPorts[j]);
                int nRet = bind(newNetwork.tftpConn[i].sock, (sockaddr*)&newNetwork.tftpConn[i].addr, sizeof(struct sockaddr_in));

                if (nRet == SOCKET_ERROR || errno)
                {
                    bindfailed = true;
                    closesocket(newNetwork.tftpConn[i].sock);
                    sprintf(logBuff, "%s Port %i bind failed", IP2String(tempbuff, newNetwork.listenServers[j]), newNetwork.listenPorts[j]);
                    logMess(logBuff, 1);
                    continue;
                }

                newNetwork.tftpConn[i].loaded = true;
                newNetwork.tftpConn[i].ready = true;
                newNetwork.tftpConn[i].server = newNetwork.listenServers[j];
                newNetwork.tftpConn[i].port = newNetwork.listenPorts[j];

                //printf("%d, %s created\n", i, IP2String(tempbuff, newNetwork.tftpConn[i].server));

                if (newNetwork.maxFD < newNetwork.tftpConn[i].sock)
                    newNetwork.maxFD = newNetwork.tftpConn[i].sock;

                if (!newNetwork.listenServers[j])
                    break;

                i++;
            }
        }

        if (bindfailed)
            cfig.failureCount++;
        else
            cfig.failureCount = 0;

        closeConn();
        memcpy(&network, &newNetwork, sizeof(data1));

        //printf("%i %i %i\n", network.tftpConn[0].ready, network.dnsUdpConn[0].ready, network.dnsTcpConn[0].ready);

        if (!network.tftpConn[0].ready)
        {
            sprintf(logBuff, "No Static Interface ready, Waiting...");
            logMess(logBuff, 1);
            continue;
        }

        for (int i = 0; i < MAX_SERVERS && network.tftpConn[i].loaded; i++)
        {
            sprintf(logBuff, "Listening On: %s:%d", IP2String(tempbuff, network.tftpConn[i].server), network.tftpConn[i].port);
            logMess(logBuff, 1);
        }

        network.ready = true;

    } while (detectChange());

    //printf("Exiting Init\n");

    _endthread();
    return;
}

Referenced by runProg(), and ServiceMain().

installService()

void installService

(

)

Definition at line 256 of file tftpd.cpp.

{
    SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);

    if (serviceControlManager)
    {
        SC_HANDLE service = OpenService(serviceControlManager,
                                        serviceName, SERVICE_QUERY_STATUS);
        if (service)
        {
            printf("Service Already Exists..\n");
            StartService(service,0,NULL);
            CloseServiceHandle(service);
        }
        else
        {
            TCHAR path[ _MAX_PATH + 1 ];
            if (GetModuleFileName(0, path, sizeof(path) / sizeof(path[0])) > 0)
            {
                SC_HANDLE service = CreateService(serviceControlManager,
                                                  serviceName, displayName,
                                                  SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
                                                  SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, path,
                                                  0, 0, 0, 0, 0);
                if (service)
                {
                    printf("Successfully installed.. !\n");
                    StartService(service,0,NULL);
                    CloseServiceHandle(service);
                }
                else
                    printf("Installation Failed..\n");
            }
        }
        CloseServiceHandle(serviceControlManager);
    }
    else
        printWindowsError();
}

Referenced by main().

IP2String()

char* IP2String	(	char *	target,
		MYDWORD	ip
	)

Definition at line 1759 of file tftpd.cpp.

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

Referenced by init(), and logMess().

isIP()

bool isIP

(

char *

string

)

Definition at line 1767 of file tftpd.cpp.

{
    int j = 0;

    for (; *string; string++)
    {
        if (*string == '.' && *(string + 1) != '.')
            j++;
        else if (*string < '0' || *string > '9')
            return 0;
    }

    if (j == 3)
        return 1;
    else
        return 0;
}

Referenced by init().

logMess() [1/2]

void logMess	(	char *	logBuff,
		MYBYTE	logLevel
	)

Definition at line 2585 of file tftpd.cpp.

{
    WaitForSingleObject(lEvent, INFINITE);

    if (verbatim)
        printf("%s\n", logBuff);
    else if (cfig.logfile && logLevel <= cfig.logLevel)
    {
        time_t t = time(NULL);
        tm *ttm = localtime(&t);

        if (ttm->tm_yday != loggingDay)
        {
            loggingDay = ttm->tm_yday;
            strftime(extbuff, sizeof(extbuff), logFile, ttm);
            fprintf(cfig.logfile, "Logging Continued on file %s\n", extbuff);
            fclose(cfig.logfile);
            cfig.logfile = fopen(extbuff, "at");

            if (cfig.logfile)
            {
                fprintf(cfig.logfile, "%s\n\n", sVersion);
                WritePrivateProfileString("InternetShortcut","URL", extbuff, lnkFile);
                WritePrivateProfileString("InternetShortcut","IconIndex", "0", lnkFile);
                WritePrivateProfileString("InternetShortcut","IconFile", extbuff, lnkFile);
            }
            else
                return;
        }

        strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
        fprintf(cfig.logfile, "[%s] %s\n", extbuff, logBuff);
        fflush(cfig.logfile);
    }
    SetEvent(lEvent);
}

Referenced by detectChange(), init(), processRequest(), runProg(), and ServiceMain().

logMess() [2/2]

void logMess	(	request *	req,
		MYBYTE	logLevel
	)

Definition at line 2622 of file tftpd.cpp.

{
    WaitForSingleObject(lEvent, INFINITE);

    char tempbuff[256];

    if (verbatim)
    {
        if (!req->serverError.errormessage[0])
            sprintf(req->serverError.errormessage, strerror(errno));

        if (req->path[0])
            printf("Client %s:%u %s, %s\n", IP2String(tempbuff, req->client.sin_addr.s_addr), ntohs(req->client.sin_port), req->path, req->serverError.errormessage);
        else
            printf("Client %s:%u, %s\n", IP2String(tempbuff, req->client.sin_addr.s_addr), ntohs(req->client.sin_port), req->serverError.errormessage);
    }
    else if (cfig.logfile && logLevel <= cfig.logLevel)
    {
        time_t t = time(NULL);
        tm *ttm = localtime(&t);

        if (ttm->tm_yday != loggingDay)
        {
            loggingDay = ttm->tm_yday;
            strftime(extbuff, sizeof(extbuff), logFile, ttm);
            fprintf(cfig.logfile, "Logging Continued on file %s\n", extbuff);
            fclose(cfig.logfile);
            cfig.logfile = fopen(extbuff, "at");

            if (cfig.logfile)
            {
                fprintf(cfig.logfile, "%s\n\n", sVersion);
                WritePrivateProfileString("InternetShortcut","URL", extbuff, lnkFile);
                WritePrivateProfileString("InternetShortcut","IconIndex", "0", lnkFile);
                WritePrivateProfileString("InternetShortcut","IconFile", extbuff, lnkFile);
            }
            else
                return;
        }

        strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);

        if (req->path[0])
            fprintf(cfig.logfile, "[%s] Client %s:%u %s, %s\n", extbuff, IP2String(tempbuff, req->client.sin_addr.s_addr), ntohs(req->client.sin_port), req->path, req->serverError.errormessage);
        else
            fprintf(cfig.logfile, "[%s] Client %s:%u, %s\n", extbuff, IP2String(tempbuff, req->client.sin_addr.s_addr), ntohs(req->client.sin_port), req->serverError.errormessage);

        fflush(cfig.logfile);
    }
    SetEvent(lEvent);
}

main()

int main	(	int argc	,
		TCHAR *	argv[]
	)

Definition at line 346 of file tftpd.cpp.

{
    OSVERSIONINFO osvi;
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    bool result = GetVersionEx(&osvi);

    if (result && osvi.dwPlatformId >= VER_PLATFORM_WIN32_NT)
    {
        if (argc > 1 && lstrcmpi(argv[1], TEXT("-i")) == 0)
            installService();
        else if (argc > 1 && lstrcmpi(argv[1], TEXT("-u")) == 0)
            uninstallService();
        else if (argc > 1 && lstrcmpi(argv[1], TEXT("-v")) == 0)
        {
            SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);
            bool serviceStopped = true;

            if (serviceControlManager)
            {
                SC_HANDLE service = OpenService(serviceControlManager,
                                                serviceName, SERVICE_QUERY_STATUS | SERVICE_STOP);
                if (service)
                {
                    serviceStopped = stopService(service);
                    CloseServiceHandle(service);
                }
                CloseServiceHandle(serviceControlManager);
            }
            else
                printWindowsError();

            if (serviceStopped)
                runProg();
            else
                printf("Failed to Stop Service\n");
        }
        else
            runService();
    }
    else if (argc == 1 || lstrcmpi(argv[1], TEXT("-v")) == 0)
        runProg();
    else
        printf("This option is not available on Windows95/98/ME\n");

    return 0;
}

myGetToken()

char* myGetToken	(	char *	buff,
		MYBYTE	index
	)

Definition at line 1628 of file tftpd.cpp.

{
    while (*buff)
    {
        if (index)
            index--;
        else
            break;

        buff += strlen(buff) + 1;
    }

    return buff;
}

myLower()

char* myLower

(

char *

string

)

Definition at line 1795 of file tftpd.cpp.

{
    char diff = 'a' - 'A';
    MYWORD len = strlen(string);
    for (int i = 0; i < len; i++)
        if (string[i] >= 'A' && string[i] <= 'Z')
            string[i] += diff;
    return string;
}

mySplit()

void mySplit	(	char *	name,
		char *	value,
		char *	source,
		char	splitChar
	)

Definition at line 1730 of file tftpd.cpp.

{
    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);
}

Referenced by init().

myTokenize()

MYWORD myTokenize	(	char *	target,
		char *	source,
		char *	sep,
		bool	whiteSep
	)

Definition at line 1643 of file tftpd.cpp.

{
    bool found = true;
    char *dp = target;
    MYWORD 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;
}

myTrim()

char* myTrim	(	char *	target,
		char *	source
	)

Definition at line 1689 of file tftpd.cpp.

{
    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;
}

Referenced by getSection(), mySplit(), openSection(), and readSection().

myUpper()

char* myUpper

(

char *

string

)

Definition at line 1785 of file tftpd.cpp.

{
    char diff = 'a' - 'A';
    MYWORD len = strlen(string);
    for (int i = 0; i < len; i++)
        if (string[i] >= 'a' && string[i] <= 'z')
            string[i] -= diff;
    return string;
}

Referenced by getSection(), and openSection().

openSection()

FILE* openSection	(	const char *	sectionName,
		MYBYTE	serial,
		char *	fileName
	)

Definition at line 1581 of file tftpd.cpp.

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

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

            if (strstr(buff, section) == buff)
            {
                found++;

                if (found == serial)
                    return f;
            }
        }
        fclose(f);
    }
    return NULL;
}

Referenced by init().

printWindowsError()

void printWindowsError

(

)

Definition at line 323 of file tftpd.cpp.

{
    MYDWORD dw = GetLastError();

    if (dw)
    {
        LPVOID lpMsgBuf;

        FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER |
            FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            dw,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR) &lpMsgBuf,
            0, NULL );

        printf("Error: %s\nPress Enter..\n", (LPTSTR)lpMsgBuf);
        getchar();
    }
}

Referenced by installService(), main(), and uninstallService().

processRequest()

void processRequest

(

void *

lpParam

)

Definition at line 488 of file tftpd.cpp.

{
    //printf("New Thread %u\n",GetCurrentThreadId());

    request req;

    WaitForSingleObject(cEvent, INFINITE);
    totalThreads++;
    SetEvent(cEvent);

    do
    {
        WaitForSingleObject(tEvent, INFINITE);
        //printf("In Thread %u\n",GetCurrentThreadId());

        WaitForSingleObject(cEvent, INFINITE);
        activeThreads++;
        SetEvent(cEvent);

        if (currentServer >= MAX_SERVERS || !network.tftpConn[currentServer].port)
        {
            SetEvent(sEvent);
            req.attempt = UCHAR_MAX;
            continue;
        }

        memset(&req, 0, sizeof(request));
        req.sock = INVALID_SOCKET;

        req.clientsize = sizeof(req.client);
        req.sockInd = currentServer;
        currentServer = UCHAR_MAX;
        req.knock = network.tftpConn[req.sockInd].sock;

        if (req.knock == INVALID_SOCKET)
        {
            SetEvent(sEvent);
            req.attempt = UCHAR_MAX;
            continue;
        }

        errno = 0;
        req.bytesRecd = recvfrom(req.knock, (char*)&req.mesin, sizeof(message), 0, (sockaddr*)&req.client, &req.clientsize);
        errno = WSAGetLastError();

        //printf("socket Signalled=%u\n",SetEvent(sEvent));
        SetEvent(sEvent);

        if (!errno && req.bytesRecd > 0)
        {
            if (cfig.hostRanges[0].rangeStart)
            {
                MYDWORD iip = ntohl(req.client.sin_addr.s_addr);
                bool allowed = false;

#ifdef __REACTOS__
                for (MYWORD j = 0; j < _countof(cfig.hostRanges) && cfig.hostRanges[j].rangeStart; j++)
#else
                for (int j = 0; j <= 32 && cfig.hostRanges[j].rangeStart; j++)
#endif
                {
                    if (iip >= cfig.hostRanges[j].rangeStart && iip <= cfig.hostRanges[j].rangeEnd)
                    {
                        allowed = true;
                        break;
                    }
                }

                if (!allowed)
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(2);
                    strcpy(req.serverError.errormessage, "Access Denied");
                    logMess(&req, 1);
                    sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
                    req.attempt = UCHAR_MAX;
                    continue;
                }
            }

            if ((htons(req.mesin.opcode) == 5))
            {
                sprintf(req.serverError.errormessage, "Error Code %i at Client, %s", ntohs(req.clientError.errorcode), req.clientError.errormessage);
                logMess(&req, 2);
                req.attempt = UCHAR_MAX;
                continue;
            }
            else if (htons(req.mesin.opcode) != 1 && htons(req.mesin.opcode) != 2)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(5);
                sprintf(req.serverError.errormessage, "Unknown Transfer Id");
                logMess(&req, 2);
                sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
                req.attempt = UCHAR_MAX;
                continue;
            }
        }
        else
        {
            sprintf(req.serverError.errormessage, "Communication Error");
            logMess(&req, 1);
            req.attempt = UCHAR_MAX;
            continue;
        }

        req.blksize = 512;
        req.timeout = timeout;
        req.expiry = time(NULL) + req.timeout;
        bool fetchAck = false;

        req.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

        if (req.sock == INVALID_SOCKET)
        {
            req.serverError.opcode = htons(5);
            req.serverError.errorcode = htons(0);
            strcpy(req.serverError.errormessage, "Thread Socket Creation Error");
            sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
            logMess(&req, 1);
            req.attempt = UCHAR_MAX;
            continue;
        }

        sockaddr_in service;
        service.sin_family = AF_INET;
        service.sin_addr.s_addr = network.tftpConn[req.sockInd].server;

        if (cfig.minport)
        {
            for (MYWORD comport = cfig.minport; ; comport++)
            {
                service.sin_port = htons(comport);

                if (comport > cfig.maxport)
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(0);
                    strcpy(req.serverError.errormessage, "No port is free");
                    sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
                    logMess(&req, 1);
                    req.attempt = UCHAR_MAX;
                    break;
                }
                else if (bind(req.sock, (sockaddr*) &service, sizeof(service)) == -1)
                    continue;
                else
                    break;
            }
        }
        else
        {
            service.sin_port = 0;

            if (bind(req.sock, (sockaddr*) &service, sizeof(service)) == -1)
            {
                strcpy(req.serverError.errormessage, "Thread failed to bind");
                sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
            }
        }

        if (req.attempt >= 3)
            continue;

        if (connect(req.sock, (sockaddr*)&req.client, req.clientsize) == -1)
        {
            req.serverError.opcode = htons(5);
            req.serverError.errorcode = htons(0);
            strcpy(req.serverError.errormessage, "Connect Failed");
            sendto(req.knock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0, (sockaddr*)&req.client, req.clientsize);
            logMess(&req, 1);
            req.attempt = UCHAR_MAX;
            continue;
        }

        //sprintf(req.serverError.errormessage, "In Temp, Socket");
        //logMess(&req, 1);

        char *inPtr = req.mesin.buffer;
        *(inPtr + (req.bytesRecd - 3)) = 0;
        req.filename = inPtr;

        if (!strlen(req.filename) || strlen(req.filename) > UCHAR_MAX)
        {
            req.serverError.opcode = htons(5);
            req.serverError.errorcode = htons(4);
            strcpy(req.serverError.errormessage, "Malformed Request, Invalid/Missing Filename");
            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
            req.attempt = UCHAR_MAX;
            logMess(&req, 1);
            continue;
        }

        inPtr += strlen(inPtr) + 1;
        req.mode = inPtr;

        if (!strlen(req.mode) || strlen(req.mode) > 25)
        {
            req.serverError.opcode = htons(5);
            req.serverError.errorcode = htons(4);
            strcpy(req.serverError.errormessage, "Malformed Request, Invalid/Missing Mode");
            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
            req.attempt = UCHAR_MAX;
            logMess(&req, 1);
            continue;
        }

        inPtr += strlen(inPtr) + 1;

        for (MYDWORD i = 0; i < strlen(req.filename); i++)
            if (req.filename[i] == notFileSep)
                req.filename[i] = fileSep;

        tempbuff[0] = '.';
        tempbuff[1] = '.';
        tempbuff[2] = fileSep;
        tempbuff[3] = 0;

        if (strstr(req.filename, tempbuff))
        {
            req.serverError.opcode = htons(5);
            req.serverError.errorcode = htons(2);
            strcpy(req.serverError.errormessage, "Access violation");
            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
            logMess(&req, 1);
            req.attempt = UCHAR_MAX;
            continue;
        }

        if (req.filename[0] == fileSep)
            req.filename++;

        if (!cfig.homes[0].alias[0])
        {
            if (strlen(cfig.homes[0].target) + strlen(req.filename) >= sizeof(req.path))
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(4);
                sprintf(req.serverError.errormessage, "Filename too large");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            strcpy(req.path, cfig.homes[0].target);
            strcat(req.path, req.filename);
        }
        else
        {
            char *bname = strchr(req.filename, fileSep);

            if (bname)
            {
                *bname = 0;
                bname++;
            }
            else
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                sprintf(req.serverError.errormessage, "Missing directory/alias");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

#ifdef __REACTOS__
            for (int i = 0; i < MAX_SERVERS; i++)
#else
            for (int i = 0; i < 8; i++)
#endif
            {
                //printf("%s=%i\n", req.filename, cfig.homes[i].alias[0]);
                if (cfig.homes[i].alias[0] && !strcasecmp(req.filename, cfig.homes[i].alias))
                {
                    if (strlen(cfig.homes[i].target) + strlen(bname) >= sizeof(req.path))
                    {
                        req.serverError.opcode = htons(5);
                        req.serverError.errorcode = htons(4);
                        sprintf(req.serverError.errormessage, "Filename too large");
                        send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }

                    strcpy(req.path, cfig.homes[i].target);
                    strcat(req.path, bname);
                    break;
                }
                else if (i == 7 || !cfig.homes[i].alias[0])
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(2);
                    sprintf(req.serverError.errormessage, "No such directory/alias %s", req.filename);
                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                    logMess(&req, 1);
                    req.attempt = UCHAR_MAX;
                    break;
                }
            }
        }

        if (req.attempt >= 3)
            continue;

        if (ntohs(req.mesin.opcode) == 1)
        {
            if (!cfig.fileRead)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "GET Access Denied");
                logMess(&req, 1);
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                req.attempt = UCHAR_MAX;
                continue;
            }

            if (*inPtr)
            {
                char *tmp = inPtr;

                while (*tmp)
                {
                    if (!strcasecmp(tmp, "blksize"))
                    {
                        tmp += strlen(tmp) + 1;
                        MYDWORD val = atol(tmp);

                        if (val < 512)
                            val = 512;
                        else if (val > blksize)
                            val = blksize;

                        req.blksize = val;
                        break;
                    }

                    tmp += strlen(tmp) + 1;
                }
            }

            errno = 0;

            if (!strcasecmp(req.mode, "netascii") || !strcasecmp(req.mode, "ascii"))
                req.file = fopen(req.path, "rt");
            else
                req.file = fopen(req.path, "rb");

            if (errno || !req.file)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(1);
                strcpy(req.serverError.errormessage, "File not found or No Access");
                logMess(&req, 1);
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                req.attempt = UCHAR_MAX;
                continue;
            }
        }
        else
        {
            if (!cfig.fileWrite && !cfig.fileOverwrite)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "PUT Access Denied");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            req.file = fopen(req.path, "rb");

            if (req.file)
            {
                fclose(req.file);
                req.file = NULL;

                if (!cfig.fileOverwrite)
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(6);
                    strcpy(req.serverError.errormessage, "File already exists");
                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                    logMess(&req, 1);
                    req.attempt = UCHAR_MAX;
                    continue;
                }
            }
            else if (!cfig.fileWrite)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "Create File Access Denied");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            errno = 0;

            if (!strcasecmp(req.mode, "netascii") || !strcasecmp(req.mode, "ascii"))
                req.file = fopen(req.path, "wt");
            else
                req.file = fopen(req.path, "wb");

            if (errno || !req.file)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "Invalid Path or No Access");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }
        }

        setvbuf(req.file, NULL, _IOFBF, 5 * req.blksize);

        if (*inPtr)
        {
            fetchAck = true;
            char *outPtr = req.mesout.buffer;
            req.mesout.opcode = htons(6);
            MYDWORD val;
            while (*inPtr)
            {
                //printf("%s\n", inPtr);
                if (!strcasecmp(inPtr, "blksize"))
                {
                    strcpy(outPtr, inPtr);
                    outPtr += strlen(outPtr) + 1;
                    inPtr += strlen(inPtr) + 1;
                    val = atol(inPtr);

                    if (val < 512)
                        val = 512;
                    else if (val > blksize)
                        val = blksize;

                    req.blksize = val;
                    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 (ntohs(req.mesin.opcode) == 1)
                    {
                        if (!fseek(req.file, 0, SEEK_END))
                        {
                            if (ftell(req.file) >= 0)
                            {
                                req.tsize = ftell(req.file);
                                sprintf(outPtr, "%u", req.tsize);
                                outPtr += strlen(outPtr) + 1;
                            }
                            else
                            {
                                req.serverError.opcode = htons(5);
                                req.serverError.errorcode = htons(2);
                                strcpy(req.serverError.errormessage, "Invalid Path or No Access");
                                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                                logMess(&req, 1);
                                req.attempt = UCHAR_MAX;
                                break;
                            }
                        }
                        else
                        {
                            req.serverError.opcode = htons(5);
                            req.serverError.errorcode = htons(2);
                            strcpy(req.serverError.errormessage, "Invalid Path or No Access");
                            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                            logMess(&req, 1);
                            req.attempt = UCHAR_MAX;
                            break;
                        }
                    }
                    else
                    {
                        req.tsize = 0;
                        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 > UCHAR_MAX)
                        val = UCHAR_MAX;

                    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);
            }

            if (req.attempt >= 3)
                continue;

            errno = 0;
            req.bytesReady = (const char*)outPtr - (const char*)&req.mesout;
            //printf("Bytes Ready=%u\n", req.bytesReady);
            send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
            errno = WSAGetLastError();
        }
        else if (htons(req.mesin.opcode) == 2)
        {
            req.acout.opcode = htons(4);
            req.acout.block = htons(0);
            errno = 0;
            req.bytesReady = 4;
            send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
            errno = WSAGetLastError();
        }

        if (errno)
        {
            sprintf(req.serverError.errormessage, "Communication Error");
            logMess(&req, 1);
            req.attempt = UCHAR_MAX;
            continue;
        }
        else if (ntohs(req.mesin.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])
            {
                sprintf(req.serverError.errormessage, "Memory Error");
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            long ftellLoc = ftell(req.file);

            if (ftellLoc > 0)
            {
                if (fseek(req.file, 0, SEEK_SET))
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(2);
                    strcpy(req.serverError.errormessage, "File Access Error");
                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                    logMess(&req, 1);
                    req.attempt = UCHAR_MAX;
                    continue;
                }
            }
            else if (ftellLoc < 0)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "File Access Error");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            errno = 0;
            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(2);
                strcpy(req.serverError.errormessage, "Invalid Path or No Access");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            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 (req.bytesRead[1] < req.blksize)
                {
                    fclose(req.file);
                    req.file = 0;
                }
            }
            else
            {
                fclose(req.file);
                req.file = 0;
            }

            if (errno)
            {
                req.serverError.opcode = htons(5);
                req.serverError.errorcode = htons(2);
                strcpy(req.serverError.errormessage, "Invalid Path or No Access");
                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            while (req.attempt <= 3)
            {
                if (fetchAck)
                {
                    FD_ZERO(&req.readfds);
                    req.tv.tv_sec = 1;
                    req.tv.tv_usec = 0;
                    FD_SET(req.sock, &req.readfds);
                    select(req.sock + 1, &req.readfds, NULL, NULL, &req.tv);

                    if (FD_ISSET(req.sock, &req.readfds))
                    {
                        errno = 0;
                        req.bytesRecd = recv(req.sock, (char*)&req.mesin, sizeof(message), 0);
                        errno = WSAGetLastError();
                        if (req.bytesRecd <= 0 || errno)
                        {
                            sprintf(req.serverError.errormessage, "Communication Error");
                            logMess(&req, 1);
                            req.attempt = UCHAR_MAX;
                            break;
                        }
                        else if(req.bytesRecd >= 4 && ntohs(req.mesin.opcode) == 4)
                        {
                            if (ntohs(req.acin.block) == req.block)
                            {
                                req.block++;
                                req.fblock++;
                                req.attempt = 0;
                            }
                            else if (req.expiry > time(NULL))
                                continue;
                            else
                                req.attempt++;
                        }
                        else if (ntohs(req.mesin.opcode) == 5)
                        {
                            sprintf(req.serverError.errormessage, "Client %s:%u, Error Code %i at Client, %s", inet_ntoa(req.client.sin_addr), ntohs(req.client.sin_port), ntohs(req.clientError.errorcode), req.clientError.errormessage);
                            logMess(&req, 1);
                            req.attempt = UCHAR_MAX;
                            break;
                        }
                        else
                        {
                            req.serverError.opcode = htons(5);
                            req.serverError.errorcode = htons(4);
                            sprintf(req.serverError.errormessage, "Unexpected Option Code %i", ntohs(req.mesin.opcode));
                            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                            logMess(&req, 1);
                            req.attempt = UCHAR_MAX;
                            break;
                        }
                    }
                    else if (req.expiry > time(NULL))
                        continue;
                    else
                        req.attempt++;
                }
                else
                {
                    fetchAck = true;
                    req.acin.block = 1;
                    req.block = 1;
                    req.fblock = 1;
                }

                if (req.attempt >= 3)
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(0);

                    if (req.fblock && !req.block)
                        strcpy(req.serverError.errormessage, "Large File, Block# Rollover not supported by Client");
                    else
                        strcpy(req.serverError.errormessage, "Timeout");

                    logMess(&req, 1);
                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                    req.attempt = UCHAR_MAX;
                    break;
                }
                else if (!req.fblock)
                {
                    errno = 0;
                    send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
                    errno = WSAGetLastError();
                    if (errno)
                    {
                        sprintf(req.serverError.errormessage, "Communication Error");
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                    req.expiry = time(NULL) + req.timeout;
                }
                else if (ntohs(req.pkt[0]->block) == req.block)
                {
                    errno = 0;
                    send(req.sock, (const char*)req.pkt[0], req.bytesRead[0] + 4, 0);
                    errno = WSAGetLastError();
                    if (errno)
                    {
                        sprintf(req.serverError.errormessage, "Communication Error");
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                    req.expiry = time(NULL) + req.timeout;

                    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(4);
                                sprintf(req.serverError.errormessage, strerror(errno));
                                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                                logMess(&req, 1);
                                req.attempt = UCHAR_MAX;
                                break;
                            }
                            else if (req.bytesRead[1] < req.blksize)
                            {
                                fclose(req.file);
                                req.file = 0;
                            }
                        }
                    }
                }
                else if (ntohs(req.pkt[1]->block) == req.block)
                {
                    errno = 0;
                    send(req.sock, (const char*)req.pkt[1], req.bytesRead[1] + 4, 0);
                    errno = WSAGetLastError();
                    if (errno)
                    {
                        sprintf(req.serverError.errormessage, "Communication Error");
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }

                    req.expiry = time(NULL) + req.timeout;

                    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(4);
                                sprintf(req.serverError.errormessage, strerror(errno));
                                send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                                logMess(&req, 1);
                                req.attempt = UCHAR_MAX;
                                break;
                            }
                            else if (req.bytesRead[0] < req.blksize)
                            {
                                fclose(req.file);
                                req.file = 0;
                            }
                        }
                    }
                }
                else
                {
                    sprintf(req.serverError.errormessage, "%u Blocks Served", req.fblock - 1);
                    logMess(&req, 2);
                    req.attempt = UCHAR_MAX;
                    break;
                }
            }
        }
        else if (ntohs(req.mesin.opcode) == 2)
        {
            errno = 0;
            req.pkt[0] = (packet*)calloc(1, req.blksize + 4);

            if (errno || !req.pkt[0])
            {
                sprintf(req.serverError.errormessage, "Memory Error");
                logMess(&req, 1);
                req.attempt = UCHAR_MAX;
                continue;
            }

            while (req.attempt <= 3)
            {
                FD_ZERO(&req.readfds);
                req.tv.tv_sec = 1;
                req.tv.tv_usec = 0;
                FD_SET(req.sock, &req.readfds);
                select(req.sock + 1, &req.readfds, NULL, NULL, &req.tv);

                if (FD_ISSET(req.sock, &req.readfds))
                {
                    errno = 0;
                    req.bytesRecd = recv(req.sock, (char*)req.pkt[0], req.blksize + 4, 0);
                    errno = WSAGetLastError();

                    if (errno)
                    {
                        sprintf(req.serverError.errormessage, "Communication Error");
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                }
                else
                    req.bytesRecd = 0;

                if (req.bytesRecd >= 4)
                {
                    if (ntohs(req.pkt[0]->opcode) == 3)
                    {
                        req.tblock = req.block + 1;

                        if (ntohs(req.pkt[0]->block) == req.tblock)
                        {
                            req.acout.opcode = htons(4);
                            req.acout.block = req.pkt[0]->block;
                            req.block++;
                            req.fblock++;
                            req.bytesReady = 4;
                            req.expiry = time(NULL) + req.timeout;

                            errno = 0;
                            send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
                            errno = WSAGetLastError();

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

                            if (req.bytesRecd > 4)
                            {
                                errno = 0;
                                if (fwrite(&req.pkt[0]->buffer, req.bytesRecd - 4, 1, req.file) != 1 || errno)
                                {
                                    req.serverError.opcode = htons(5);
                                    req.serverError.errorcode = htons(3);
                                    strcpy(req.serverError.errormessage, "Disk full or allocation exceeded");
                                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                                    logMess(&req, 1);
                                    req.attempt = UCHAR_MAX;
                                    break;
                                }
                                else
                                    req.attempt = 0;
                            }
                            else
                                req.attempt = 0;

                            if ((MYWORD)req.bytesRecd < req.blksize + 4)
                            {
                                fclose(req.file);
                                req.file = 0;
                                sprintf(req.serverError.errormessage, "%u Blocks Received", req.fblock);
                                logMess(&req, 2);
                                req.attempt = UCHAR_MAX;
                                break;
                            }
                        }
                        else if (req.expiry > time(NULL))
                            continue;
                        else if (req.attempt >= 3)
                        {
                            req.serverError.opcode = htons(5);
                            req.serverError.errorcode = htons(0);

                            if (req.fblock && !req.block)
                                strcpy(req.serverError.errormessage, "Large File, Block# Rollover not supported by Client");
                            else
                                strcpy(req.serverError.errormessage, "Timeout");

                            logMess(&req, 1);
                            send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                            req.attempt = UCHAR_MAX;
                            break;
                        }
                        else
                        {
                            req.expiry = time(NULL) + req.timeout;
                            errno = 0;
                            send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
                            errno = WSAGetLastError();
                            req.attempt++;

                            if (errno)
                            {
                                sprintf(req.serverError.errormessage, "Communication Error");
                                logMess(&req, 1);
                                req.attempt = UCHAR_MAX;
                                break;
                            }
                        }
                    }
                    else if (req.bytesRecd > (int)sizeof(message))
                    {
                        req.serverError.opcode = htons(5);
                        req.serverError.errorcode = htons(4);
                        sprintf(req.serverError.errormessage, "Error: Incoming Packet too large");
                        send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                    else if (ntohs(req.pkt[0]->opcode) == 5)
                    {
                        sprintf(req.serverError.errormessage, "Error Code %i at Client, %s", ntohs(req.pkt[0]->block), &req.pkt[0]->buffer);
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                    else
                    {
                        req.serverError.opcode = htons(5);
                        req.serverError.errorcode = htons(4);
                        sprintf(req.serverError.errormessage, "Unexpected Option Code %i", ntohs(req.pkt[0]->opcode));
                        send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                }
                else if (req.expiry > time(NULL))
                    continue;
                else if (req.attempt >= 3)
                {
                    req.serverError.opcode = htons(5);
                    req.serverError.errorcode = htons(0);

                    if (req.fblock && !req.block)
                        strcpy(req.serverError.errormessage, "Large File, Block# Rollover not supported by Client");
                    else
                        strcpy(req.serverError.errormessage, "Timeout");

                    logMess(&req, 1);
                    send(req.sock, (const char*)&req.serverError, strlen(req.serverError.errormessage) + 5, 0);
                    req.attempt = UCHAR_MAX;
                    break;
                }
                else
                {
                    req.expiry = time(NULL) + req.timeout;
                    errno = 0;
                    send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
                    errno = WSAGetLastError();
                    req.attempt++;

                    if (errno)
                    {
                        sprintf(req.serverError.errormessage, "Communication Error");
                        logMess(&req, 1);
                        req.attempt = UCHAR_MAX;
                        break;
                    }
                }
            }
        }
    }
    while (cleanReq(&req));

    WaitForSingleObject(cEvent, INFINITE);
    totalThreads--;
    SetEvent(cEvent);

    //printf("Thread %u Killed\n",GetCurrentThreadId());
    _endthread();
    return;
}

Referenced by init(), runProg(), and ServiceMain().

readSection()

char* readSection	(	char *	buff,
		FILE *	f
	)

Definition at line 1611 of file tftpd.cpp.

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

        if (*buff == '[')
            break;

        if (((*buff) >= '0' && (*buff) <= '9') || ((*buff) >= 'A' && (*buff) <= 'Z') || ((*buff) >= 'a' && (*buff) <= 'z') || ((*buff) && strchr("/\\?*", (*buff))))
            return buff;
    }

    fclose(f);
    return NULL;
}

Referenced by init().

runProg()

void runProg

(

)

Definition at line 393 of file tftpd.cpp.

{
    verbatim = true;

    if (_beginthread(init, 0, 0) == 0)
    {
        if (cfig.logLevel)
        {
            sprintf(logBuff, "Thread Creation Failed");
            logMess(logBuff, 1);
        }
        exit(-1);
    }

    fd_set readfds;
    timeval tv;
    int fdsReady = 0;
    tv.tv_sec = 20;
    tv.tv_usec = 0;

    printf("\naccepting requests..\n");

    do
    {
        network.busy = false;

        //printf("Active=%u Total=%u\n",activeThreads, totalThreads);

        if (!network.tftpConn[0].ready || !network.ready)
        {
            Sleep(1000);
            continue;
        }

        FD_ZERO(&readfds);

        for (int i = 0; i < MAX_SERVERS && network.tftpConn[i].ready; i++)
            FD_SET(network.tftpConn[i].sock, &readfds);

        fdsReady = select(network.maxFD, &readfds, NULL, NULL, &tv);

        if (!network.ready)
            continue;

        //errno = WSAGetLastError();

        //if (errno)
        //    printf("%d\n", errno);

        for (int i = 0; fdsReady > 0 && i < MAX_SERVERS && network.tftpConn[i].ready; i++)
        {
            if (network.ready)
            {
                network.busy = true;

                if (FD_ISSET(network.tftpConn[i].sock, &readfds))
                {
                    //printf("%d Requests Waiting\n", fdsReady);

                    WaitForSingleObject(sEvent, INFINITE);

                    currentServer = i;

                    if (!totalThreads || activeThreads >= totalThreads)
                    {
                        _beginthread(
                              processRequest,                 // thread function
                              0,                            // default security attributes
                              NULL);                          // argument to thread function
                    }
                    SetEvent(tEvent);

                    //printf("thread signalled=%u\n",SetEvent(tEvent));

                    WaitForSingleObject(sEvent, INFINITE);
                    fdsReady--;
                    SetEvent(sEvent);
                }
            }
        }
    }
    while (true);

    closeConn();

    WSACleanup();
}

Referenced by main().

runService()

void runService

(

)

Definition at line 214 of file tftpd.cpp.

{
    SERVICE_TABLE_ENTRY serviceTable[] =
        {
            {serviceName, ServiceMain},
            {0, 0}
        };

    StartServiceCtrlDispatcher(serviceTable);
}

Referenced by main().

ServiceControlHandler()

void WINAPI ServiceControlHandler

(

DWORD

controlCode

)

Definition at line 67 of file tftpd.cpp.

{
    switch (controlCode)
    {
        case SERVICE_CONTROL_INTERROGATE:
            break;

        case SERVICE_CONTROL_SHUTDOWN:
        case SERVICE_CONTROL_STOP:
            serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
            SetServiceStatus(serviceStatusHandle, &serviceStatus);

            SetEvent(stopServiceEvent);
            return ;

        case SERVICE_CONTROL_PAUSE:
            break;

        case SERVICE_CONTROL_CONTINUE:
            break;

        default:
            if (controlCode >= 128 && controlCode <= 255)
                break;
            else
                break;
    }

    SetServiceStatus(serviceStatusHandle, &serviceStatus);
}

Referenced by ServiceMain().

ServiceMain()

void WINAPI ServiceMain	(	DWORD	,
		TCHAR *	[]
	)

Definition at line 98 of file tftpd.cpp.

{
    serviceStatus.dwServiceType = SERVICE_WIN32;
    serviceStatus.dwCurrentState = SERVICE_STOPPED;
    serviceStatus.dwControlsAccepted = 0;
    serviceStatus.dwWin32ExitCode = NO_ERROR;
    serviceStatus.dwServiceSpecificExitCode = NO_ERROR;
    serviceStatus.dwCheckPoint = 0;
    serviceStatus.dwWaitHint = 0;

    serviceStatusHandle = RegisterServiceCtrlHandler(serviceName, ServiceControlHandler);

    if (serviceStatusHandle)
    {
        serviceStatus.dwCurrentState = SERVICE_START_PENDING;
        SetServiceStatus(serviceStatusHandle, &serviceStatus);

        //init
        verbatim = false;

        if (_beginthread(init, 0, 0) == 0)
        {
            if (cfig.logLevel)
            {
                sprintf(logBuff, "Thread Creation Failed");
                logMess(logBuff, 1);
            }
            exit(-1);
        }

        fd_set readfds;
        timeval tv;
        tv.tv_sec = 20;
        tv.tv_usec = 0;

        stopServiceEvent = CreateEvent(0, FALSE, FALSE, 0);

        serviceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
        serviceStatus.dwCurrentState = SERVICE_RUNNING;
        SetServiceStatus(serviceStatusHandle, &serviceStatus);

        do
        {
            network.busy = false;

            if (!network.tftpConn[0].ready || !network.ready)
            {
                Sleep(1000);
                continue;
            }

            FD_ZERO(&readfds);

            for (int i = 0; i < MAX_SERVERS && network.tftpConn[i].ready; i++)
                FD_SET(network.tftpConn[i].sock, &readfds);

            int fdsReady = select(network.maxFD, &readfds, NULL, NULL, &tv);

            for (int i = 0; fdsReady > 0 && i < MAX_SERVERS && network.tftpConn[i].ready; i++)
            {
                if (network.ready)
                {
                    network.busy = true;

                    if (FD_ISSET(network.tftpConn[i].sock, &readfds))
                    {
                        WaitForSingleObject(sEvent, INFINITE);

                        currentServer = i;

                        if (!totalThreads || activeThreads >= totalThreads)
                        {
                            _beginthread(
                                  processRequest,                 // thread function
                                  0,                            // default security attributes
                                  NULL);                          // argument to thread function

                        }

                        SetEvent(tEvent);
                        WaitForSingleObject(sEvent, INFINITE);
                        fdsReady--;
                        SetEvent(sEvent);
                    }
                }
            }
        }
        while (WaitForSingleObject(stopServiceEvent, 0) == WAIT_TIMEOUT);

        serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
        SetServiceStatus(serviceStatusHandle, &serviceStatus);

        sprintf(logBuff, "Closing Network Connections...");
        logMess(logBuff, 1);

        closeConn();

        WSACleanup();

        sprintf(logBuff, "TFTP Server Stopped !\n");
        logMess(logBuff, 1);

        if (cfig.logfile)
        {
            fclose(cfig.logfile);
            cfig.logfile = NULL;
        }

        serviceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
        serviceStatus.dwCurrentState = SERVICE_STOPPED;
        SetServiceStatus(serviceStatusHandle, &serviceStatus);
        CloseHandle(stopServiceEvent);
        stopServiceEvent = 0;
    }
}

Referenced by runService().

stopService()

bool stopService

(

SC_HANDLE

service

)

Definition at line 225 of file tftpd.cpp.

{
    if (service)
    {
        SERVICE_STATUS serviceStatus;
        QueryServiceStatus(service, &serviceStatus);
        if (serviceStatus.dwCurrentState != SERVICE_STOPPED)
        {
            ControlService(service, SERVICE_CONTROL_STOP, &serviceStatus);
            printf("Stopping Service.");
            for (int i = 0; i < 100; i++)
            {
                QueryServiceStatus(service, &serviceStatus);
                if (serviceStatus.dwCurrentState == SERVICE_STOPPED)
                {
                    printf("Stopped\n");
                    return true;
                }
                else
                {
                    Sleep(500);
                    printf(".");
                }
            }
            printf("Failed\n");
            return false;
        }
    }
    return true;
}

Referenced by main(), and uninstallService().

uninstallService()

void uninstallService

(

)

Definition at line 296 of file tftpd.cpp.

{
    SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

    if (serviceControlManager)
    {
        SC_HANDLE service = OpenService(serviceControlManager,
                                        serviceName, SERVICE_QUERY_STATUS | SERVICE_STOP | DELETE);
        if (service)
        {
            if (stopService(service))
            {
                DeleteService(service);
                printf("Successfully Removed !\n");
            }
            else
                printf("Failed to Stop Service..\n");

            CloseServiceHandle(service);
        }

        CloseServiceHandle(serviceControlManager);
    }
    else
        printWindowsError();
}

Referenced by main().

Variable Documentation

activeThreads

MYWORD activeThreads =0

Definition at line 60 of file tftpd.cpp.

Referenced by cleanReq(), processRequest(), runProg(), and ServiceMain().

blksize

MYWORD blksize = 65464

Definition at line 45 of file tftpd.cpp.

Referenced by init(), and processRequest().

cEvent

HANDLE cEvent

Definition at line 54 of file tftpd.cpp.

Referenced by cleanReq(), init(), and processRequest().

cfig

data2 cfig

Definition at line 51 of file tftpd.cpp.

Referenced by detectChange(), init(), logMess(), processRequest(), runProg(), and ServiceMain().

currentServer

MYBYTE currentServer = UCHAR_MAX

Definition at line 57 of file tftpd.cpp.

Referenced by processRequest(), runProg(), and ServiceMain().

displayName

char displayName[] = "Open TFTP Server, MultiThreaded"

Definition at line 35 of file tftpd.cpp.

Referenced by BackgroundCopyJobConstructor(), hls_ref_Moniker_GetDisplayName(), hls_site_Moniker_GetDisplayName(), installService(), ItemMonikerImpl_ParseDisplayName(), and test_GetName().

extbuff

char extbuff[_MAX_PATH]

Definition at line 41 of file tftpd.cpp.

Referenced by init(), and logMess().

fileSep

char fileSep = '\\'

Definition at line 43 of file tftpd.cpp.

Referenced by init(), and processRequest().

iniFile

char iniFile[_MAX_PATH]

Definition at line 37 of file tftpd.cpp.

Referenced by init(), and test_profile_int().

lEvent

HANDLE lEvent

Definition at line 56 of file tftpd.cpp.

Referenced by init(), logMess(), WSAAsyncSelect(), and WSPAsyncSelect().

lnkFile

char lnkFile[_MAX_PATH]

Definition at line 39 of file tftpd.cpp.

Referenced by init(), and logMess().

logBuff

char logBuff[512]

Definition at line 42 of file tftpd.cpp.

Referenced by detectChange(), init(), logMess(), runProg(), and ServiceMain().

logFile

char logFile[_MAX_PATH]

Definition at line 38 of file tftpd.cpp.

Referenced by handle_escape_cmd(), init(), and logMess().

loggingDay

MYWORD loggingDay

Definition at line 48 of file tftpd.cpp.

Referenced by init(), and logMess().

minThreads

MYWORD minThreads =1

Definition at line 59 of file tftpd.cpp.

Referenced by cleanReq(), and init().

network

data1 network

Definition at line 49 of file tftpd.cpp.

Referenced by closeConn(), detectChange(), getInterfaces(), init(), processRequest(), runProg(), ServiceMain(), wnet_use_connection(), and wnetInit().

newNetwork

data1 newNetwork

Definition at line 50 of file tftpd.cpp.

Referenced by init(), and NetBTEnum().

notFileSep

char notFileSep = '/'

Definition at line 44 of file tftpd.cpp.

Referenced by init(), and processRequest().

serviceName

char serviceName[] = "TFTPServer"

Definition at line 34 of file tftpd.cpp.

Referenced by _tryLoadProvider(), installService(), main(), MakeService(), QueryConfig2A(), QueryConfig2W(), runService(), ServiceMain(), and uninstallService().