12 Commits
Author SHA1 Message Date
Marty Connor 53e9fb50d2 [release] Update version to 1.0.0 for release
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-02-02 11:12:44 -05:00
Stefan Hajnoczi 26f882bf64 [proto] Remove unsupported NMB protocol
The NMB protocol code came from legacy Etherboot and was never updated
to work as a gPXE protocol.  There has been no demand for this protocol,
so this patch removes it.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:24:12 -05:00
Stefan Hajnoczi 00a780e38f [proto] Remove unsupported IGMP protocol
The IGMP code came from legacy Etherboot and was never updated to work
as a gPXE protocol.  There has been no demand for this protocol, so this
patch removes it.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:22:43 -05:00
Stefan Hajnoczi 1548189ffa [proto] Remove unsupported NFS protocol
The NFS protocol code came from legacy Etherboot and was never updated
to work as a gPXE protocol.  There has been no demand for this protocol,
so this patch removes it.

I have an unfinished NFSv3 over TCP implementation for gPXE that can be
used as the base for new work, should we want to resurrect this
protocol.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:21:00 -05:00
Stefan Hajnoczi e501e6e19e [proto] Remove unsupported FSP protocol
The FSP protocol code came from legacy Etherboot and was never updated
to work as a gPXE protocol.  There has been no demand for this protocol,
so this patch removes it.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:19:49 -05:00
Stefan Hajnoczi 1056a1c2d5 [prefix] Remove unsupported ELF prefices
The .elf, .elfd, .lmelf, and .lmelfd prefices were brought over from
legacy Etherboot and they do not build in gPXE.  This patch removes the
ELF prefices.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:10:25 -05:00
Stefan Hajnoczi 9a89f0d17d [prefix] Remove unsupported .exe prefix
The unfinished .exe prefix was brought over from legacy Etherboot.
There has been no demand for .exe images so this patch removes the
prefix.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:06:55 -05:00
Stefan Hajnoczi ddcf2d5f08 [prefix] Remove unsupported .com prefix
The DOS .com prefix was brought over from legacy Etherboot but does not
build.  There has been no demand for .com images so this patch removes
the prefix.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:05:22 -05:00
Stefan Hajnoczi d3b9c3f3d0 [prefix] Remove .bImage in favor of .lkrn
The .lkrn prefix allows gPXE to be loaded as a Linux bzImage.  The
bImage prefix was carried over from legacy Etherboot and does not build.
This patch removes the .bImage prefix, use .lkrn instead.

Signed-off-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-31 19:00:56 -05:00
Joshua Oreman f3467ad169 [http] GET / if URI doesn't contain a path
Commit 3d9dd93 introduced a regression in HTTP: if a URI without a
path is specified (e.g. http://netboot.me), we send the empty string
as our GET request. Reintroduce an extra slash when uri->path is NULL,
to turn this into the expected GET /.

Reported-by: Kyle Kienapfel <doctor.whom@gmail.com>
Signed-off-by: Joshua Oreman <oremanj@rwcr.net>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-27 08:52:39 -05:00
Joshua Oreman e6f08b0aa7 [uri] Handle an empty unparse_uri() result properly
Previously, if none of the URI parts requested existed in the passed
URI, unparse_uri() would not touch the destination buffer at all; this
could lead to use of uninitialized data. Fix by setting buf[0] = '\0'
before unparsing whenever we have room to do so.

Signed-off-by: Joshua Oreman <oremanj@rwcr.net>
Signed-off-by: Marty Connor <mdc@etherboot.org>
2010-01-27 08:50:49 -05:00
Marty Connor 329c7b78e3 [release] Update version to 1.0.0-rc1+ post release 2010-01-26 15:00:32 -05:00
23 changed files with 9 additions and 2498 deletions
+1 -2
View File
@@ -54,7 +54,6 @@ BFD_DIR := $(BINUTILS_DIR)
SRCDIRS :=
SRCDIRS += libgcc
SRCDIRS += core
SRCDIRS += proto
SRCDIRS += net net/tcp net/udp net/infiniband net/80211
SRCDIRS += image
SRCDIRS += drivers/bus
@@ -131,7 +130,7 @@ install :
VERSION_MAJOR = 1
VERSION_MINOR = 0
VERSION_PATCH = 0
EXTRAVERSION = -rc1
EXTRAVERSION =
MM_VERSION = $(VERSION_MAJOR).$(VERSION_MINOR)
VERSION = $(MM_VERSION).$(VERSION_PATCH)$(EXTRAVERSION)
CFLAGS += -DVERSION_MAJOR=$(VERSION_MAJOR) \
-7
View File
@@ -16,18 +16,11 @@ MEDIA += xrom
MEDIA += pxe
MEDIA += kpxe
MEDIA += kkpxe
MEDIA += elf
MEDIA += elfd
MEDIA += lmelf
MEDIA += lmelfd
MEDIA += lkrn
MEDIA += bImage
MEDIA += dsk
MEDIA += nbi
MEDIA += hd
MEDIA += raw
MEDIA += com
MEDIA += exe
# Padding rules
#
-611
View File
@@ -1,611 +0,0 @@
/*
Copyright (C) 2000, Entity Cyber, Inc.
Authors: Gary Byers (gb@thinguin.org)
Marty Connor (mdc@thinguin.org)
Eric Biederman (ebiederman@lnxi.com)
This code also derives a lot from arch/i386/boot/setup.S in
the linux kernel.
This software may be used and distributed according to the terms
of the GNU Public License (GPL), incorporated herein by reference.
Description:
This is just a little bit of code and data that can get prepended
to an Etherboot ROM image in order to allow LILO to load the
result as if it were a Linux kernel image.
A real Linux kernel image consists of a one-sector boot loader
(to load the image from a floppy disk), followed a few sectors
of setup code, followed by the kernel code itself. There's
a table in the first sector (starting at offset 497) that indicates
how many sectors of setup code follow the first sector and which
contains some other parameters that aren't interesting in this
case.
When LILO loads the sectors that comprise a kernel image, it doesn't
execute the code in the first sector (since that code would try to
load the image from a floppy disk.) The code in the first sector
below doesn't expect to get executed (and prints an error message
if it ever -is- executed.) LILO's only interested in knowing the
number of setup sectors advertised in the table (at offset 497 in
the first sector.)
Etherboot doesn't require much in the way of setup code.
Historically, the Linux kernel required at least 4 sectors of
setup code. Current versions of LILO look at the byte at
offset 497 in the first sector to indicate how many sectors
of setup code are contained in the image.
The setup code that is present here does a lot of things
exactly the way the linux kernel does them instead of in
ways more typical of etherboot. Generally this is so
the code can be strongly compatible with the linux kernel.
In addition the general etherboot technique of enabling the a20
after we switch into protected mode does not work if etherboot
is being loaded at 1MB.
*/
.equ CR0_PE,1
#ifdef GAS291
#define DATA32 data32;
#define ADDR32 addr32;
#define LJMPI(x) ljmp x
#else
#define DATA32 data32
#define ADDR32 addr32
/* newer GAS295 require #define LJMPI(x) ljmp *x */
#define LJMPI(x) ljmp x
#endif
/* Simple and small GDT entries for booting only */
#define GDT_ENTRY_BOOT_CS 2
#define GDT_ENTRY_BOOT_DS (GDT_ENTRY_BOOT_CS + 1)
#define __BOOT_CS (GDT_ENTRY_BOOT_CS * 8)
#define __BOOT_DS (GDT_ENTRY_BOOT_DS * 8)
#define SETUPSECS 4 /* Minimal nr of setup-sectors */
#define PREFIXSIZE ((SETUPSECS+1)*512)
#define PREFIXPGH (PREFIXSIZE / 16 )
#define BOOTSEG 0x07C0 /* original address of boot-sector */
#define INITSEG 0x9000 /* we move boot here - out of the way */
#define SETUPSEG 0x9020 /* setup starts here */
#define SYSSEG 0x1000 /* system loaded at 0x10000 (65536). */
#define DELTA_INITSEG (SETUPSEG - INITSEG) /* 0x0020 */
/* Signature words to ensure LILO loaded us right */
#define SIG1 0xAA55
#define SIG2 0x5A5A
.text
.code16
.arch i386
.org 0
.section ".prefix", "ax", @progbits
_prefix:
/*
This is a minimal boot sector. If anyone tries to execute it (e.g., if
a .lkrn file is dd'ed to a floppy), print an error message.
*/
bootsector:
jmp $BOOTSEG, $go - _prefix /* reload cs:ip to match relocation addr */
go:
movw $0x2000, %di /* 0x2000 is arbitrary value >= length
of bootsect + room for stack */
movw $BOOTSEG, %ax
movw %ax,%ds
movw %ax,%es
cli
movw %ax, %ss /* put stack at BOOTSEG:0x2000. */
movw %di,%sp
sti
movw $why_end-why, %cx
movw $why - _prefix, %si
movw $0x0007, %bx /* page 0, attribute 7 (normal) */
movb $0x0e, %ah /* write char, tty mode */
prloop:
lodsb
int $0x10
loop prloop
freeze: jmp freeze
why: .ascii "This image cannot be loaded from a floppy disk.\r\n"
why_end:
.org 497
setup_sects:
.byte SETUPSECS
root_flags:
.word 0
syssize:
.word _verbatim_size_pgh - PREFIXPGH
swap_dev:
.word 0
ram_size:
.word 0
vid_mode:
.word 0
root_dev:
.word 0
boot_flag:
.word 0xAA55
/*
We're now at the beginning of the second sector of the image -
where the setup code goes.
We don't need to do too much setup for Etherboot.
This code gets loaded at SETUPSEG:0. It wants to start
executing the Etherboot image that's loaded at SYSSEG:0 and
whose entry point is SYSSEG:0.
*/
setup_code:
jmp trampoline
# This is the setup header, and it must start at %cs:2 (old 0x9020:2)
.ascii "HdrS" # header signature
.word 0x0203 # header version number (>= 0x0105)
# or else old loadlin-1.5 will fail)
realmode_swtch: .word 0, 0 # default_switch, SETUPSEG
start_sys_seg: .word SYSSEG # low load segment (obsolete)
.word kernel_version - setup_code
# pointing to kernel version string
# above section of header is compatible
# with loadlin-1.5 (header v1.5). Don't
# change it.
type_of_loader: .byte 0 # = 0, old one (LILO, Loadlin,
# Bootlin, SYSLX, bootsect...)
# See Documentation/i386/boot.txt for
# assigned ids
# flags, unused bits must be zero (RFU) bit within loadflags
loadflags:
LOADED_HIGH = 1 # If set, the kernel is loaded high
CAN_USE_HEAP = 0x80 # If set, the loader also has set
# heap_end_ptr to tell how much
# space behind setup.S can be used for
# heap purposes.
# Only the loader knows what is free
.byte LOADED_HIGH
setup_move_size: .word 0x8000 # size to move, when setup is not
# loaded at 0x90000. We will move setup
# to 0x90000 then just before jumping
# into the kernel. However, only the
# loader knows how much data behind
# us also needs to be loaded.
code32_start: # here loaders can put a different
# start address for 32-bit code.
.long 0x100000 # 0x100000 = default for big kernel
ramdisk_image: .long 0 # address of loaded ramdisk image
# Here the loader puts the 32-bit
# address where it loaded the image.
# This only will be read by the kernel.
ramdisk_size: .long 0 # its size in bytes
bootsect_kludge:
.long 0 # obsolete
heap_end_ptr: .word 0 # (Header version 0x0201 or later)
# space from here (exclusive) down to
# end of setup code can be used by setup
# for local heap purposes.
pad1: .word 0
cmd_line_ptr: .long 0 # (Header version 0x0202 or later)
# If nonzero, a 32-bit pointer
# to the kernel command line.
# The command line should be
# located between the start of
# setup and the end of low
# memory (0xa0000), or it may
# get overwritten before it
# gets read. If this field is
# used, there is no longer
# anything magical about the
# 0x90000 segment; the setup
# can be located anywhere in
# low memory 0x10000 or higher.
ramdisk_max: .long 0 # (Header version 0x0203 or later)
# The highest safe address for
# the contents of an initrd
trampoline: call start_of_setup
trampoline_end:
.space 1024
# End of setup header #####################################################
start_of_setup:
# Set %ds = %cs, we know that SETUPSEG = %cs at this point
movw %cs, %ax # aka SETUPSEG
movw %ax, %ds
# Check signature at end of setup
cmpw $SIG1, (setup_sig1 - setup_code)
jne bad_sig
cmpw $SIG2, (setup_sig2 - setup_code)
jne bad_sig
jmp good_sig1
# Routine to print asciiz string at ds:si
prtstr:
lodsb
andb %al, %al
jz fin
call prtchr
jmp prtstr
fin: ret
# Part of above routine, this one just prints ascii al
prtchr: pushw %ax
pushw %cx
movw $7,%bx
movw $0x01, %cx
movb $0x0e, %ah
int $0x10
popw %cx
popw %ax
ret
no_sig_mess: .string "No setup signature found ..."
good_sig1:
jmp good_sig
# We now have to find the rest of the setup code/data
bad_sig:
movw %cs, %ax # SETUPSEG
subw $DELTA_INITSEG, %ax # INITSEG
movw %ax, %ds
xorb %bh, %bh
movb (497), %bl # get setup sect from bootsect
subw $4, %bx # LILO loads 4 sectors of setup
shlw $8, %bx # convert to words (1sect=2^8 words)
movw %bx, %cx
shrw $3, %bx # convert to segment
addw $SYSSEG, %bx
movw %bx, %cs:(start_sys_seg - setup_code)
# Move rest of setup code/data to here
movw $2048, %di # four sectors loaded by LILO
subw %si, %si
pushw %cs
popw %es
movw $SYSSEG, %ax
movw %ax, %ds
rep
movsw
movw %cs, %ax # aka SETUPSEG
movw %ax, %ds
cmpw $SIG1, (setup_sig1 - setup_code)
jne no_sig
cmpw $SIG2, (setup_sig2 - setup_code)
jne no_sig
jmp good_sig
no_sig:
lea (no_sig_mess - setup_code), %si
call prtstr
no_sig_loop:
hlt
jmp no_sig_loop
good_sig:
cmpw $0, %cs:(realmode_swtch - setup_code)
jz rmodeswtch_normal
lcall *%cs:(realmode_swtch - setup_code)
jmp rmodeswtch_end
rmodeswtch_normal:
pushw %cs
call default_switch
rmodeswtch_end:
# we get the code32 start address and modify the below 'jmpi'
# (loader may have changed it)
movl %cs:(code32_start - setup_code), %eax
movl %eax, %cs:(code32 - setup_code)
# then we load the segment descriptors
movw %cs, %ax # aka SETUPSEG
movw %ax, %ds
#
# Enable A20. This is at the very best an annoying procedure.
# A20 code ported from SYSLINUX 1.52-1.63 by H. Peter Anvin.
#
A20_TEST_LOOPS = 32 # Iterations per wait
A20_ENABLE_LOOPS = 255 # Total loops to try
a20_try_loop:
# First, see if we are on a system with no A20 gate.
a20_none:
call a20_test
jnz a20_done
# Next, try the BIOS (INT 0x15, AX=0x2401)
a20_bios:
movw $0x2401, %ax
pushfl # Be paranoid about flags
int $0x15
popfl
call a20_test
jnz a20_done
# Try enabling A20 through the keyboard controller
a20_kbc:
call empty_8042
call a20_test # Just in case the BIOS worked
jnz a20_done # but had a delayed reaction.
movb $0xD1, %al # command write
outb %al, $0x64
call empty_8042
movb $0xDF, %al # A20 on
outb %al, $0x60
call empty_8042
# Wait until a20 really *is* enabled; it can take a fair amount of
# time on certain systems; Toshiba Tecras are known to have this
# problem.
a20_kbc_wait:
xorw %cx, %cx
a20_kbc_wait_loop:
call a20_test
jnz a20_done
loop a20_kbc_wait_loop
# Final attempt: use "configuration port A"
a20_fast:
inb $0x92, %al # Configuration Port A
orb $0x02, %al # "fast A20" version
andb $0xFE, %al # don't accidentally reset
outb %al, $0x92
# Wait for configuration port A to take effect
a20_fast_wait:
xorw %cx, %cx
a20_fast_wait_loop:
call a20_test
jnz a20_done
loop a20_fast_wait_loop
# A20 is still not responding. Try frobbing it again.
#
decb (a20_tries - setup_code)
jnz a20_try_loop
movw $(a20_err_msg - setup_code), %si
call prtstr
a20_die:
hlt
jmp a20_die
a20_tries:
.byte A20_ENABLE_LOOPS
a20_err_msg:
.ascii "linux: fatal error: A20 gate not responding!"
.byte 13, 10, 0
# If we get here, all is good
a20_done:
# Leave the idt alone
# set up gdt
xorl %eax, %eax # Compute gdt_base
movw %ds, %ax # (Convert %ds:gdt to a linear ptr)
shll $4, %eax
addl $(bImage_gdt - setup_code), %eax
movl %eax, (bImage_gdt_48+2 - setup_code)
DATA32 lgdt %ds:(bImage_gdt_48 - setup_code) # load gdt with whatever is
# appropriate
# Switch to protected mode
movl %cr0, %eax
orb $CR0_PE, %al
movl %eax, %cr0
DATA32 ljmp *%ds:(code32 - setup_code)
code32:
.long 0x100000
.word __BOOT_CS, 0
# Here's a bunch of information about your current kernel..
kernel_version: .ascii "Etherboot "
.ascii VERSION
.byte 0
# This is the default real mode switch routine.
# to be called just before protected mode transition
default_switch:
cli # no interrupts allowed !
movb $0x80, %al # disable NMI for bootup
# sequence
outb %al, $0x70
lret
# This routine tests whether or not A20 is enabled. If so, it
# exits with zf = 0.
#
# The memory address used, 0x200, is the int $0x80 vector, which
# should be safe.
A20_TEST_ADDR = 4*0x80
a20_test:
pushw %cx
pushw %ax
xorw %cx, %cx
movw %cx, %fs # Low memory
decw %cx
movw %cx, %gs # High memory area
movw $A20_TEST_LOOPS, %cx
movw %fs:(A20_TEST_ADDR), %ax
pushw %ax
a20_test_wait:
incw %ax
movw %ax, %fs:(A20_TEST_ADDR)
call delay # Serialize and make delay constant
cmpw %gs:(A20_TEST_ADDR+0x10), %ax
loope a20_test_wait
popw %fs:(A20_TEST_ADDR)
popw %ax
popw %cx
ret
# This routine checks that the keyboard command queue is empty
# (after emptying the output buffers)
#
# Some machines have delusions that the keyboard buffer is always full
# with no keyboard attached...
#
# If there is no keyboard controller, we will usually get 0xff
# to all the reads. With each IO taking a microsecond and
# a timeout of 100,000 iterations, this can take about half a
# second ("delay" == outb to port 0x80). That should be ok,
# and should also be plenty of time for a real keyboard controller
# to empty.
#
empty_8042:
pushl %ecx
movl $100000, %ecx
empty_8042_loop:
decl %ecx
jz empty_8042_end_loop
call delay
inb $0x64, %al # 8042 status port
testb $1, %al # output buffer?
jz no_output
call delay
inb $0x60, %al # read it
jmp empty_8042_loop
no_output:
testb $2, %al # is input buffer full?
jnz empty_8042_loop # yes - loop
empty_8042_end_loop:
popl %ecx
# Delay is needed after doing I/O
delay:
outb %al,$0x80
ret
# Descriptor tables
#
# NOTE: The intel manual says gdt should be sixteen bytes aligned for
# efficiency reasons. However, there are machines which are known not
# to boot with misaligned GDTs, so alter this at your peril! If you alter
# GDT_ENTRY_BOOT_CS (in asm/segment.h) remember to leave at least two
# empty GDT entries (one for NULL and one reserved).
#
# NOTE: On some CPUs, the GDT must be 8 byte aligned. This is
# true for the Voyager Quad CPU card which will not boot without
# This directive. 16 byte aligment is recommended by intel.
#
.balign 16
bImage_gdt:
.fill GDT_ENTRY_BOOT_CS,8,0
.word 0xFFFF # 4Gb - (0x100000*0x1000 = 4Gb)
.word 0 # base address = 0
.word 0x9A00 # code read/exec
.word 0x00CF # granularity = 4096, 386
# (+5th nibble of limit)
.word 0xFFFF # 4Gb - (0x100000*0x1000 = 4Gb)
.word 0 # base address = 0
.word 0x9200 # data read/write
.word 0x00CF # granularity = 4096, 386
# (+5th nibble of limit)
bImage_gdt_end:
.balign 4
.word 0 # alignment byte
bImage_idt_48:
.word 0 # idt limit = 0
.long 0 # idt base = 0L
.word 0 # alignment byte
bImage_gdt_48:
.word bImage_gdt_end - bImage_gdt - 1 # gdt limit
.long bImage_gdt_48 - setup_code # gdt base (filled in later)
.section ".text16", "ax", @progbits
prefix_exit:
int $0x19 /* should try to boot machine */
prefix_exit_end:
.previous
.org (PREFIXSIZE - 4)
# Setup signature -- must be last
setup_sig1: .word SIG1
setup_sig2: .word SIG2
/* Etherboot expects to be contiguous in memory once loaded.
* The linux bImage protocol does not do this, but since we
* don't need any information that's left in the prefix, it
* doesn't matter: we just have to ensure that we make it to _start
*
* protected_start will live at 0x100000 and it will be the
* the first code called as we enter protected mode.
*/
.code32
protected_start:
/* Load segment registers */
movw $__BOOT_DS, %ax
movw %ax, %ss
movw %ax, %ds
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
/* Use the internal etherboot stack */
movl $(_prefix_stack_end - protected_start + 0x100000), %esp
pushl $0 /* No parameters to preserve for exit path */
pushl $0 /* Use prefix exit path mechanism */
jmp _start
/*
That's about it.
*/
-46
View File
@@ -1,46 +0,0 @@
/* We need a real mode stack that won't be stomped on by Etherboot
which starts at 0x20000. Choose something that's sufficiently high,
but not in DOC territory. Note that we couldn't do this in a real
.com program since stack variables are in the same segment as the
code and data, but this isn't really a .com program, it just looks
like one to make DOS load it into memory. It still has the 64kB
limitation of .com files though. */
#define STACK_SEG 0x7000
#define STACK_SIZE 0x4000
.text
.code16
.arch i386
.section ".prefix", "ax", @progbits
/* Cheat a little with the relocations: .COM files are loaded at 0x100 */
_prefix:
/* Set up temporary stack */
movw $STACK_SEG, %ax
movw %ax, %ss
movw $STACK_SIZE, %sp
pushl $0 /* No parameters to preserve for exit path */
pushw $0 /* Dummy return address - use prefix_exit */
/* Calculate segment address of image start */
pushw %cs
popw %ax
addw $(0x100/16), %ax
pushw %ax
pushw $_start
/* Calculated lcall to _start with %cs:0000 = image start */
lret
.section ".text16", "ax", @progbits
prefix_exit:
movw $0x4c00,%ax /* return to DOS */
int $0x21 /* reach this on Quit */
prefix_exit_end:
.previous
/* The body of etherboot is attached here at build time.
* Force 16 byte alignment
*/
.align 16,0
_body:
-94
View File
@@ -1,94 +0,0 @@
#include "elf.h"
.arch i386
.section ".prefix", "a", @progbits
#define LOAD_ADDR 0x10000
/* ELF Header */
.globl elf_header
elf_header:
e_ident: .byte 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
e_type: .short ET_DYN
e_machine: .short EM_386
e_version: .long 1
e_entry: .long LOAD_ADDR + _start - elf_header
e_phoff: .long elf_program_header - elf_header
e_shoff: .long 0
e_flags: .long 0
e_ehsize: .short elf_header_end - elf_header
e_phentsize: .short ELF32_PHDR_SIZE
e_phnum: .short (elf_program_header_end - elf_program_header)/ELF32_PHDR_SIZE
e_shentsize: .short 0
e_shnum: .short 0
e_shstrndx: .short 0
elf_header_end:
elf_program_header:
phdr1_p_type: .long PT_NOTE
phdr1_p_offset: .long elf_note - elf_header
phdr1_p_vaddr: .long elf_note
phdr1_p_paddr: .long elf_note
phdr1_p_filesz: .long elf_note_end - elf_note
phdr1_p_memsz: .long elf_note_end - elf_note
phdr1_p_flags: .long PF_R | PF_W | PF_X
phdr1_p_align: .long 0
/* The decompressor */
phdr2_p_type: .long PT_LOAD
phdr2_p_offset: .long 0
phdr2_p_vaddr: .long elf_header
phdr2_p_paddr: .long LOAD_ADDR
phdr2_p_filesz: .long _verbatim_size
phdr2_p_memsz: .long _image_size
phdr2_p_flags: .long PF_R | PF_W | PF_X
phdr2_p_align: .long 16
elf_program_header_end:
.globl elf_note
elf_note:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_NAME
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz "Etherboot"
4:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_VERSION
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz VERSION
4:
#if 0
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_CHECKSUM
1: .asciz "ELFBoot"
2:
.balign 4
3:
.word 0
4:
#endif
.balign 4
elf_note_end:
/* Dummy routines to satisfy the build */
.section ".text16", "ax", @progbits
prefix_exit:
prefix_exit_end:
.previous
-94
View File
@@ -1,94 +0,0 @@
#include "elf.h"
.arch i386
.section ".prefix", "a", @progbits
#define LOAD_ADDR 0x10000
/* ELF Header */
.globl elf_header
elf_header:
e_ident: .byte 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
e_type: .short ET_EXEC
e_machine: .short EM_386
e_version: .long 1
e_entry: .long LOAD_ADDR + _start - elf_header
e_phoff: .long elf_program_header - elf_header
e_shoff: .long 0
e_flags: .long 0
e_ehsize: .short elf_header_end - elf_header
e_phentsize: .short ELF32_PHDR_SIZE
e_phnum: .short (elf_program_header_end - elf_program_header)/ELF32_PHDR_SIZE
e_shentsize: .short 0
e_shnum: .short 0
e_shstrndx: .short 0
elf_header_end:
elf_program_header:
phdr1_p_type: .long PT_NOTE
phdr1_p_offset: .long elf_note - elf_header
phdr1_p_vaddr: .long elf_note
phdr1_p_paddr: .long elf_note
phdr1_p_filesz: .long elf_note_end - elf_note
phdr1_p_memsz: .long elf_note_end - elf_note
phdr1_p_flags: .long PF_R | PF_W | PF_X
phdr1_p_align: .long 0
/* The decompressor */
phdr2_p_type: .long PT_LOAD
phdr2_p_offset: .long 0
phdr2_p_vaddr: .long elf_header
phdr2_p_paddr: .long LOAD_ADDR
phdr2_p_filesz: .long _verbatim_size
phdr2_p_memsz: .long _image_size
phdr2_p_flags: .long PF_R | PF_W | PF_X
phdr2_p_align: .long 16
elf_program_header_end:
.globl elf_note
elf_note:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_NAME
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz "Etherboot"
4:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_VERSION
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz VERSION
4:
#if 0
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_CHECKSUM
1: .asciz "ELFBoot"
2:
.balign 4
3:
.word 0
4:
#endif
.balign 4
elf_note_end:
/* Dummy routines to satisfy the build */
.section ".text16", "ax", @progbits
prefix_exit:
prefix_exit_end:
.previous
-41
View File
@@ -1,41 +0,0 @@
/*
Prefix for .exe images
Doesn't work yet, even though it starts off the same as a .com
image as shown by DOS debug.
*/
.text
.code16
.arch i386
.section ".prefix", "ax", @progbits
_prefix:
.byte 'M', 'Z'
.short _exe_size_tail /* tail */
.short _exe_size_pages /* pages */
.short 0 /* relocations */
.short 2 /* header paras */
.short _exe_bss_size /* min */
.short 0xFFFF /* max paras */
.short _exe_ss_offset /* SS */
.short _stack_size /* SP */
.short 0 /* checksum */
.short 0 /* IP */
.short 0 /* CS */
.short 0x1C /* reloc offset */
.short 0 /* overlay number */
.short 0 /* fill */
.short 0 /* fill */
.section ".text16", "ax", @progbits
prefix_exit:
movw $0x4c00,%ax /* return to DOS */
int $0x21 /* reach this on Quit */
prefix_exit_end:
.previous
/* The body of etherboot is attached here at build time.
* Force 16 byte alignment
*/
.align 16,0
_body:
-161
View File
@@ -1,161 +0,0 @@
#include "elf.h"
.arch sledgehammer
.code32
.equ FLAT_CODE_SEG,_pmcs-_gdt
.equ FLAT_DATA_SEG,_pmds-_gdt
.equ MSR_K6_EFER, 0xC0000080
.equ EFER_LME, 0x00000100
.equ X86_CR4_PAE, 0x00000020
.equ CR0_PG, 0x80000000
.section ".prefix", "ax", @progbits
#define LOAD_ADDR 0x10000
/* ELF Header */
.globl elf_header
elf_header:
e_ident: .byte 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
e_type: .short ET_DYN
e_machine: .short EM_X86_64
e_version: .long 1
e_entry: .long LOAD_ADDR + elf_start - elf_header
e_phoff: .long elf_program_header - elf_header
e_shoff: .long 0
e_flags: .long 0
e_ehsize: .short elf_header_end - elf_header
e_phentsize: .short ELF32_PHDR_SIZE
e_phnum: .short (elf_program_header_end - elf_program_header)/ELF32_PHDR_SIZE
e_shentsize: .short 0
e_shnum: .short 0
e_shstrndx: .short 0
elf_header_end:
elf_program_header:
phdr1_p_type: .long PT_NOTE
phdr1_p_offset: .long elf_note - elf_header
phdr1_p_vaddr: .long elf_note
phdr1_p_paddr: .long elf_note
phdr1_p_filesz: .long elf_note_end - elf_note
phdr1_p_memsz: .long elf_note_end - elf_note
phdr1_p_flags: .long PF_R | PF_W | PF_X
phdr1_p_align: .long 0
/* The decompressor */
phdr2_p_type: .long PT_LOAD
phdr2_p_offset: .long 0
phdr2_p_vaddr: .long elf_header
phdr2_p_paddr: .long LOAD_ADDR
phdr2_p_filesz: .long _verbatim_size
phdr2_p_memsz: .long _image_size
phdr2_p_flags: .long PF_R | PF_W | PF_X
phdr2_p_align: .long 16
elf_program_header_end:
.globl elf_note
elf_note:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_NAME
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz "Etherboot"
4:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_VERSION
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz VERSION
4:
#if 0
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_CHECKSUM
1: .asciz "ELFBoot"
2:
.balign 4
3:
.word 0
4:
#endif
.balign 4
elf_note_end:
elf_start:
.code64
/* Reload the gdt to something I know */
leaq _gdt(%rip), %rax
movq %rax, 0x02 + gdtptr(%rip)
lgdt gdtptr(%rip)
/* Enter 32bit compatibility mode */
leaq elf_start32(%rip), %rax
movl %eax, 0x00 + elf_start32_addr(%rip)
ljmp *elf_start32_addr(%rip)
elf_start32:
.code32
/* Reload the data segments */
movl $FLAT_DATA_SEG, %eax
movl %eax, %ds
movl %eax, %es
movl %eax, %ss
/* Disable paging */
movl %cr0, %eax
andl $~CR0_PG, %eax
movl %eax, %cr0
/* Disable long mode */
movl $MSR_K6_EFER, %ecx
rdmsr
andl $~EFER_LME, %eax
wrmsr
/* Disable PAE */
movl %cr4, %eax
andl $~X86_CR4_PAE, %eax
movl %eax, %cr4
/* Save the first argument */
pushl %ebx
jmp _start
gdtptr:
.word _gdt_end - _gdt -1
.long _gdt
.long 0
_gdt:
elf_start32_addr:
.long elf_start32
.long FLAT_CODE_SEG
_pmcs:
/* 32 bit protected mode code segment, base 0 */
.word 0xffff,0
.byte 0,0x9f,0xcf,0
_pmds:
/* 32 bit protected mode data segment, base 0 */
.word 0xffff,0
.byte 0,0x93,0xcf,0
_gdt_end:
/* Dummy routines to satisfy the build */
.section ".text16", "ax", @progbits
prefix_exit:
prefix_exit_end:
.previous
-161
View File
@@ -1,161 +0,0 @@
#include "elf.h"
.arch sledgehammer
.code32
.equ FLAT_CODE_SEG,_pmcs-_gdt
.equ FLAT_DATA_SEG,_pmds-_gdt
.equ MSR_K6_EFER, 0xC0000080
.equ EFER_LME, 0x00000100
.equ X86_CR4_PAE, 0x00000020
.equ CR0_PG, 0x80000000
.section ".prefix", "ax", @progbits
#define LOAD_ADDR 0x10000
/* ELF Header */
.globl elf_header
elf_header:
e_ident: .byte 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
e_type: .short ET_EXEC
e_machine: .short EM_X86_64
e_version: .long 1
e_entry: .long LOAD_ADDR + elf_start - elf_header
e_phoff: .long elf_program_header - elf_header
e_shoff: .long 0
e_flags: .long 0
e_ehsize: .short elf_header_end - elf_header
e_phentsize: .short ELF32_PHDR_SIZE
e_phnum: .short (elf_program_header_end - elf_program_header)/ELF32_PHDR_SIZE
e_shentsize: .short 0
e_shnum: .short 0
e_shstrndx: .short 0
elf_header_end:
elf_program_header:
phdr1_p_type: .long PT_NOTE
phdr1_p_offset: .long elf_note - elf_header
phdr1_p_vaddr: .long elf_note
phdr1_p_paddr: .long elf_note
phdr1_p_filesz: .long elf_note_end - elf_note
phdr1_p_memsz: .long elf_note_end - elf_note
phdr1_p_flags: .long PF_R | PF_W | PF_X
phdr1_p_align: .long 0
/* The decompressor */
phdr2_p_type: .long PT_LOAD
phdr2_p_offset: .long 0
phdr2_p_vaddr: .long elf_header
phdr2_p_paddr: .long LOAD_ADDR
phdr2_p_filesz: .long _verbatim_size
phdr2_p_memsz: .long _image_size
phdr2_p_flags: .long PF_R | PF_W | PF_X
phdr2_p_align: .long 16
elf_program_header_end:
.globl elf_note
elf_note:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_NAME
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz "Etherboot"
4:
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_VERSION
1: .asciz "ELFBoot"
2:
.balign 4
3:
.asciz VERSION
4:
#if 0
.balign 4
.int 2f - 1f
.int 4f - 3f
.int EIN_PROGRAM_CHECKSUM
1: .asciz "ELFBoot"
2:
.balign 4
3:
.word 0
4:
#endif
.balign 4
elf_note_end:
elf_start:
.code64
/* Reload the gdt to something I know */
leaq _gdt(%rip), %rax
movq %rax, 0x02 + gdtptr(%rip)
lgdt gdtptr(%rip)
/* Enter 32bit compatibility mode */
leaq elf_start32(%rip), %rax
movl %eax, 0x00 + elf_start32_addr(%rip)
ljmp *elf_start32_addr(%rip)
elf_start32:
.code32
/* Reload the data segments */
movl $FLAT_DATA_SEG, %eax
movl %eax, %ds
movl %eax, %es
movl %eax, %ss
/* Disable paging */
movl %cr0, %eax
andl $~CR0_PG, %eax
movl %eax, %cr0
/* Disable long mode */
movl $MSR_K6_EFER, %ecx
rdmsr
andl $~EFER_LME, %eax
wrmsr
/* Disable PAE */
movl %cr4, %eax
andl $~X86_CR4_PAE, %eax
movl %eax, %cr4
/* Save the first argument */
pushl %ebx
jmp _start
gdtptr:
.word _gdt_end - _gdt -1
.long _gdt
.long 0
_gdt:
elf_start32_addr:
.long elf_start32
.long FLAT_CODE_SEG
_pmcs:
/* 32 bit protected mode code segment, base 0 */
.word 0xffff,0
.byte 0,0x9f,0xcf,0
_pmds:
/* 32 bit protected mode data segment, base 0 */
.word 0xffff,0
.byte 0,0x93,0xcf,0
_gdt_end:
/* Dummy routines to satisfy the build */
.section ".text16", "ax", @progbits
prefix_exit:
prefix_exit_end:
.previous
-6
View File
@@ -109,9 +109,6 @@ REQUIRE_OBJECT ( pxe_call );
#ifdef DOWNLOAD_PROTO_TFTP
REQUIRE_OBJECT ( tftp );
#endif
#ifdef DOWNLOAD_PROTO_NFS
REQUIRE_OBJECT ( nfs );
#endif
#ifdef DOWNLOAD_PROTO_HTTP
REQUIRE_OBJECT ( http );
#endif
@@ -149,9 +146,6 @@ REQUIRE_OBJECT ( ib_srpboot );
#ifdef DNS_RESOLVER
REQUIRE_OBJECT ( dns );
#endif
#ifdef NMB_RESOLVER
REQUIRE_OBJECT ( nmb );
#endif
/*
* Drag in all requested image formats
-3
View File
@@ -54,13 +54,11 @@ FILE_LICENCE ( GPL2_OR_LATER );
*/
#define DOWNLOAD_PROTO_TFTP /* Trivial File Transfer Protocol */
#undef DOWNLOAD_PROTO_NFS /* Network File System */
#define DOWNLOAD_PROTO_HTTP /* Hypertext Transfer Protocol */
#undef DOWNLOAD_PROTO_HTTPS /* Secure Hypertext Transfer Protocol */
#undef DOWNLOAD_PROTO_FTP /* File Transfer Protocol */
#undef DOWNLOAD_PROTO_TFTM /* Multicast Trivial File Transfer Protocol */
#undef DOWNLOAD_PROTO_SLAM /* Scalable Local Area Multicast */
#undef DOWNLOAD_PROTO_FSP /* FSP? */
/*
* SAN boot protocols
@@ -85,7 +83,6 @@ FILE_LICENCE ( GPL2_OR_LATER );
*/
#define DNS_RESOLVER /* DNS resolver */
#undef NMB_RESOLVER /* NMB resolver */
/*
* Image types
-2
View File
@@ -9,8 +9,6 @@ Literature dealing with the network protocols:
DHCP - RFC2131, RFC2132 (options)
TFTP - RFC1350, RFC2347 (options), RFC2348 (blocksize), RFC2349 (tsize)
RPC - RFC1831, RFC1832 (XDR), RFC1833 (rpcbind/portmapper)
NFS - RFC1094, RFC1813 (v3, useful for clarifications, not implemented)
IGMP - RFC1112
**************************************************************************/
+1 -1
View File
@@ -1426,7 +1426,7 @@ struct setting filename_setting __setting = {
/** Root path setting */
struct setting root_path_setting __setting = {
.name = "root-path",
.description = "NFS/iSCSI root path",
.description = "iSCSI root path",
.tag = DHCP_ROOT_PATH,
.type = &setting_type_string,
};
+5 -4
View File
@@ -225,12 +225,13 @@ int unparse_uri ( char *buf, size_t size, struct uri *uri,
dump_uri ( uri );
DBG ( "\n" );
/* Ensure buffer is NUL-terminated */
if ( size )
buf[0] = '\0';
/* Special-case NULL URI */
if ( ! uri ) {
if ( size )
buf[0] = '\0';
if ( ! uri )
return 0;
}
/* Iterate through requested fields */
for ( i = URI_FIRST_FIELD; i <= URI_LAST_FIELD; i++ ) {
-1
View File
@@ -9,7 +9,6 @@ FILE_LICENCE ( GPL2_OR_LATER );
/* Protocol numbers */
#define IP_ICMP 1
#define IP_IGMP 2
#define IP_TCP 6
#define IP_UDP 17
#define IP_ICMP6 58
-42
View File
@@ -1,42 +0,0 @@
#ifndef IGMP_H
#define IGMP_H
#include "stdint.h"
#include <gpxe/in.h>
#define IGMP_QUERY 0x11
#define IGMPv1_REPORT 0x12
#define IGMPv2_REPORT 0x16
#define IGMP_LEAVE 0x17
#define GROUP_ALL_HOSTS 0xe0000001 /* 224.0.0.1 Host byte order */
#define MULTICAST_MASK 0xf0000000
#define MULTICAST_NETWORK 0xe0000000
enum {
IGMP_SERVER,
MAX_IGMP
};
struct igmp {
uint8_t type;
uint8_t response_time;
uint16_t chksum;
struct in_addr group;
} PACKED;
struct igmp_ip_t { /* Format of an igmp ip packet */
struct iphdr ip;
uint8_t router_alert[4]; /* Router alert option */
struct igmp igmp;
} PACKED;
struct igmptable_t {
struct in_addr group;
unsigned long time;
} PACKED;
extern void join_group ( int slot, unsigned long group );
extern void leave_group ( int slot );
#endif /* IGMP_H */
-63
View File
@@ -1,63 +0,0 @@
#ifndef _NFS_H
#define _NFS_H
#define SUNRPC_PORT 111
#define PROG_PORTMAP 100000
#define PROG_NFS 100003
#define PROG_MOUNT 100005
#define MSG_CALL 0
#define MSG_REPLY 1
#define PORTMAP_GETPORT 3
#define MOUNT_ADDENTRY 1
#define MOUNT_UMOUNTALL 4
#define NFS_LOOKUP 4
#define NFS_READLINK 5
#define NFS_READ 6
#define NFS_FHSIZE 32
#define NFSERR_PERM 1
#define NFSERR_NOENT 2
#define NFSERR_ACCES 13
#define NFSERR_ISDIR 21
#define NFSERR_INVAL 22
/* Block size used for NFS read accesses. A RPC reply packet (including all
* headers) must fit within a single Ethernet frame to avoid fragmentation.
* Chosen to be a power of two, as most NFS servers are optimized for this. */
#define NFS_READ_SIZE 1024
#define NFS_MAXLINKDEPTH 16
struct rpc_t {
struct iphdr ip;
struct udphdr udp;
union {
uint8_t data[300]; /* longest RPC call must fit!!!! */
struct {
uint32_t id;
uint32_t type;
uint32_t rpcvers;
uint32_t prog;
uint32_t vers;
uint32_t proc;
uint32_t data[1];
} call;
struct {
uint32_t id;
uint32_t type;
uint32_t rstatus;
uint32_t verifier;
uint32_t v2;
uint32_t astatus;
uint32_t data[1];
} reply;
} u;
} PACKED;
#endif /* _NFS_H */
-22
View File
@@ -1,22 +0,0 @@
#ifndef NMB_H
#define NMB_H
#include <gpxe/dns.h>
/*
* NetBIOS name query packets are basically the same as DNS packets,
* though the resource record format is different.
*
*/
#define DNS_TYPE_NB 0x20
#define DNS_FLAG_BROADCAST ( 0x01 << 4 )
#define NBNS_UDP_PORT 137
struct dns_rr_info_nb {
struct dns_rr_info info;
uint16_t nb_flags;
struct in_addr nb_address;
} __attribute__ (( packed ));
#endif /* NMB_H */
+2 -1
View File
@@ -452,11 +452,12 @@ static void http_step ( struct process *process ) {
/* Send GET request */
if ( ( rc = xfer_printf ( &http->socket,
"GET %s HTTP/1.0\r\n"
"GET %s%s HTTP/1.0\r\n"
"User-Agent: gPXE/" VERSION "\r\n"
"%s%s%s"
"Host: %s\r\n"
"\r\n",
http->uri->path ? "" : "/",
request,
( user ?
"Authorization: Basic " : "" ),
-243
View File
@@ -1,243 +0,0 @@
/*********************************************************************\
* Copyright (c) 2005 by Radim Kolar (hsn-sendmail.cz) *
* *
* You may copy or modify this file in any manner you wish, provided *
* that this notice is always included, and that you hold the author *
* harmless for any loss or damage resulting from the installation or *
* use of this software. *
* *
* This file provides support for FSP v2 protocol written from scratch *
* by Radim Kolar, FSP project leader. *
* *
* ABOUT FSP *
* FSP is a lightweight file transfer protocol and is being used for *
* booting, Internet firmware updates, embedded devices and in *
* wireless applications. FSP is very easy to implement; contact Radim *
* Kolar if you need hand optimized assembler FSP stacks for various *
* microcontrollers, CPUs or consultations. *
* http://fsp.sourceforge.net/ *
* *
* REVISION HISTORY *
* 1.0 2005-03-17 rkolar Initial coding *
* 1.1 2005-03-24 rkolar We really need to send CC_BYE to the server *
* at end of transfer, because next stage boot *
* loader is unable to contact FSP server *
* until session timeouts. *
* 1.2 2005-03-26 rkolar We need to query filesize in advance, *
* because NBI loader do not reads file until *
* eof is reached.
* REMARKS *
* there is no support for selecting port number of fsp server, maybe *
* we should parse fsp:// URLs in boot image filename. *
* this implementation has filename limit 255 chars. *
\*********************************************************************/
#ifdef DOWNLOAD_PROTO_FSP
#define FSP_PORT 21
/* FSP commands */
#define CC_GET_FILE 0x42
#define CC_BYE 0x4A
#define CC_ERR 0x40
#define CC_STAT 0x4D
/* etherboot limits */
#define FSP_MAXFILENAME 255
struct fsp_info {
in_addr server_ip;
uint16_t server_port;
uint16_t local_port;
const char *filename;
int (*fnc)(unsigned char *, unsigned int, unsigned int, int);
};
struct fsp_header {
uint8_t cmd;
uint8_t sum;
uint16_t key;
uint16_t seq;
uint16_t len;
uint32_t pos;
} PACKED;
#define FSP_MAXPAYLOAD (ETH_MAX_MTU - \
(sizeof(struct iphdr) + sizeof(struct udphdr) + sizeof(struct fsp_header)))
static struct fsp_request {
struct iphdr ip;
struct udphdr udp;
struct fsp_header fsp;
unsigned char data[FSP_MAXFILENAME + 1 + 2];
} request;
struct fsp_reply {
struct iphdr ip;
struct udphdr udp;
struct fsp_header fsp;
unsigned char data[FSP_MAXPAYLOAD];
} PACKED;
static int await_fsp(int ival, void *ptr, unsigned short ptype __unused,
struct iphdr *ip, struct udphdr *udp)
{
if(!udp)
return 0;
if (ip->dest.s_addr != arptable[ARP_CLIENT].ipaddr.s_addr)
return 0;
if (ntohs(udp->dest) != ival)
return 0;
if (ntohs(udp->len) < 12+sizeof(struct udphdr))
return 0;
return 1;
}
static int proto_fsp(struct fsp_info *info)
{
uint32_t filepos;
uint32_t filelength=0;
int i,retry;
uint16_t reqlen;
struct fsp_reply *reply;
int block=1;
/* prepare FSP request packet */
filepos=0;
i=strlen(info->filename);
if(i>FSP_MAXFILENAME)
{
printf("Boot filename is too long.\n");
return 0;
}
strcpy(request.data,info->filename);
*(uint16_t *)(request.data+i+1)=htons(FSP_MAXPAYLOAD);
request.fsp.len=htons(i+1);
reqlen=i+3+12;
rx_qdrain();
retry=0;
/* main loop */
for(;;) {
int sum;
long timeout;
/* query filelength if not known */
if(filelength == 0)
request.fsp.cmd=CC_STAT;
/* prepare request packet */
request.fsp.pos=htonl(filepos);
request.fsp.seq=random();
request.fsp.sum=0;
for(i=0,sum=reqlen;i<reqlen;i++)
{
sum += ((uint8_t *)&request.fsp)[i];
}
request.fsp.sum= sum + (sum >> 8);
/* send request */
if (!udp_transmit(info->server_ip.s_addr, info->local_port,
info->server_port, sizeof(request.ip) +
sizeof(request.udp) + reqlen, &request))
return (0);
/* wait for retry */
#ifdef CONGESTED
timeout =
rfc2131_sleep_interval(filepos ? TFTP_REXMT : TIMEOUT, retry);
#else
timeout = rfc2131_sleep_interval(TIMEOUT, retry);
#endif
retry++;
if (!await_reply(await_fsp, info->local_port, NULL, timeout))
continue;
reply=(struct fsp_reply *) &nic.packet[ETH_HLEN];
/* check received packet */
if (reply->fsp.seq != request.fsp.seq)
continue;
reply->udp.len=ntohs(reply->udp.len)-sizeof(struct udphdr);
if(reply->udp.len < ntohs(reply->fsp.len) + 12 )
continue;
sum=-reply->fsp.sum;
for(i=0;i<reply->udp.len;i++)
{
sum += ((uint8_t *)&(reply->fsp))[i];
}
sum = (sum + (sum >> 8)) & 0xff;
if(sum != reply->fsp.sum)
{
printf("FSP checksum failed. computed %d, but packet has %d.\n",sum,reply->fsp.sum);
continue;
}
if(reply->fsp.cmd == CC_ERR)
{
printf("\nFSP error: %s",info->filename);
if(reply->fsp.len)
printf(" [%s]",reply->data);
printf("\n");
return 0;
}
if(reply->fsp.cmd == CC_BYE && filelength == 1)
{
info->fnc(request.data,block,1,1);
return 1;
}
if(reply->fsp.cmd == CC_STAT)
{
if(reply->data[8] == 0)
{
/* file not found, etc. */
filelength=0xffffffff;
} else
{
filelength= ntohl(*((uint32_t *)&reply->data[4]));
}
request.fsp.cmd = CC_GET_FILE;
request.fsp.key = reply->fsp.key;
retry=0;
continue;
}
if(reply->fsp.cmd == CC_GET_FILE)
{
if(ntohl(reply->fsp.pos) != filepos)
continue;
request.fsp.key = reply->fsp.key;
retry=0;
i=ntohs(reply->fsp.len);
if(i == 1)
{
request.fsp.cmd=CC_BYE;
request.data[0]=reply->data[0];
continue;
}
/* let last byte alone */
if(i >= filelength)
i = filelength - 1;
if(!info->fnc(reply->data,block++,i,0))
return 0;
filepos += i;
filelength -= i;
}
}
return 0;
}
int url_fsp(const char *name, int (*fnc)(unsigned char *, unsigned int, unsigned int, int))
{
struct fsp_info info;
/* Set the defaults */
info.server_ip.s_addr = arptable[ARP_SERVER].ipaddr.s_addr;
info.server_port = FSP_PORT;
info.local_port = 1024 + random() & 0xfbff;
info.fnc = fnc;
/* Now parse the url */
/* printf("fsp-URI: [%s]\n", name); */
/* quick hack for now */
info.filename=name;
return proto_fsp(&info);
}
#endif
-167
View File
@@ -1,167 +0,0 @@
/*
* Eric Biederman wrote this code originally.
*
*/
#if 0
#include <ip.h>
#include <igmp.h>
static unsigned long last_igmpv1 = 0;
static struct igmptable_t igmptable[MAX_IGMP];
static long rfc1112_sleep_interval ( long base, int exp ) {
unsigned long divisor, tmo;
if ( exp > BACKOFF_LIMIT )
exp = BACKOFF_LIMIT;
divisor = RAND_MAX / ( base << exp );
tmo = random() / divisor;
return tmo;
}
static void send_igmp_reports ( unsigned long now ) {
struct igmp_ip_t igmp;
int i;
for ( i = 0 ; i < MAX_IGMP ; i++ ) {
if ( ! igmptable[i].time )
continue;
if ( now < igmptable[i].time )
continue;
igmp.router_alert[0] = 0x94;
igmp.router_alert[1] = 0x04;
igmp.router_alert[2] = 0;
igmp.router_alert[3] = 0;
build_ip_hdr ( igmptable[i].group.s_addr, 1, IP_IGMP,
sizeof ( igmp.router_alert ),
sizeof ( igmp ), &igmp );
igmp.igmp.type = IGMPv2_REPORT;
if ( last_igmpv1 &&
( now < last_igmpv1 + IGMPv1_ROUTER_PRESENT_TIMEOUT ) ) {
igmp.igmp.type = IGMPv1_REPORT;
}
igmp.igmp.response_time = 0;
igmp.igmp.chksum = 0;
igmp.igmp.group.s_addr = igmptable[i].group.s_addr;
igmp.igmp.chksum = ipchksum ( &igmp.igmp,
sizeof ( igmp.igmp ) );
ip_transmit ( sizeof ( igmp ), &igmp );
DBG ( "IGMP sent report to %s\n", inet_ntoa ( igmp.igmp.group ) );
/* Don't send another igmp report until asked */
igmptable[i].time = 0;
}
}
static void process_igmp ( unsigned long now, unsigned short ptype __unused,
struct iphdr *ip ) {
struct igmp *igmp;
int i;
unsigned iplen;
if ( ( ! ip ) || ( ip->protocol != IP_IGMP ) ||
( nic.packetlen < ( sizeof ( struct iphdr ) +
sizeof ( struct igmp ) ) ) ) {
return;
}
iplen = ( ip->verhdrlen & 0xf ) * 4;
igmp = ( struct igmp * ) &nic.packet[ sizeof( struct iphdr ) ];
if ( ipchksum ( igmp, ntohs ( ip->len ) - iplen ) != 0 )
return;
if ( ( igmp->type == IGMP_QUERY ) &&
( ip->dest.s_addr == htonl ( GROUP_ALL_HOSTS ) ) ) {
unsigned long interval = IGMP_INTERVAL;
if ( igmp->response_time == 0 ) {
last_igmpv1 = now;
} else {
interval = ( igmp->response_time * TICKS_PER_SEC ) /10;
}
DBG ( "IGMP received query for %s\n", inet_ntoa ( igmp->group ) );
for ( i = 0 ; i < MAX_IGMP ; i++ ) {
uint32_t group = igmptable[i].group.s_addr;
if ( ( group == 0 ) ||
( group == igmp->group.s_addr ) ) {
unsigned long time;
time = currticks() +
rfc1112_sleep_interval ( interval, 0 );
if ( time < igmptable[i].time ) {
igmptable[i].time = time;
}
}
}
}
if ( ( ( igmp->type == IGMPv1_REPORT ) ||
( igmp->type == IGMPv2_REPORT ) ) &&
( ip->dest.s_addr == igmp->group.s_addr ) ) {
DBG ( "IGMP received report for %s\n",
inet_ntoa ( igmp->group ) );
for ( i = 0 ; i < MAX_IGMP ; i++ ) {
if ( ( igmptable[i].group.s_addr ==
igmp->group.s_addr ) &&
( igmptable[i].time != 0 ) ) {
igmptable[i].time = 0;
}
}
}
}
struct background igmp_background __background = {
.send = send_igmp_reports,
.process = process_igmp,
};
void leave_group ( int slot ) {
/* Be very stupid and always send a leave group message if
* I have subscribed. Imperfect but it is standards
* compliant, easy and reliable to implement.
*
* The optimal group leave method is to only send leave when,
* we were the last host to respond to a query on this group,
* and igmpv1 compatibility is not enabled.
*/
if ( igmptable[slot].group.s_addr ) {
struct igmp_ip_t igmp;
igmp.router_alert[0] = 0x94;
igmp.router_alert[1] = 0x04;
igmp.router_alert[2] = 0;
igmp.router_alert[3] = 0;
build_ip_hdr ( htonl ( GROUP_ALL_HOSTS ), 1, IP_IGMP,
sizeof ( igmp.router_alert ), sizeof ( igmp ),
&igmp);
igmp.igmp.type = IGMP_LEAVE;
igmp.igmp.response_time = 0;
igmp.igmp.chksum = 0;
igmp.igmp.group.s_addr = igmptable[slot].group.s_addr;
igmp.igmp.chksum = ipchksum ( &igmp.igmp, sizeof ( igmp ) );
ip_transmit ( sizeof ( igmp ), &igmp );
DBG ( "IGMP left group %s\n", inet_ntoa ( igmp.igmp.group ) );
}
memset ( &igmptable[slot], 0, sizeof ( igmptable[0] ) );
}
void join_group ( int slot, unsigned long group ) {
/* I have already joined */
if ( igmptable[slot].group.s_addr == group )
return;
if ( igmptable[slot].group.s_addr ) {
leave_group ( slot );
}
/* Only join a group if we are given a multicast ip, this way
* code can be given a non-multicast (broadcast or unicast ip)
* and still work...
*/
if ( ( group & htonl ( MULTICAST_MASK ) ) ==
htonl ( MULTICAST_NETWORK ) ) {
igmptable[slot].group.s_addr = group;
igmptable[slot].time = currticks();
}
}
#endif
-616
View File
@@ -1,616 +0,0 @@
#if 0
#include <gpxe/init.h>
#include <gpxe/in.h>
/* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
* large portions are copied verbatim) as distributed in OSKit 0.97. A few
* changes were necessary to adapt the code to Etherboot and to fix several
* inconsistencies. Also the RPC message preparation is done "by hand" to
* avoid adding netsprintf() which I find hard to understand and use. */
/* NOTE 2: Etherboot does not care about things beyond the kernel image, so
* it loads the kernel image off the boot server (ARP_SERVER) and does not
* access the client root disk (root-path in dhcpd.conf), which would use
* ARP_ROOTSERVER. The root disk is something the operating system we are
* about to load needs to use. This is different from the OSKit 0.97 logic. */
/* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
* If a symlink is encountered, it is followed as far as possible (recursion
* possible, maximum 16 steps). There is no clearing of ".."'s inside the
* path, so please DON'T DO THAT. thx. */
#define START_OPORT 700 /* mountd usually insists on secure ports */
#define OPORT_SWEEP 200 /* make sure we don't leave secure range */
static int oport = START_OPORT;
static struct sockaddr_in mount_server;
static struct sockaddr_in nfs_server;
static unsigned long rpc_id;
/**************************************************************************
RPC_INIT - set up the ID counter to something fairly random
**************************************************************************/
void rpc_init(void)
{
unsigned long t;
t = currticks();
rpc_id = t ^ (t << 8) ^ (t << 16);
}
/**************************************************************************
RPC_PRINTERROR - Print a low level RPC error message
**************************************************************************/
static void rpc_printerror(struct rpc_t *rpc)
{
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus) {
/* rpc_printerror() is called for any RPC related error,
* suppress output if no low level RPC error happened. */
DBG("RPC error: (%ld,%ld,%ld)\n", ntohl(rpc->u.reply.rstatus),
ntohl(rpc->u.reply.verifier),
ntohl(rpc->u.reply.astatus));
}
}
/**************************************************************************
AWAIT_RPC - Wait for an rpc packet
**************************************************************************/
static int await_rpc(int ival, void *ptr,
unsigned short ptype __unused, struct iphdr *ip,
struct udphdr *udp, struct tcphdr *tcp __unused)
{
struct rpc_t *rpc;
if (!udp)
return 0;
if (arptable[ARP_CLIENT].ipaddr.s_addr != ip->dest.s_addr)
return 0;
if (ntohs(udp->dest) != ival)
return 0;
if (nic.packetlen < ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr) + 8)
return 0;
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (*(unsigned long *)ptr != ntohl(rpc->u.reply.id))
return 0;
if (MSG_REPLY != ntohl(rpc->u.reply.type))
return 0;
return 1;
}
/**************************************************************************
RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************/
static int rpc_lookup(struct sockaddr_in *addr, int prog, int ver, int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_PORTMAP);
buf.u.call.vers = htonl(2); /* portmapper is version 2 */
buf.u.call.proc = htonl(PORTMAP_GETPORT);
p = (long *)buf.u.call.data;
*p++ = 0; *p++ = 0; /* auth credential */
*p++ = 0; *p++ = 0; /* auth verifier */
*p++ = htonl(prog);
*p++ = htonl(ver);
*p++ = htonl(IP_UDP);
*p++ = 0;
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout;
udp_transmit(addr->sin_addr.s_addr, sport, addr->sin_port,
(char *)p - (char *)&buf, &buf);
timeout = rfc2131_sleep_interval(TIMEOUT, retries);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus) {
rpc_printerror(rpc);
return 0;
} else {
return ntohl(rpc->u.reply.data[0]);
}
}
}
return 0;
}
/**************************************************************************
RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
**************************************************************************/
static long *rpc_add_credentials(long *p)
{
int hl;
/* Here's the executive summary on authentication requirements of the
* various NFS server implementations: Linux accepts both AUTH_NONE
* and AUTH_UNIX authentication (also accepts an empty hostname field
* in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
* AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
* scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
* it (if the BOOTP/DHCP reply didn't give one, just use an empty
* hostname). */
hl = (hostnamelen + 3) & ~3;
/* Provide an AUTH_UNIX credential. */
*p++ = htonl(1); /* AUTH_UNIX */
*p++ = htonl(hl+20); /* auth length */
*p++ = htonl(0); /* stamp */
*p++ = htonl(hostnamelen); /* hostname string */
if (hostnamelen & 3) {
*(p + hostnamelen / 4) = 0; /* add zero padding */
}
memcpy(p, hostname, hostnamelen);
p += hl / 4;
*p++ = 0; /* uid */
*p++ = 0; /* gid */
*p++ = 0; /* auxiliary gid list */
/* Provide an AUTH_NONE verifier. */
*p++ = 0; /* AUTH_NONE */
*p++ = 0; /* auth length */
return p;
}
/**************************************************************************
NFS_PRINTERROR - Print a NFS error message
**************************************************************************/
static void nfs_printerror(int err)
{
switch (-err) {
case NFSERR_PERM:
printf("Not owner\n");
break;
case NFSERR_NOENT:
printf("No such file or directory\n");
break;
case NFSERR_ACCES:
printf("Permission denied\n");
break;
case NFSERR_ISDIR:
printf("Directory given where filename expected\n");
break;
case NFSERR_INVAL:
printf("Invalid filehandle\n");
break; // INVAL is not defined in NFSv2, some NFS-servers
// seem to use it in answers to v2 nevertheless.
case 9998:
printf("low-level RPC failure (parameter decoding problem?)\n");
break;
case 9999:
printf("low-level RPC failure (authentication problem?)\n");
break;
default:
printf("Unknown NFS error %d\n", -err);
}
}
/**************************************************************************
NFS_MOUNT - Mount an NFS Filesystem
**************************************************************************/
static int nfs_mount(struct sockaddr_in *server, char *path, char *fh, int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
int pathlen = strlen(path);
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_MOUNT);
buf.u.call.vers = htonl(1); /* mountd is version 1 */
buf.u.call.proc = htonl(MOUNT_ADDENTRY);
p = rpc_add_credentials((long *)buf.u.call.data);
*p++ = htonl(pathlen);
if (pathlen & 3) {
*(p + pathlen / 4) = 0; /* add zero padding */
}
memcpy(p, path, pathlen);
p += (pathlen + 3) / 4;
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout;
udp_transmit(server->sin_addr.s_addr, sport, server->sin_port,
(char *)p - (char *)&buf, &buf);
timeout = rfc2131_sleep_interval(TIMEOUT, retries);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
memcpy(fh, rpc->u.reply.data + 1, NFS_FHSIZE);
return 0;
}
}
}
return -1;
}
/**************************************************************************
NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
**************************************************************************/
static void nfs_umountall(struct sockaddr_in *server)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_MOUNT);
buf.u.call.vers = htonl(1); /* mountd is version 1 */
buf.u.call.proc = htonl(MOUNT_UMOUNTALL);
p = rpc_add_credentials((long *)buf.u.call.data);
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(server->sin_addr.s_addr, oport, server->sin_port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, oport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus) {
rpc_printerror(rpc);
}
break;
}
}
}
/**************************************************************************
NFS_RESET - Reset the NFS subsystem
**************************************************************************/
static void nfs_reset ( void ) {
/* If we have a mount server, call nfs_umountall() */
if ( mount_server.sin_addr.s_addr ) {
nfs_umountall ( &mount_server );
}
/* Zero the data structures */
memset ( &mount_server, 0, sizeof ( mount_server ) );
memset ( &nfs_server, 0, sizeof ( nfs_server ) );
}
/***************************************************************************
* NFS_READLINK (AH 2003-07-14)
* This procedure is called when read of the first block fails -
* this probably happens when it's a directory or a symlink
* In case of successful readlink(), the dirname is manipulated,
* so that inside the nfs() function a recursion can be done.
**************************************************************************/
static int nfs_readlink(struct sockaddr_in *server, char *fh __unused,
char *path, char *nfh, int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
long *p;
int retries;
int pathlen = strlen(path);
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_READLINK);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, nfh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(server->sin_addr.s_addr, sport, server->sin_port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
// It *is* a link.
// If it's a relative link, append everything to dirname, filename TOO!
retries = strlen ( (char *)(&(rpc->u.reply.data[2]) ));
if ( *((char *)(&(rpc->u.reply.data[2]))) != '/' ) {
path[pathlen++] = '/';
while ( ( retries + pathlen ) > 298 ) {
retries--;
}
if ( retries > 0 ) {
memcpy(path + pathlen, &(rpc->u.reply.data[2]), retries + 1);
} else { retries = 0; }
path[pathlen + retries] = 0;
} else {
// Else make it the only path.
if ( retries > 298 ) { retries = 298; }
memcpy ( path, &(rpc->u.reply.data[2]), retries + 1 );
path[retries] = 0;
}
return 0;
}
}
}
return -1;
}
/**************************************************************************
NFS_LOOKUP - Lookup Pathname
**************************************************************************/
static int nfs_lookup(struct sockaddr_in *server, char *fh, char *path, char *nfh,
int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
long *p;
int retries;
int pathlen = strlen(path);
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_LOOKUP);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, fh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(pathlen);
if (pathlen & 3) {
*(p + pathlen / 4) = 0; /* add zero padding */
}
memcpy(p, path, pathlen);
p += (pathlen + 3) / 4;
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(server->sin_addr.s_addr, sport, server->sin_port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
memcpy(nfh, rpc->u.reply.data + 1, NFS_FHSIZE);
return 0;
}
}
}
return -1;
}
/**************************************************************************
NFS_READ - Read File on NFS Server
**************************************************************************/
static int nfs_read(struct sockaddr_in *server, char *fh, int offset, int len,
int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
static int tokens=0;
/*
* Try to implement something similar to a window protocol in
* terms of response to losses. On successful receive, increment
* the number of tokens by 1 (cap at 256). On failure, halve it.
* When the number of tokens is >= 2, use a very short timeout.
*/
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_READ);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, fh, NFS_FHSIZE);
p += NFS_FHSIZE / 4;
*p++ = htonl(offset);
*p++ = htonl(len);
*p++ = 0; /* unused parameter */
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
if (tokens >= 2)
timeout = TICKS_PER_SEC/2;
udp_transmit(server->sin_addr.s_addr, sport, server->sin_port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
if (tokens < 256)
tokens++;
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
return 0;
}
} else
tokens >>= 1;
}
return -1;
}
/**************************************************************************
NFS - Download extended BOOTP data, or kernel image from NFS server
**************************************************************************/
static int nfs ( char *url __unused, struct sockaddr_in *server,
char *name, struct buffer *buffer ) {
static int recursion = 0;
int sport;
int err, namelen = strlen(name);
char dirname[300], *fname;
char dirfh[NFS_FHSIZE]; /* file handle of directory */
char filefh[NFS_FHSIZE]; /* file handle of kernel image */
int rlen, size, offs, len;
struct rpc_t *rpc;
sport = oport++;
if (oport > START_OPORT+OPORT_SWEEP) {
oport = START_OPORT;
}
mount_server.sin_addr = nfs_server.sin_addr = server->sin_addr;
mount_server.sin_port = rpc_lookup(server, PROG_MOUNT, 1, sport);
if ( ! mount_server.sin_port ) {
DBG ( "Cannot get mount port from %s:%d\n",
inet_ntoa ( server->sin_addr ), server->sin_port );
return 0;
}
nfs_server.sin_port = rpc_lookup(server, PROG_NFS, 2, sport);
if ( ! mount_server.sin_port ) {
DBG ( "Cannot get nfs port from %s:%d\n",
inet_ntoa ( server->sin_addr ), server->sin_port );
return 0;
}
if ( name != dirname ) {
memcpy(dirname, name, namelen + 1);
}
recursion = 0;
nfssymlink:
if ( recursion > NFS_MAXLINKDEPTH ) {
DBG ( "\nRecursion: More than %d symlinks followed. Abort.\n",
NFS_MAXLINKDEPTH );
return 0;
}
recursion++;
fname = dirname + (namelen - 1);
while (fname >= dirname) {
if (*fname == '/') {
*fname = '\0';
fname++;
break;
}
fname--;
}
if (fname < dirname) {
DBG("can't parse file name %s\n", name);
return 0;
}
err = nfs_mount(&mount_server, dirname, dirfh, sport);
if (err) {
DBG("mounting %s: ", dirname);
nfs_printerror(err);
/* just to be sure... */
nfs_reset();
return 0;
}
err = nfs_lookup(&nfs_server, dirfh, fname, filefh, sport);
if (err) {
DBG("looking up %s: ", fname);
nfs_printerror(err);
nfs_reset();
return 0;
}
offs = 0;
size = -1; /* will be set properly with the first reply */
len = NFS_READ_SIZE; /* first request is always full size */
do {
err = nfs_read(&nfs_server, filefh, offs, len, sport);
if ((err <= -NFSERR_ISDIR)&&(err >= -NFSERR_INVAL) && (offs == 0)) {
// An error occured. NFS servers tend to sending
// errors 21 / 22 when symlink instead of real file
// is requested. So check if it's a symlink!
if ( nfs_readlink(&nfs_server, dirfh, dirname,
filefh, sport) == 0 ) {
printf("\nLoading symlink:%s ..",dirname);
goto nfssymlink;
}
nfs_printerror(err);
nfs_reset();
return 0;
}
if (err) {
printf("\nError reading at offset %d: ", offs);
nfs_printerror(err);
nfs_reset();
return 0;
}
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
/* size must be found out early to allow EOF detection */
if (size == -1) {
size = ntohl(rpc->u.reply.data[6]);
}
rlen = ntohl(rpc->u.reply.data[18]);
if (rlen > len) {
rlen = len; /* shouldn't happen... */
}
if ( ! fill_buffer ( buffer, &rpc->u.reply.data[19],
offs, rlen ) ) {
nfs_reset();
return 0;
}
offs += rlen;
/* last request is done with matching requested read size */
if (size-offs < NFS_READ_SIZE) {
len = size-offs;
}
} while (len != 0);
/* len == 0 means that all the file has been read */
return 1;
}
struct protocol nfs_protocol __protocol = {
.name = "nfs",
.default_port = SUNRPC_PORT,
.load = nfs,
};
#endif
-110
View File
@@ -1,110 +0,0 @@
#if 0
#include "resolv.h"
#include "string.h"
#include <gpxe/dns.h>
#include "nic.h"
#include "nmb.h"
/*
* Convert a standard NUL-terminated string to an NBNS query name.
*
* Returns a pointer to the character following the constructed NBNS
* query name.
*
*/
static inline char * nbns_make_name ( char *dest, const char *name ) {
char nb_name[16];
char c;
int i;
uint16_t *d;
*(dest++) = 32; /* Length is always 32 */
/* Name encoding is as follows: pad the name with spaces to
* length 15, and add a NUL. Take this 16-byte string, split
* it into nibbles and add 0x41 to each nibble to form a byte
* of the resulting name string.
*/
memset ( nb_name, ' ', 15 );
nb_name[15] = '\0';
memcpy ( nb_name, name, strlen ( name ) ); /* Do not copy NUL */
d = ( uint16_t * ) dest;
for ( i = 0 ; i < 16 ; i++ ) {
c = nb_name[i];
*( d++ ) = htons ( ( ( c | ( c << 4 ) ) & 0x0f0f ) + 0x4141 );
}
dest = ( char * ) d;
*(dest++) = 0; /* Terminating 0-length name component */
return dest;
}
/*
* Resolve a name using NMB
*
*/
static int nmb_resolv ( struct in_addr *addr, const char *name ) {
struct dns_query query;
struct dns_query_info *query_info;
struct dns_header *reply;
struct dns_rr_info *rr_info;
struct dns_rr_info_nb *rr_info_nb;
struct sockaddr_in nameserver;
DBG ( "NMB resolving %s\n", name );
/* Set up the query data */
nameserver.sin_addr.s_addr = INADDR_BROADCAST;
nameserver.sin_port = NBNS_UDP_PORT;
memset ( &query, 0, sizeof ( query ) );
query.dns.id = htons ( 1 );
query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
DNS_FLAG_RD | DNS_FLAG_BROADCAST );
query.dns.qdcount = htons ( 1 );
query_info = ( void * ) nbns_make_name ( query.payload, name );
query_info->qtype = htons ( DNS_TYPE_NB );
query_info->qclass = htons ( DNS_CLASS_IN );
/* Issue query, wait for reply */
reply = dns_query ( &query,
( ( ( char * ) query_info )
+ sizeof ( *query_info )
- ( ( char * ) &query ) ),
&nameserver );
if ( ! reply ) {
DBG ( "NMB got no response via %@ (port %d)\n",
nameserver.sin_addr.s_addr,
nameserver.sin_port );
return 0;
}
/* Search through response for useful answers. */
rr_info = dns_find_rr ( &query, reply );
if ( ! rr_info ) {
DBG ( "NMB got invalid response\n" );
return 0;
}
/* Check type of response */
if ( ntohs ( rr_info->type ) != DNS_TYPE_NB ) {
DBG ( "NMB got answer type %hx (wanted %hx)\n",
ntohs ( rr_info->type ), DNS_TYPE_NB );
return 0;
}
/* Read response */
rr_info_nb = ( struct dns_rr_info_nb * ) rr_info;
*addr = rr_info_nb->nb_address;
DBG ( "NMB found address %@\n", addr->s_addr );
return 1;
}
struct resolver nmb_resolver __resolver = {
.name = "NMB",
.resolv = nmb_resolv,
};
#endif