efi/pxe.c

   1 #include <syslinux/firmware.h>
   2 #include <syslinux/pxe_api.h>
   3 #include "efi.h"
   4 #include "net.h"
   5 #include "fs/pxe/pxe.h"
   6
   7 const struct url_scheme url_schemes[] = {
   8     { "tftp", tftp_open, 0 },
   9     { "http", http_open, O_DIRECTORY },
  10     { "ftp",  ftp_open,  O_DIRECTORY },
  11     { NULL, NULL, 0 },
  12 };
  13
  14 /**
  15  * Network stack-specific initialization
  16  */
  17 void net_core_init(void)
  18 {
  19     http_bake_cookies();
  20 }
  21
  22 void pxe_init_isr(void) {}
  23 void gpxe_init(void) {}
  24 void pxe_idle_init(void) {}
  25
  26 int reset_pxe(void)
  27 {
  28     return 0;
  29 }
  30
  31 #define DNS_MAX_SERVERS 4               /* Max no of DNS servers */
  32 uint32_t dns_server[DNS_MAX_SERVERS] = {0, };
  33
  34 __export uint32_t dns_resolv(const char *name)
  35 {
  36     /*
  37      * Return failure on an empty input... this can happen during
  38      * some types of URL parsing, and this is the easiest place to
  39      * check for it.
  40      */
  41     if (!name || !*name)
  42         return 0;
  43
  44     return 0;
  45 }
  46
  47 int pxe_init(bool quiet)
  48 {
  49     EFI_HANDLE *handles;
  50     EFI_STATUS status;
  51     UINTN nr_handles;
  52
  53     status = LibLocateHandle(ByProtocol, &PxeBaseCodeProtocol,
  54                              NULL, &nr_handles, &handles);
  55     if (status != EFI_SUCCESS) {
  56         if (!quiet)
  57             Print(L"No PXE Base Code Protocol\n");
  58         return -1;
  59     }
  60
  61     return 0;
  62 }
  63
  64 void net_parse_dhcp(void)
  65 {
  66     EFI_PXE_BASE_CODE_MODE *mode;
  67     EFI_PXE_BASE_CODE *bc;
  68     unsigned int pkt_len = sizeof(EFI_PXE_BASE_CODE_PACKET);
  69     EFI_STATUS status;
  70     EFI_HANDLE *handles = NULL;
  71     UINTN nr_handles = 0;
  72     uint8_t hardlen;
  73     uint32_t ip;
  74     char dst[256];
  75
  76     status = LibLocateHandle(ByProtocol, &PxeBaseCodeProtocol,
  77                          NULL, &nr_handles, &handles);
  78     if (status != EFI_SUCCESS)
  79         return;
  80
  81     /* Probably want to use IPv4 protocol to decide which handle to use */
  82     status = uefi_call_wrapper(BS->HandleProtocol, 3, handles[0],
  83                            &PxeBaseCodeProtocol, (void **)&bc);
  84     if (status != EFI_SUCCESS) {
  85         Print(L"Failed to lookup PxeBaseCodeProtocol\n");
  86     }
  87
  88     mode = bc->Mode;
  89
  90     /*
  91      * Get the DHCP client identifiers (query info 1)
  92      */
  93     Print(L"Getting cached packet ");
  94     parse_dhcp(&mode->DhcpDiscover.Dhcpv4, pkt_len);
  95     /*
  96      * We don't use flags from the request packet, so
  97      * this is a good time to initialize DHCPMagic...
  98      * Initialize it to 1 meaning we will accept options found;
  99      * in earlier versions of PXELINUX bit 0 was used to indicate
 100      * we have found option 208 with the appropriate magic number;
 101      * we no longer require that, but MAY want to re-introduce
 102      * it in the future for vendor encapsulated options.
 103      */
 104     *(char *)&DHCPMagic = 1;
 105
 106     /*
 107      * Get the BOOTP/DHCP packet that brought us file (and an IP
 108      * address). This lives in the DHCPACK packet (query info 2)
 109      */
 110     parse_dhcp(&mode->DhcpAck.Dhcpv4, pkt_len);
 111     /*
 112      * Save away MAC address (assume this is in query info 2. If this
 113      * turns out to be problematic it might be better getting it from
 114      * the query info 1 packet
 115      */
 116     hardlen = mode->DhcpAck.Dhcpv4.BootpHwAddrLen;
 117     MAC_len = hardlen > 16 ? 0 : hardlen;
 118     MAC_type = mode->DhcpAck.Dhcpv4.BootpHwType;
 119     memcpy(MAC, mode->DhcpAck.Dhcpv4.BootpHwAddr, MAC_len);
 120
 121     /*
 122      * Get the boot file and other info. This lives in the CACHED_REPLY
 123      * packet (query info 3)
 124      */
 125     parse_dhcp(&mode->PxeReply.Dhcpv4, pkt_len);
 126     Print(L"\n");
 127
 128     ip = IPInfo.myip;
 129     sprintf(dst, "%u.%u.%u.%u",
 130         ((const uint8_t *)&ip)[0],
 131         ((const uint8_t *)&ip)[1],
 132         ((const uint8_t *)&ip)[2],
 133         ((const uint8_t *)&ip)[3]);
 134
 135     Print(L"My IP is %a\n", dst);
 136 }