pxe.c File Reference

#include <freeldr.h>
#include <debug.h>

Include dependency graph for pxe.c:

Go to the source code of this file.

Macros
#define	TAG_PXE_FILE   'FexP'
#define	NO_FILE   ((ULONG)-1)

Functions
	DBG_DEFAULT_CHANNEL (FILESYSTEM)
static PPXE	FindPxeStructure (VOID)
static PPXE	GetPxeStructure (VOID)
PXENV_EXIT __cdecl	PxeCallApi (UINT16 Segment, UINT16 Offset, UINT16 Service, VOID *Parameter)
BOOLEAN	CallPxe (UINT16 Service, PVOID Parameter)
static ARC_STATUS	PxeClose (ULONG FileId)
static ARC_STATUS	PxeGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	PxeOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	PxeRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	PxeSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
const DEVVTBL *	PxeMount (ULONG DeviceId)
static ARC_STATUS	PxeDiskClose (ULONG FileId)
static ARC_STATUS	PxeDiskGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	PxeDiskOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	PxeDiskRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	PxeDiskSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
static BOOLEAN	GetCachedInfo (VOID)
BOOLEAN	PxeInit (VOID)

Variables
static IP4	_ServerIP = { 0, }
static ULONG	_OpenFile = NO_FILE
static CHAR	_OpenFileName [128]
static ULONG	_FileSize = 0
static ULONG	_FilePosition = 0
static ULONG	_PacketPosition = 0
static UCHAR	_Packet [1024]
static ULONG	_CachedLength = 0
static const DEVVTBL	PxeVtbl
static const DEVVTBL	PxeDiskVtbl

Macro Definition Documentation

NO_FILE

#define NO_FILE   ((ULONG)-1)

Definition at line 26 of file pxe.c.

TAG_PXE_FILE

#define TAG_PXE_FILE   'FexP'

Definition at line 25 of file pxe.c.

Function Documentation

CallPxe()

BOOLEAN CallPxe	(	UINT16	Service,
		PVOID	Parameter
	)

Definition at line 85 of file pxe.c.

{
    PPXE pxe;
    PXENV_EXIT exit;
 
    pxe = GetPxeStructure();
    if (!pxe)
        return FALSE;
 
    if (Service != PXENV_TFTP_READ)
    {
        // HACK: this delay shouldn't be necessary
        StallExecutionProcessor(100 * 1000); // 100 ms
        TRACE("PxeCall(0x%x, %p)\n", Service, Parameter);
    }
 
    exit = PxeCallApi(pxe->EntryPointSP.segment, pxe->EntryPointSP.offset, Service, Parameter);
    if (exit != PXENV_EXIT_SUCCESS)
    {
        ERR("PxeCall(0x%x, %p) failed with exit=%d status=0x%x\n",
                Service, Parameter, exit, *(PXENV_STATUS*)Parameter);
        return FALSE;
    }
    if (*(PXENV_STATUS*)Parameter != PXENV_STATUS_SUCCESS)
    {
        ERR("PxeCall(0x%x, %p) succeeded, but returned error status 0x%x\n",
                Service, Parameter, *(PXENV_STATUS*)Parameter);
        return FALSE;
    }
    return TRUE;
}

Referenced by GetCachedInfo(), PxeClose(), PxeOpen(), PxeRead(), and PxeSeek().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

FILESYSTEM

)

FindPxeStructure()

static PPXE FindPxeStructure ( VOID  )

static

Definition at line 38 of file pxe.c.

{
    PPXE Ptr;
    UCHAR Checksum;
    UCHAR i;
 
    /* Find the '!PXE' structure */
    Ptr = (PPXE)0xA0000;
    while ((ULONG_PTR)Ptr > 0x10000)
    {
        Ptr = (PPXE)((ULONG_PTR)Ptr - 0x10);
 
        /* Look for signature */
        if (memcmp(Ptr, "!PXE", 4) != 0)
            continue;
 
        /* Check size */
        if (Ptr->StructLength != sizeof(PXE))
            continue;
 
        /* Check checksum */
        Checksum = 0;
        for (i = 0; i < Ptr->StructLength; i++)
            Checksum += *((PUCHAR)Ptr + i);
        if (Checksum != 0)
            continue;
 
        TRACE("!PXE structure found at %p\n", Ptr);
        return Ptr;
    }
 
    return NULL;
}

Referenced by GetPxeStructure().

GetCachedInfo()

static BOOLEAN GetCachedInfo ( VOID  )

static

Definition at line 357 of file pxe.c.

{
    t_PXENV_GET_CACHED_INFO Data;
    BOOLEAN res;
    UCHAR* Packet;
 
    RtlZeroMemory(&Data, sizeof(Data));
    Data.PacketType = PXENV_PACKET_TYPE_CACHED_REPLY;
 
    res = CallPxe(PXENV_GET_CACHED_INFO, &Data);
    if (!res)
        return FALSE;
    if (Data.BufferSize < 36)
        return FALSE;
    Packet = (UCHAR*)((ULONG_PTR)(Data.Buffer.segment << 4) + Data.Buffer.offset);
    RtlCopyMemory(&_ServerIP, Packet + 20, sizeof(IP4));
    return TRUE;
}

Referenced by PxeInit().

GetPxeStructure()

static PPXE GetPxeStructure ( VOID  )

static

Definition at line 72 of file pxe.c.

{
    static PPXE pPxe = NULL;
    static BOOLEAN bPxeSearched = FALSE;
    if (!bPxeSearched)
    {
        pPxe = FindPxeStructure();
        bPxeSearched = TRUE;
    }
    return pPxe;
}

Referenced by CallPxe(), PxeInit(), and PxeMount().

PxeCallApi()

PXENV_EXIT __cdecl PxeCallApi	(	UINT16	Segment,
		UINT16	Offset,
		UINT16	Service,
		VOID *	Parameter
	)

Referenced by CallPxe().

PxeClose()

static ARC_STATUS PxeClose ( ULONG  FileId )

static

Definition at line 117 of file pxe.c.

{
    t_PXENV_TFTP_CLOSE closeData;
 
    if (_OpenFile == NO_FILE || FileId != _OpenFile)
        return EBADF;
 
    RtlZeroMemory(&closeData, sizeof(closeData));
    if (!CallPxe(PXENV_TFTP_CLOSE, &closeData))
        return EIO;
 
    _OpenFile = NO_FILE;
    return ESUCCESS;
}

Referenced by PxeSeek().

PxeDiskClose()

static ARC_STATUS PxeDiskClose ( ULONG  FileId )

static

Definition at line 319 of file pxe.c.

{
    // Nothing to do
    return ESUCCESS;
}

PxeDiskGetFileInformation()

static ARC_STATUS PxeDiskGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 325 of file pxe.c.

{
    // No disk access in PXE mode
    return EINVAL;
}

PxeDiskOpen()

static ARC_STATUS PxeDiskOpen ( CHAR *  Path, OPENMODE  OpenMode, ULONG *  FileId  )

static

Definition at line 331 of file pxe.c.

{
    // Nothing to do
    return ESUCCESS;
}

PxeDiskRead()

static ARC_STATUS PxeDiskRead ( ULONG  FileId, VOID *  Buffer, ULONG  N, ULONG *  Count  )

static

Definition at line 337 of file pxe.c.

{
    // No disk access in PXE mode
    return EINVAL;
}

PxeDiskSeek()

static ARC_STATUS PxeDiskSeek ( ULONG  FileId, LARGE_INTEGER *  Position, SEEKMODE  SeekMode  )

static

Definition at line 343 of file pxe.c.

{
    // No disk access in PXE mode
    return EINVAL;
}

PxeGetFileInformation()

static ARC_STATUS PxeGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 132 of file pxe.c.

{
    PCSTR FileName;
 
    if (_OpenFile == NO_FILE || FileId != _OpenFile)
        return EBADF;
 
    RtlZeroMemory(Information, sizeof(*Information));
    Information->EndingAddress.LowPart = _FileSize;
    Information->CurrentAddress.LowPart = _FilePosition;
 
    Information->Type = NetworkPeripheral;
 
    /* Set the ARC file attributes */
    Information->Attributes = ReadOnlyFile;
 
    /* Search for the last path separator. Slashes are used as separators,
     * for supporting TFTP servers on POSIX systems (see PxeOpen()) */
    FileName = strrchr(_OpenFileName, '/');
    if (FileName)
        ++FileName; // Go past it.
    else
        FileName = _OpenFileName; // No separator: file name without directory.
 
    /* Copy the file name, perhaps truncated, and NUL-terminated */
    Information->FileNameLength = (ULONG)strlen(FileName);
    Information->FileNameLength = min(Information->FileNameLength, sizeof(Information->FileName) - 1);
    RtlCopyMemory(Information->FileName, FileName, Information->FileNameLength);
    Information->FileName[Information->FileNameLength] = ANSI_NULL;
 
    TRACE("PxeGetFileInformation(%lu) -> FileSize = %lu, FilePointer = 0x%lx\n",
          FileId, Information->EndingAddress.LowPart, Information->CurrentAddress.LowPart);
 
    return ESUCCESS;
}

PxeInit()

BOOLEAN PxeInit

(

VOID

)

Definition at line 376 of file pxe.c.

{
    static BOOLEAN Initialized = FALSE;
    static BOOLEAN Success = FALSE;
 
    // Do initialization only once
    if (Initialized)
        return Success;
    Initialized = TRUE;
 
    // Check if PXE is available
    if (GetPxeStructure() && GetCachedInfo())
    {
        FsRegisterDevice("net(0)", &PxeDiskVtbl);
        Success = TRUE;
    }
 
    return Success;
}

Referenced by PcInitializeBootDevices().

PxeMount()

const DEVVTBL * PxeMount

(

ULONG

DeviceId

)

Definition at line 312 of file pxe.c.

{
    if (GetPxeStructure() == NULL)
        return NULL;
    return &PxeVtbl;
}

PxeOpen()

static ARC_STATUS PxeOpen ( CHAR *  Path, OPENMODE  OpenMode, ULONG *  FileId  )

static

Definition at line 168 of file pxe.c.

{
    t_PXENV_TFTP_GET_FSIZE sizeData;
    t_PXENV_TFTP_OPEN openData;
    SIZE_T PathLen, i;
 
    if (_OpenFile != NO_FILE)
        return EIO;
    if (OpenMode != OpenReadOnly)
        return EACCES;
 
    /* Skip leading path separator, if any, so as to ensure that
     * we always lookup the file at the root of the TFTP server's
     * file space ("virtual root"), even if the server doesn't
     * support this, and NOT from the root of the file system. */
    if (*Path == '\\' || *Path == '/')
        ++Path;
 
    /* Retrieve the path length without NULL terminator */
    PathLen = strlen(Path);
    PathLen = min(PathLen, sizeof(_OpenFileName) - 1);
 
    /* Lowercase the path and always use slashes as separators,
     * for supporting TFTP servers on POSIX systems */
    for (i = 0; i < PathLen; i++)
    {
        if (Path[i] == '\\')
            _OpenFileName[i] = '/';
        else
            _OpenFileName[i] = tolower(Path[i]);
    }
 
    /* Zero out rest of the file name */
    RtlZeroMemory(_OpenFileName + PathLen, sizeof(_OpenFileName) - PathLen);
 
    RtlZeroMemory(&sizeData, sizeof(sizeData));
    sizeData.ServerIPAddress = _ServerIP;
    RtlCopyMemory(sizeData.FileName, _OpenFileName, sizeof(_OpenFileName));
    if (!CallPxe(PXENV_TFTP_GET_FSIZE, &sizeData))
    {
        ERR("Failed to get '%s' size\n", Path);
        return EIO;
    }
 
    _FileSize = sizeData.FileSize;
    _CachedLength = 0;
 
    RtlZeroMemory(&openData, sizeof(openData));
    openData.ServerIPAddress = _ServerIP;
    RtlCopyMemory(openData.FileName, _OpenFileName, sizeof(_OpenFileName));
    openData.PacketSize = sizeof(_Packet);
 
    if (!CallPxe(PXENV_TFTP_OPEN, &openData))
        return ENOENT;
 
    _FilePosition = 0;
    _PacketPosition = 0;
 
    _OpenFile = *FileId;
    return ESUCCESS;
}

Referenced by PxeSeek().

PxeRead()

static ARC_STATUS PxeRead ( ULONG  FileId, VOID *  Buffer, ULONG  N, ULONG *  Count  )

static

Definition at line 230 of file pxe.c.

{
    t_PXENV_TFTP_READ readData;
    ULONG i;
 
    *Count = 0;
 
    if (_OpenFile == NO_FILE || FileId != _OpenFile)
        return EBADF;
 
    RtlZeroMemory(&readData, sizeof(readData));
    readData.Buffer.segment = ((ULONG_PTR)_Packet & 0xf0000) / 16;
    readData.Buffer.offset = (ULONG_PTR)_Packet & 0xffff;
 
    // Get new packets as required
    while (N > 0)
    {
        if (N < _CachedLength - _FilePosition)
            i = N;
        else
            i = _CachedLength - _FilePosition;
        RtlCopyMemory(Buffer, _Packet + _FilePosition - _PacketPosition, i);
        _FilePosition += i;
        Buffer = (UCHAR*)Buffer + i;
        *Count += i;
        N -= i;
        if (N == 0)
            break;
 
        if (!CallPxe(PXENV_TFTP_READ, &readData))
            return EIO;
        _PacketPosition = _CachedLength;
        _CachedLength += readData.BufferSize;
    }
 
    return ESUCCESS;
}

PxeSeek()

static ARC_STATUS PxeSeek ( ULONG  FileId, LARGE_INTEGER *  Position, SEEKMODE  SeekMode  )

static

Definition at line 268 of file pxe.c.

{
    t_PXENV_TFTP_READ readData;
 
    if (_OpenFile == NO_FILE || FileId != _OpenFile)
        return EBADF;
 
    if (Position->HighPart != 0 || SeekMode != SeekAbsolute)
        return EINVAL;
 
    if (Position->LowPart < _FilePosition)
    {
        // Close and reopen the file to go to position 0
        if (PxeClose(FileId) != ESUCCESS)
            return EIO;
        if (PxeOpen(_OpenFileName, OpenReadOnly, &FileId) != ESUCCESS)
            return EIO;
    }
 
    RtlZeroMemory(&readData, sizeof(readData));
    readData.Buffer.segment = ((ULONG_PTR)_Packet & 0xf0000) / 16;
    readData.Buffer.offset = (ULONG_PTR)_Packet & 0xffff;
 
    // Get new packets as required
    while (Position->LowPart > _CachedLength)
    {
        if (!CallPxe(PXENV_TFTP_READ, &readData))
            return EIO;
        _PacketPosition = _CachedLength;
        _CachedLength += readData.BufferSize;
    }
 
    _FilePosition = Position->LowPart;
    return ESUCCESS;
}

Variable Documentation

_CachedLength

ULONG _CachedLength = 0

static

Definition at line 35 of file pxe.c.

Referenced by PxeOpen(), PxeRead(), and PxeSeek().

_FilePosition

ULONG _FilePosition = 0

static

Definition at line 32 of file pxe.c.

Referenced by PxeGetFileInformation(), PxeOpen(), PxeRead(), and PxeSeek().

_FileSize

ULONG _FileSize = 0

static

Definition at line 31 of file pxe.c.

Referenced by PxeGetFileInformation(), and PxeOpen().

_OpenFile

ULONG _OpenFile = NO_FILE

static

Definition at line 29 of file pxe.c.

Referenced by PxeClose(), PxeGetFileInformation(), PxeOpen(), PxeRead(), and PxeSeek().

_OpenFileName

CHAR _OpenFileName[128]

static

Definition at line 30 of file pxe.c.

Referenced by PxeGetFileInformation(), PxeOpen(), and PxeSeek().

_Packet

UCHAR _Packet[1024]

static

Definition at line 34 of file pxe.c.

Referenced by NdisGetFirstBufferFromPacket(), NdisGetFirstBufferFromPacketSafe(), PxeOpen(), PxeRead(), and PxeSeek().

_PacketPosition

ULONG _PacketPosition = 0

static

Definition at line 33 of file pxe.c.

Referenced by PxeOpen(), PxeRead(), and PxeSeek().

_ServerIP

IP4 _ServerIP = { 0, }

static

Definition at line 28 of file pxe.c.

Referenced by GetCachedInfo(), and PxeOpen().

PxeDiskVtbl

const DEVVTBL PxeDiskVtbl

static

Initial value:

= {
    PxeDiskClose,
    PxeDiskGetFileInformation,
    PxeDiskOpen,
    PxeDiskRead,
    PxeDiskSeek,
}

Definition at line 349 of file pxe.c.

Referenced by PxeInit().

PxeVtbl

const DEVVTBL PxeVtbl

static

Initial value:

= {
    PxeClose,
    PxeGetFileInformation,
    PxeOpen,
    PxeRead,
    PxeSeek,
}

Definition at line 304 of file pxe.c.

Referenced by PxeMount().