7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi#include <slirp.h>

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi#include <iprt/file.h>

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi#include <iprt/asm-math.h>

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef enum ENMTFTPSESSIONFMT

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPFMT_NONE = 0,

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPFMT_OCTET,

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPFMT_NETASCII,

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPFMT_MAIL,

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPFMT_NOT_FMT = 0xffff

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi} ENMTFTPSESSIONFMT;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef struct TFPTPSESSIONOPTDESC

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi int fRequested;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint64_t u64Value;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi} TFPTPSESSIONOPTDESC, *PTFPTPSESSIONOPTDESC;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef struct TFTPSESSION

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi int fInUse;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi unsigned char pszFilename[TFTP_FILENAME_MAX];

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi struct in_addr IpClientAddress;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint16_t u16ClientPort;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi int iTimestamp;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint64_t cbTransfered;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint16_t cTftpAck;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi ENMTFTPSESSIONFMT enmTftpFmt;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFPTPSESSIONOPTDESC OptionBlkSize;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFPTPSESSIONOPTDESC OptionTSize;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFPTPSESSIONOPTDESC OptionTimeout;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi} TFTPSESSION, *PTFTPSESSION, **PPTFTPSESSION;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi#pragma pack(1)

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef struct TFTPCOREHDR

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint16_t u16TftpOpCode;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi /* Data lays here (might be raw uint8_t* or header of payload ) */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi} TFTPCOREHDR, *PTFTPCOREHDR;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef struct TFTPIPHDR

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi struct ip IPv4Hdr;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi struct udphdr UdpHdr;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi uint16_t u16TftpOpType;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi TFTPCOREHDR Core;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi /* Data lays here */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi} TFTPIPHDR, *PTFTPIPHDR;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi#pragma pack()

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef const PTFTPIPHDR PCTFTPIPHDR;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef const PTFTPSESSION PCTFTPSESSION;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef struct TFTPOPTIONDESC

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi const char *pszName;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi ENMTFTPSESSIONFMT enmType;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi int cbName;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi bool fHasValue;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi} TFTPOPTIONDESC, *PTFTPOPTIONDESC;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecinditypedef const PTFTPOPTIONDESC PCTFTPOPTIONDESC;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindistatic TFTPOPTIONDESC g_TftpTransferFmtDesc[] =

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

4557a2a1868181b517f5dfe61ba6eeba58edf4c0robj {"octet", TFTPFMT_OCTET, 5, false}, /* RFC1350 */

4557a2a1868181b517f5dfe61ba6eeba58edf4c0robj {"netascii", TFTPFMT_NETASCII, 8, false}, /* RFC1350 */

4557a2a1868181b517f5dfe61ba6eeba58edf4c0robj {"mail", TFTPFMT_MAIL, 4, false}, /* RFC1350 */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi};

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindistatic TFTPOPTIONDESC g_TftpDesc[] =

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {"blksize", TFTPFMT_NOT_FMT, 7, true}, /* RFC2348 */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {"timeout", TFTPFMT_NOT_FMT, 7, true}, /* RFC2349 */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {"tsize", TFTPFMT_NOT_FMT, 5, true}, /* RFC2349 */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {"size", TFTPFMT_NOT_FMT, 4, true}, /* RFC2349 */

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi};

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

0eb822a1c0c2bea495647510b75f77f0e57633ebcindiDECLINLINE(int) tftpSecurityFilenameCheck(PNATState pData, PCTFTPSESSION pcTftpSession)

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston{

4557a2a1868181b517f5dfe61ba6eeba58edf4c0robj size_t cbSessionFilename = 0;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi int rc = VINF_SUCCESS;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi AssertPtrReturn(pcTftpSession, VERR_INVALID_PARAMETER);

825ba0f20a74fd9c5d0d1ce2c195da2cc88a7f77robj cbSessionFilename = RTStrNLen((const char *)pcTftpSession->pszFilename, TFTP_FILENAME_MAX);

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi if ( !RTStrNCmp((const char*)pcTftpSession->pszFilename, "../", 3)

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston || (pcTftpSession->pszFilename[cbSessionFilename - 1] == '/')

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi || RTStrStr((const char *)pcTftpSession->pszFilename, "/../"))

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi rc = VERR_FILE_NOT_FOUND;

825ba0f20a74fd9c5d0d1ce2c195da2cc88a7f77robj

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi /* only allow exported prefixes */

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi if ( RT_SUCCESS(rc)

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston && !tftp_prefix)

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi rc = VERR_INTERNAL_ERROR;

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston LogFlowFuncLeaveRC(rc);

825ba0f20a74fd9c5d0d1ce2c195da2cc88a7f77robj return rc;

825ba0f20a74fd9c5d0d1ce2c195da2cc88a7f77robj}

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

4557a2a1868181b517f5dfe61ba6eeba58edf4c0robjDECLINLINE(int) tftpFindDesciptorIndexByName(int *piIdxOpt, PCTFTPOPTIONDESC paTftpDesc, int caTftpDesc, const char *pszOptName)

2eeaed14a5e2ed9bd811643ad5bffc3510ca0310robj{

825ba0f20a74fd9c5d0d1ce2c195da2cc88a7f77robj int rc = VINF_SUCCESS;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi int idxOption = 0;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi AssertReturn(piIdxOpt, VERR_INVALID_PARAMETER);

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi AssertReturn(paTftpDesc, VERR_INVALID_PARAMETER);

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston AssertReturn(pszOptName, VERR_INVALID_PARAMETER);

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi for (idxOption = 0; idxOption < caTftpDesc; ++idxOption)

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi {

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi if (!RTStrNICmp(pszOptName, paTftpDesc[idxOption].pszName, 10))

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston {

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi *piIdxOpt = idxOption;

88045cff0aae4ed8823cd0989168e8f56927f83eRobert Johnston return rc;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi }

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi }

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi rc = VERR_NOT_FOUND;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi return rc;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi}

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

0eb822a1c0c2bea495647510b75f77f0e57633ebcindiDECLINLINE(int) tftpFindTransferFormatIdxbyName(int *piIdxOpt, const char *pszOpt)

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi{

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi return tftpFindDesciptorIndexByName(piIdxOpt, &g_TftpTransferFmtDesc[0], RT_ELEMENTS(g_TftpTransferFmtDesc), pszOpt);

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi}

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

0eb822a1c0c2bea495647510b75f77f0e57633ebcindiDECLINLINE(int) tftpFindOptionIdxbyName(int *piIdxOpt, const char *pszOpt)

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi{

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi return tftpFindDesciptorIndexByName(piIdxOpt, &g_TftpDesc[0], RT_ELEMENTS(g_TftpDesc), pszOpt);

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi}

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

0eb822a1c0c2bea495647510b75f77f0e57633ebcindiDECLINLINE(bool) tftpIsAcceptableOption(const char *pszOptionName)

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi{

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi int idxOptDesc = 0;

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi AssertPtrReturn(pszOptionName, false);

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi AssertReturn(RTStrNLen(pszOptionName,10) >= 4, false);

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi AssertReturn(RTStrNLen(pszOptionName,10) < 8, false);

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi for(idxOptDesc = 0; idxOptDesc < RT_ELEMENTS(g_TftpTransferFmtDesc); ++idxOptDesc)

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi if (!RTStrNICmp(pszOptionName, g_TftpTransferFmtDesc[idxOptDesc].pszName, 10))

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi return true;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi }

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi for(idxOptDesc = 0; idxOptDesc < RT_ELEMENTS(g_TftpDesc); ++idxOptDesc)

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi {

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi if (!RTStrNICmp(pszOptionName, g_TftpDesc[idxOptDesc].pszName, 10))

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi return true;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi }

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi return false;

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi}

0eb822a1c0c2bea495647510b75f77f0e57633ebcindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindiDECLINLINE(int) tftpIsSupportedTransferMode(PCTFTPSESSION pcTftpSession)

7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fecindi{

AssertPtrReturn(pcTftpSession, 0);

return (pcTftpSession->enmTftpFmt == TFTPFMT_OCTET);

}

DECLINLINE(void) tftpSessionUpdate(PNATState pData, PTFTPSESSION pTftpSession)

{

pTftpSession->iTimestamp = curtime;

pTftpSession->fInUse = 1;

}

DECLINLINE(void) tftpSessionTerminate(PTFTPSESSION pTftpSession)

{

pTftpSession->fInUse = 0;

}

DECLINLINE(int)tftpSessionParseAndMarkOption(const char *pcszRawOption, PTFPTPSESSIONOPTDESC pTftpSessionOption)

{

int rc = VINF_SUCCESS;

rc = RTStrToInt64Full(pcszRawOption, 0, (int64_t *)&pTftpSessionOption->u64Value);

AssertRCReturn(rc, rc);

pTftpSessionOption->fRequested = 1;

return rc;

}

DECLINLINE(int) tftpSessionOptionParse(PTFTPSESSION pTftpSession, PCTFTPIPHDR pcTftpIpHeader)

{

int rc = VINF_SUCCESS;

char *pszTftpRRQRaw;

size_t idxTftpRRQRaw = 0;

int cbTftpRRQRaw = 0;

int fWithArg = 0;

int idxOptionArg = 0;

AssertPtrReturn(pTftpSession, VERR_INVALID_PARAMETER);

AssertPtrReturn(pcTftpIpHeader, VERR_INVALID_PARAMETER);

AssertReturn(RT_N2H_U16(pcTftpIpHeader->u16TftpOpType) == TFTP_RRQ, VERR_INVALID_PARAMETER);

LogFlowFunc(("pTftpSession:%p, pcTftpIpHeader:%p\n", pTftpSession, pcTftpIpHeader));

pszTftpRRQRaw = (char *)&pcTftpIpHeader->Core;

cbTftpRRQRaw = RT_H2N_U16(pcTftpIpHeader->UdpHdr.uh_ulen) + sizeof(struct ip) - RT_OFFSETOF(TFTPIPHDR, Core);

while(cbTftpRRQRaw)

{

idxTftpRRQRaw = RTStrNLen(pszTftpRRQRaw, 512 - idxTftpRRQRaw) + 1;

if (RTStrNLen((char *)pTftpSession->pszFilename, TFTP_FILENAME_MAX) == 0)

{

rc = RTStrCopy((char *)pTftpSession->pszFilename, TFTP_FILENAME_MAX, pszTftpRRQRaw);

if (RT_FAILURE(rc))

{

LogFlowFuncLeaveRC(rc);

AssertRCReturn(rc,rc);

}

}

else if (pTftpSession->enmTftpFmt == TFTPFMT_NONE)

{

int idxFmt = 0;

rc = tftpFindTransferFormatIdxbyName(&idxFmt, pszTftpRRQRaw);

if (RT_FAILURE(rc))

{

LogFlowFuncLeaveRC(VERR_INTERNAL_ERROR);

return VERR_INTERNAL_ERROR;

}

AssertReturn( g_TftpTransferFmtDesc[idxFmt].enmType != TFTPFMT_NONE

&& g_TftpTransferFmtDesc[idxFmt].enmType != TFTPFMT_NOT_FMT, VERR_INTERNAL_ERROR);

pTftpSession->enmTftpFmt = g_TftpTransferFmtDesc[idxFmt].enmType;

}

else if (fWithArg)

{

if (!RTStrICmp("blksize", g_TftpDesc[idxOptionArg].pszName))

{

rc = tftpSessionParseAndMarkOption(pszTftpRRQRaw, &pTftpSession->OptionBlkSize);

if (pTftpSession->OptionBlkSize.u64Value > UINT16_MAX)

rc = VERR_INVALID_PARAMETER;

}

if ( RT_SUCCESS(rc)

&& !RTStrICmp("tsize", g_TftpDesc[idxOptionArg].pszName))

rc = tftpSessionParseAndMarkOption(pszTftpRRQRaw, &pTftpSession->OptionTSize);

/* @todo: we don't use timeout, but its value in the range 0-255 */

if ( RT_SUCCESS(rc)

&& !RTStrICmp("timeout", g_TftpDesc[idxOptionArg].pszName))

rc = tftpSessionParseAndMarkOption(pszTftpRRQRaw, &pTftpSession->OptionTimeout);

/* @todo: unknown option detection */

if (RT_FAILURE(rc))

{

LogFlowFuncLeaveRC(rc);

AssertRCReturn(rc,rc);

}

fWithArg = 0;

idxOptionArg = 0;

}

else

{

rc = tftpFindOptionIdxbyName(&idxOptionArg, pszTftpRRQRaw);

if (RT_SUCCESS(rc))

fWithArg = 1;

else

{

LogFlowFuncLeaveRC(rc);

AssertRCReturn(rc,rc);

}

}

pszTftpRRQRaw += idxTftpRRQRaw;

cbTftpRRQRaw -= idxTftpRRQRaw;

}

LogFlowFuncLeaveRC(rc);

return rc;

}

static int tftpAllocateSession(PNATState pData, PCTFTPIPHDR pcTftpIpHeader, PPTFTPSESSION ppTftpSession)

{

PTFTPSESSION pTftpSession = NULL;

int rc = VINF_SUCCESS;

int idxSession;

AssertPtrReturn(pData, VERR_INVALID_PARAMETER);

AssertPtrReturn(pcTftpIpHeader, VERR_INVALID_PARAMETER);

AssertPtrReturn(ppTftpSession, VERR_INVALID_PARAMETER);

for (idxSession = 0; idxSession < TFTP_SESSIONS_MAX; idxSession++)

{

pTftpSession = &((PTFTPSESSION)pData->pvTftpSessions)[idxSession];

if (!pTftpSession->fInUse)

goto found;

/* sessions time out after 5 inactive seconds */

if ((int)(curtime - pTftpSession->iTimestamp) > 5000)

goto found;

}

return VERR_NOT_FOUND;

found:

memset(pTftpSession, 0, sizeof(*pTftpSession));

memcpy(&pTftpSession->IpClientAddress, &pcTftpIpHeader->IPv4Hdr.ip_src, sizeof(pTftpSession->IpClientAddress));

pTftpSession->u16ClientPort = pcTftpIpHeader->UdpHdr.uh_sport;

rc = tftpSessionOptionParse(pTftpSession, pcTftpIpHeader);

AssertRCReturn(rc, VERR_INTERNAL_ERROR);

*ppTftpSession = pTftpSession;

tftpSessionUpdate(pData, pTftpSession);

return VINF_SUCCESS;

}

static int tftpSessionFind(PNATState pData, PCTFTPIPHDR pcTftpIpHeader, PPTFTPSESSION ppTftpSessions)

{

PTFTPSESSION pTftpSession;

int idxTftpSession;

AssertPtrReturn(pData, VERR_INVALID_PARAMETER);

AssertPtrReturn(pcTftpIpHeader, VERR_INVALID_PARAMETER);

AssertPtrReturn(ppTftpSessions, VERR_INVALID_PARAMETER);

for (idxTftpSession = 0; idxTftpSession < TFTP_SESSIONS_MAX; idxTftpSession++)

{

pTftpSession = &((PTFTPSESSION)pData->pvTftpSessions)[idxTftpSession];

if (pTftpSession->fInUse)

{

if (!memcmp(&pTftpSession->IpClientAddress, &pcTftpIpHeader->IPv4Hdr.ip_src, sizeof(pTftpSession->IpClientAddress)))

{

if (pTftpSession->u16ClientPort == pcTftpIpHeader->UdpHdr.uh_sport)

{

*ppTftpSessions = pTftpSession;

return VINF_SUCCESS;

}

}

}

}

return VERR_NOT_FOUND;

}

DECLINLINE(int) pftpSessionOpenFile(PNATState pData, PTFTPSESSION pTftpSession, PRTFILE pSessionFile)

{

char aszSessionFileName[TFTP_FILENAME_MAX];

size_t cbSessionFileName;

int rc = VINF_SUCCESS;

LogFlowFuncEnter();

cbSessionFileName = RTStrPrintf(aszSessionFileName, TFTP_FILENAME_MAX, "%s/%s",

tftp_prefix, pTftpSession->pszFilename);

if (cbSessionFileName >= TFTP_FILENAME_MAX)

{

LogFlowFuncLeaveRC(VERR_INTERNAL_ERROR);

return VERR_INTERNAL_ERROR;

}

LogFunc(("aszSessionFileName: %s\n", aszSessionFileName));

if (!RTFileExists(aszSessionFileName))

{

LogFlowFuncLeaveRC(VERR_FILE_NOT_FOUND);

return VERR_FILE_NOT_FOUND;

}

rc = RTFileOpen(pSessionFile, aszSessionFileName, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);

LogFlowFuncLeaveRC(rc);

return rc;

}

DECLINLINE(int) tftpSessionEvaluateOptions(PNATState pData, PTFTPSESSION pTftpSession)

{

int rc = VINF_SUCCESS;

RTFILE hSessionFile;

uint64_t cbSessionFile = 0;

LogFlowFunc(("pTftpSession:%p\n", pTftpSession));

rc = pftpSessionOpenFile(pData, pTftpSession, &hSessionFile);

if (RT_FAILURE(rc))

{

LogFlowFuncLeave();

return rc;

}

rc = RTFileGetSize(hSessionFile, &cbSessionFile);

RTFileClose(hSessionFile);

if (RT_FAILURE(rc))

{

LogFlowFuncLeave();

return rc;

}

if (pTftpSession->OptionTSize.fRequested)

{

pTftpSession->OptionTSize.u64Value = cbSessionFile;

}

if ( !pTftpSession->OptionBlkSize.u64Value

&& !pTftpSession->OptionBlkSize.fRequested)

{

pTftpSession->OptionBlkSize.u64Value = 1428;

}

LogFlowFuncLeaveRC(rc);

return rc;

}

DECLINLINE(int) tftpSend(PNATState pData,

PTFTPSESSION pTftpSession,

struct mbuf *pMBuf,

PCTFTPIPHDR pcTftpIpHeaderRecv)

{

int rc = VINF_SUCCESS;

struct sockaddr_in saddr, daddr;

LogFlowFunc(("pMBuf:%p, pcTftpIpHeaderRecv:%p\n", pMBuf, pcTftpIpHeaderRecv));

saddr.sin_addr = pcTftpIpHeaderRecv->IPv4Hdr.ip_dst;

saddr.sin_port = pcTftpIpHeaderRecv->UdpHdr.uh_dport;

daddr.sin_addr = pTftpSession->IpClientAddress;

daddr.sin_port = pTftpSession->u16ClientPort;

pMBuf->m_data += sizeof(struct udpiphdr);

pMBuf->m_len -= sizeof(struct udpiphdr);

udp_output2(pData, NULL, pMBuf, &saddr, &daddr, IPTOS_LOWDELAY);

LogFlowFuncLeaveRC(rc);

return rc;

}

DECLINLINE(int) tftpSendError(PNATState pData, PTFTPSESSION pTftpSession, uint16_t errorcode, const char *msg, PCTFTPIPHDR pcTftpIpHeaderRecv);

DECLINLINE(int) tftpReadDataBlock(PNATState pData,

PTFTPSESSION pcTftpSession,

uint8_t *pu8Data,

int *pcbReadData)

{

RTFILE hSessionFile;

int rc = VINF_SUCCESS;

uint16_t u16BlkSize = 0;

AssertPtrReturn(pData, VERR_INVALID_PARAMETER);

AssertPtrReturn(pcTftpSession, VERR_INVALID_PARAMETER);

AssertPtrReturn(pu8Data, VERR_INVALID_PARAMETER);

AssertPtrReturn(pcbReadData, VERR_INVALID_PARAMETER);

AssertReturn(pcTftpSession->OptionBlkSize.u64Value < UINT16_MAX, VERR_INVALID_PARAMETER);

LogFlowFunc(("pcTftpSession:%p, pu8Data:%p, pcbReadData:%p\n",

pcTftpSession,

pu8Data,

pcbReadData));

u16BlkSize = (uint16_t)pcTftpSession->OptionBlkSize.u64Value;

rc = pftpSessionOpenFile(pData, pcTftpSession, &hSessionFile);

if (RT_FAILURE(rc))

{

LogFlowFuncLeaveRC(rc);

return rc;

}

if (pcbReadData)

{

rc = RTFileSeek(hSessionFile,

pcTftpSession->cbTransfered,

RTFILE_SEEK_BEGIN,

NULL);

if (RT_FAILURE(rc))

{

RTFileClose(hSessionFile);

LogFlowFuncLeaveRC(rc);

return rc;

}

rc = RTFileRead(hSessionFile, pu8Data, u16BlkSize, (size_t *)pcbReadData);

if (RT_FAILURE(rc))

{

RTFileClose(hSessionFile);

LogFlowFuncLeaveRC(rc);

return rc;

}

}

rc = RTFileClose(hSessionFile);

LogFlowFuncLeaveRC(rc);

return rc;

}

DECLINLINE(int) tftpAddOptionToOACK(PNATState pData, struct mbuf *pMBuf, const char *pszOptName, uint64_t u64OptValue)

{

char aszOptionBuffer[256];

size_t iOptLength = 0;

int rc = VINF_SUCCESS;

int cbMBufCurrent = pMBuf->m_len;

LogFlowFunc(("pMBuf:%p, pszOptName:%s, u16OptValue:%ld\n", pMBuf, pszOptName, u64OptValue));

AssertPtrReturn(pMBuf, VERR_INVALID_PARAMETER);

AssertPtrReturn(pszOptName, VERR_INVALID_PARAMETER);

RT_ZERO(aszOptionBuffer);

iOptLength += RTStrPrintf(aszOptionBuffer, 256 , "%s", pszOptName) + 1;

iOptLength += RTStrPrintf(aszOptionBuffer + iOptLength, 256 - iOptLength , "%u", u64OptValue) + 1;

if (iOptLength > M_TRAILINGSPACE(pMBuf))

rc = VERR_BUFFER_OVERFLOW; /* buffer too small */

else

{

pMBuf->m_len += iOptLength;

m_copyback(pData, pMBuf, cbMBufCurrent, iOptLength, aszOptionBuffer);

}

LogFlowFuncLeaveRC(rc);

return rc;

}

DECLINLINE(int) tftpSendOACK(PNATState pData,

PTFTPSESSION pTftpSession,

PCTFTPIPHDR pcTftpIpHeaderRecv)

{

struct mbuf *m;

PTFTPIPHDR pTftpIpHeader;

int rc = VINF_SUCCESS;

rc = tftpSessionEvaluateOptions(pData, pTftpSession);

if (RT_FAILURE(rc))

{

tftpSendError(pData, pTftpSession, 2, "Internal Error (blksize evaluation)", pcTftpIpHeaderRecv);

LogFlowFuncLeave();

return -1;

}

m = slirpTftpMbufAlloc(pData);

if (!m)

return -1;

m->m_data += if_maxlinkhdr;

m->m_pkthdr.header = mtod(m, void *);

pTftpIpHeader = mtod(m, PTFTPIPHDR);

m->m_len = sizeof(TFTPIPHDR) - sizeof(uint16_t); /* no u16TftpOpCode */

pTftpIpHeader->u16TftpOpType = RT_H2N_U16_C(TFTP_OACK);

if (pTftpSession->OptionBlkSize.fRequested)

{

if (pTftpSession->OptionBlkSize.u64Value > UINT16_MAX)

return -1;

else

rc = tftpAddOptionToOACK(pData, m, "blksize", pTftpSession->OptionBlkSize.u64Value);

}

if (pTftpSession->OptionTSize.fRequested)

rc = tftpAddOptionToOACK(pData, m, "tsize", pTftpSession->OptionTSize.u64Value);

rc = tftpSend(pData, pTftpSession, m, pcTftpIpHeaderRecv);

return RT_SUCCESS(rc) ? 0 : -1;

}

DECLINLINE(int) tftpSendError(PNATState pData,

PTFTPSESSION pTftpSession,

uint16_t errorcode,

const char *msg,

PCTFTPIPHDR pcTftpIpHeaderRecv)

{

struct mbuf *m = NULL;

PTFTPIPHDR pTftpIpHeader = NULL;

LogFlowFunc(("ENTER: errorcode: %RX16, msg: %s\n", errorcode, msg));

m = slirpTftpMbufAlloc(pData);

if (!m)

{

LogFlowFunc(("LEAVE: Can't allocate mbuf\n"));

return -1;

}

m->m_data += if_maxlinkhdr;

m->m_len = sizeof(TFTPIPHDR)

+ strlen(msg) + 1; /* ending zero */

m->m_pkthdr.header = mtod(m, void *);

pTftpIpHeader = mtod(m, PTFTPIPHDR);

pTftpIpHeader->u16TftpOpType = RT_H2N_U16_C(TFTP_ERROR);

pTftpIpHeader->Core.u16TftpOpCode = RT_H2N_U16(errorcode);

m_copyback(pData, m, sizeof(TFTPIPHDR), strlen(msg) + 1 /* copy ending zerro*/, (c_caddr_t)msg);

tftpSend(pData, pTftpSession, m, pcTftpIpHeaderRecv);

tftpSessionTerminate(pTftpSession);

LogFlowFuncLeave();

return 0;

}

static int tftpSendData(PNATState pData,

PTFTPSESSION pTftpSession,

uint16_t u16Block,

PCTFTPIPHDR pcTftpIpHeaderRecv)

{

struct mbuf *m;

PTFTPIPHDR pTftpIpHeader;

int cbRead = 0;

int rc = VINF_SUCCESS;

if (u16Block == pTftpSession->cTftpAck)

pTftpSession->cTftpAck++;

else

{

tftpSendError(pData, pTftpSession, 6, "ACK is wrong", pcTftpIpHeaderRecv);

tftpSessionTerminate(pTftpSession);

return -1;

}

m = slirpTftpMbufAlloc(pData);

if (!m)

return -1;

m->m_data += if_maxlinkhdr;

m->m_pkthdr.header = mtod(m, void *);

pTftpIpHeader = mtod(m, PTFTPIPHDR);

m->m_len = sizeof(TFTPIPHDR);

pTftpIpHeader->u16TftpOpType = RT_H2N_U16_C(TFTP_DATA);

pTftpIpHeader->Core.u16TftpOpCode = RT_H2N_U16(pTftpSession->cTftpAck);

rc = tftpReadDataBlock(pData, pTftpSession, (uint8_t *)&pTftpIpHeader->Core.u16TftpOpCode + sizeof(uint16_t), &cbRead);

if (RT_SUCCESS(rc))

{

pTftpSession->cbTransfered += cbRead;

m->m_len += cbRead;

tftpSend(pData, pTftpSession, m, pcTftpIpHeaderRecv);

if (cbRead > 0)

tftpSessionUpdate(pData, pTftpSession);

else

tftpSessionTerminate(pTftpSession);

}

else

{

m_freem(pData, m);

tftpSendError(pData, pTftpSession, 1, "File not found", pcTftpIpHeaderRecv);

/* send "file not found" error back */

return -1;

}

return 0;

}

DECLINLINE(void) tftpProcessRRQ(PNATState pData, PCTFTPIPHDR pTftpIpHeader, int pktlen)

{

PTFTPSESSION pTftpSession = NULL;

uint8_t *pu8Payload = NULL;

int cbPayload = 0;

size_t cbFileName = 0;

int rc = VINF_SUCCESS;

AssertPtrReturnVoid(pTftpIpHeader);

AssertPtrReturnVoid(pData);

AssertReturnVoid(pktlen > sizeof(TFTPIPHDR));

LogFlowFunc(("ENTER: pTftpIpHeader:%p, pktlen:%d\n", pTftpIpHeader, pktlen));

rc = tftpAllocateSession(pData, pTftpIpHeader, &pTftpSession);

if ( RT_FAILURE(rc)

|| pTftpSession == NULL)

{

LogFlowFuncLeave();

return;

}

pu8Payload = (uint8_t *)&pTftpIpHeader->Core;

cbPayload = pktlen - sizeof(TFTPIPHDR);

cbFileName = RTStrNLen((char *)pu8Payload, cbPayload);

/* We assume that file name should finish with '\0' and shouldn't bigger

AssertReturnVoid( cbFileName < cbPayload

&& cbFileName < TFTP_FILENAME_MAX /* current limit in tftp session handle */

&& cbFileName);

/* Dont't bother with rest processing in case of invalid access */

if (RT_FAILURE(tftpSecurityFilenameCheck(pData, pTftpSession)))

{

tftpSendError(pData, pTftpSession, 2, "Access violation", pTftpIpHeader);

LogFlowFuncLeave();

return;

}

if (RT_UNLIKELY(!tftpIsSupportedTransferMode(pTftpSession)))

{

tftpSendError(pData, pTftpSession, 4, "Unsupported transfer mode", pTftpIpHeader);

LogFlowFuncLeave();

return;

}

tftpSendOACK(pData, pTftpSession, pTftpIpHeader);

LogFlowFuncLeave();

return;

}

static void tftpProcessACK(PNATState pData, PTFTPIPHDR pTftpIpHeader)

{

int rc;

PTFTPSESSION pTftpSession = NULL;

rc = tftpSessionFind(pData, pTftpIpHeader, &pTftpSession);

if (RT_FAILURE(rc))

return;

AssertReturnVoid(tftpSendData(pData,

pTftpSession,

RT_N2H_U16(pTftpIpHeader->Core.u16TftpOpCode), pTftpIpHeader) == 0);

}

DECLCALLBACK(int) slirpTftpInit(PNATState pData)

{

AssertPtrReturn(pData, VERR_INVALID_PARAMETER);

pData->pvTftpSessions = RTMemAllocZ(sizeof(TFTPSESSION) * TFTP_SESSIONS_MAX);

AssertPtrReturn(pData->pvTftpSessions, VERR_NO_MEMORY);

return VINF_SUCCESS;

}

DECLCALLBACK(int) slirpTftpInput(PNATState pData, struct mbuf *pMbuf)

{

PTFTPIPHDR pTftpIpHeader = NULL;

AssertPtr(pData);

AssertPtr(pMbuf);

pTftpIpHeader = mtod(pMbuf, PTFTPIPHDR);

switch(RT_N2H_U16(pTftpIpHeader->u16TftpOpType))

{

case TFTP_RRQ:

tftpProcessRRQ(pData, pTftpIpHeader, m_length(pMbuf, NULL));

break;

case TFTP_ACK:

tftpProcessACK(pData, pTftpIpHeader);

break;

default:;

}

LogFlowFuncLeaveRC(VINF_SUCCESS);

return VINF_SUCCESS;

}