static grub_err_t ack (tftp_data_t data, grub_uint64_t block) { struct tftphdr *tftph_ack; grub_uint8_t nbdata[512]; struct grub_net_buff nb_ack; grub_err_t err; nb_ack.head = nbdata; nb_ack.end = nbdata + sizeof (nbdata); grub_netbuff_clear (&nb_ack); grub_netbuff_reserve (&nb_ack, 512); err = grub_netbuff_push (&nb_ack, sizeof (tftph_ack->opcode) + sizeof (tftph_ack->u.ack.block)); if (err) return err; tftph_ack = (struct tftphdr *) nb_ack.data; tftph_ack->opcode = grub_cpu_to_be16_compile_time (TFTP_ACK); tftph_ack->u.ack.block = grub_cpu_to_be16 (block); err = grub_net_send_udp_packet (data->sock, &nb_ack); if (err) return err; data->ack_sent = block; return GRUB_ERR_NONE; }
static grub_err_t tftp_close (struct grub_file *file) { tftp_data_t data = file->data; if (data->sock) { grub_uint8_t nbdata[512]; grub_err_t err; struct grub_net_buff nb_err; struct tftphdr *tftph; nb_err.head = nbdata; nb_err.end = nbdata + sizeof (nbdata); grub_netbuff_clear (&nb_err); grub_netbuff_reserve (&nb_err, 512); err = grub_netbuff_push (&nb_err, sizeof (tftph->opcode) + sizeof (tftph->u.err.errcode) + sizeof ("closed")); if (!err) { tftph = (struct tftphdr *) nb_err.data; tftph->opcode = grub_cpu_to_be16_compile_time (TFTP_ERROR); tftph->u.err.errcode = grub_cpu_to_be16_compile_time (TFTP_EUNDEF); grub_memcpy (tftph->u.err.errmsg, "closed", sizeof ("closed")); err = grub_net_send_udp_packet (data->sock, &nb_err); } if (err) grub_print_error (); grub_net_udp_close (data->sock); } destroy_pq (data); grub_free (data); return GRUB_ERR_NONE; }
grub_err_t grub_net_dns_lookup (const char *name, const struct grub_net_network_level_address *servers, grub_size_t n_servers, grub_size_t *naddresses, struct grub_net_network_level_address **addresses, int cache) { grub_size_t send_servers = 0; grub_size_t i, j; struct grub_net_buff *nb; grub_net_udp_socket_t *sockets; grub_uint8_t *optr; const char *iptr; struct dns_header *head; static grub_uint16_t id = 1; grub_uint8_t *qtypeptr; grub_err_t err = GRUB_ERR_NONE; struct recv_data data = {naddresses, addresses, cache, grub_cpu_to_be16 (id++), 0, 0, name, 0}; grub_uint8_t *nbd; int have_server = 0; if (!servers) { servers = dns_servers; n_servers = dns_nservers; } if (!n_servers) return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("no DNS servers configured")); *naddresses = 0; if (cache) { int h; h = hash (name); if (dns_cache[h].name && grub_strcmp (dns_cache[h].name, name) == 0 && grub_get_time_ms () < dns_cache[h].limit_time) { grub_dprintf ("dns", "retrieved from cache\n"); *addresses = grub_malloc (dns_cache[h].naddresses * sizeof ((*addresses)[0])); if (!*addresses) return grub_errno; *naddresses = dns_cache[h].naddresses; grub_memcpy (*addresses, dns_cache[h].addresses, dns_cache[h].naddresses * sizeof ((*addresses)[0])); return GRUB_ERR_NONE; } } sockets = grub_malloc (sizeof (sockets[0]) * n_servers); if (!sockets) return grub_errno; data.name = grub_strdup (name); if (!data.name) { grub_free (sockets); return grub_errno; } nb = grub_netbuff_alloc (GRUB_NET_OUR_MAX_IP_HEADER_SIZE + GRUB_NET_MAX_LINK_HEADER_SIZE + GRUB_NET_UDP_HEADER_SIZE + sizeof (struct dns_header) + grub_strlen (name) + 2 + 4); if (!nb) { grub_free (sockets); grub_free (data.name); return grub_errno; } grub_netbuff_reserve (nb, GRUB_NET_OUR_MAX_IP_HEADER_SIZE + GRUB_NET_MAX_LINK_HEADER_SIZE + GRUB_NET_UDP_HEADER_SIZE); grub_netbuff_put (nb, sizeof (struct dns_header) + grub_strlen (name) + 2 + 4); head = (struct dns_header *) nb->data; optr = (grub_uint8_t *) (head + 1); for (iptr = name; *iptr; ) { const char *dot; dot = grub_strchr (iptr, '.'); if (!dot) dot = iptr + grub_strlen (iptr); if ((dot - iptr) >= 64) { grub_free (sockets); grub_free (data.name); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("domain name component is too long")); } *optr = (dot - iptr); optr++; grub_memcpy (optr, iptr, dot - iptr); optr += dot - iptr; iptr = dot; if (*iptr) iptr++; } *optr++ = 0; /* Type. */ *optr++ = 0; qtypeptr = optr++; /* Class. */ *optr++ = 0; *optr++ = 1; head->id = data.id; head->flags = FLAGS_RD; head->ra_z_r_code = 0; head->qdcount = grub_cpu_to_be16_compile_time (1); head->ancount = grub_cpu_to_be16_compile_time (0); head->nscount = grub_cpu_to_be16_compile_time (0); head->arcount = grub_cpu_to_be16_compile_time (0); nbd = nb->data; for (i = 0; i < n_servers * 4; i++) { /* Connect to a next server. */ while (!(i & 1) && send_servers < n_servers) { sockets[send_servers] = grub_net_udp_open (servers[send_servers], DNS_PORT, recv_hook, &data); send_servers++; if (!sockets[send_servers - 1]) { err = grub_errno; grub_errno = GRUB_ERR_NONE; } else { have_server = 1; break; } } if (!have_server) goto out; if (*data.naddresses) goto out; for (j = 0; j < send_servers; j++) { grub_err_t err2; if (!sockets[j]) continue; nb->data = nbd; grub_size_t t = 0; do { if (servers[j].option == DNS_OPTION_IPV4 || ((servers[j].option == DNS_OPTION_PREFER_IPV4) && (t++ == 0)) || ((servers[j].option == DNS_OPTION_PREFER_IPV6) && (t++ == 1))) *qtypeptr = GRUB_DNS_QTYPE_A; else *qtypeptr = GRUB_DNS_QTYPE_AAAA; grub_dprintf ("dns", "QTYPE: %u QNAME: %s\n", *qtypeptr, name); err2 = grub_net_send_udp_packet (sockets[j], nb); if (err2) { grub_errno = GRUB_ERR_NONE; err = err2; } if (*data.naddresses) goto out; } while (t == 1); } grub_net_poll_cards (200, &data.stop); } out: grub_free (data.name); grub_netbuff_free (nb); for (j = 0; j < send_servers; j++) grub_net_udp_close (sockets[j]); grub_free (sockets); if (*data.naddresses) return GRUB_ERR_NONE; if (data.dns_err) return grub_error (GRUB_ERR_NET_NO_DOMAIN, N_("no DNS record found")); if (err) { grub_errno = err; return err; } return grub_error (GRUB_ERR_TIMEOUT, N_("no DNS reply received")); }
static grub_err_t grub_cmd_file (grub_extcmd_context_t ctxt, int argc, char **args) { grub_file_t file = 0; grub_elf_t elf = 0; grub_err_t err; int type = -1, i; int ret = 0; grub_macho_t macho = 0; if (argc == 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); for (i = OPT_TYPE_MIN; i <= OPT_TYPE_MAX; i++) if (ctxt->state[i].set) { if (type == -1) { type = i; continue; } return grub_error (GRUB_ERR_BAD_ARGUMENT, "multiple types specified"); } if (type == -1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "no type specified"); file = grub_file_open (args[0]); if (!file) return grub_errno; switch (type) { case IS_BIOS_BOOTSECTOR: { grub_uint16_t sig; if (grub_file_size (file) != 512) break; if (grub_file_seek (file, 510) == (grub_size_t) -1) break; if (grub_file_read (file, &sig, 2) != 2) break; if (sig != grub_cpu_to_le16_compile_time (0xaa55)) break; ret = 1; break; } case IS_IA64_LINUX: { Elf64_Ehdr ehdr; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_ident[EI_CLASS] != ELFCLASS64 || ehdr.e_ident[EI_DATA] != ELFDATA2LSB || ehdr.e_machine != grub_cpu_to_le16_compile_time (EM_IA_64)) break; ret = 1; break; } case IS_SPARC64_LINUX: { Elf64_Ehdr ehdr; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_ident[EI_CLASS] != ELFCLASS64 || ehdr.e_ident[EI_DATA] != ELFDATA2MSB) break; if (ehdr.e_machine != grub_cpu_to_le16_compile_time (EM_SPARCV9) || ehdr.e_type != grub_cpu_to_be16_compile_time (ET_EXEC)) break; ret = 1; break; } case IS_POWERPC_LINUX: { Elf32_Ehdr ehdr; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_ident[EI_DATA] != ELFDATA2MSB || (ehdr.e_machine != grub_cpu_to_le16_compile_time (EM_PPC) && ehdr.e_machine != grub_cpu_to_le16_compile_time (EM_PPC64))) break; if (ehdr.e_type != grub_cpu_to_be16_compile_time (ET_EXEC) && ehdr.e_type != grub_cpu_to_be16_compile_time (ET_DYN)) break; ret = 1; break; } case IS_MIPS_LINUX: { Elf32_Ehdr ehdr; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_ident[EI_DATA] != ELFDATA2MSB || ehdr.e_machine != grub_cpu_to_be16_compile_time (EM_MIPS) || ehdr.e_type != grub_cpu_to_be16_compile_time (ET_EXEC)) break; ret = 1; break; } case IS_X86_KNETBSD: case IS_X86_KNETBSD32: case IS_X86_KNETBSD64: { int is32, is64; elf = grub_elf_file (file, file->name); if (elf->ehdr.ehdr32.e_type != grub_cpu_to_le16_compile_time (ET_EXEC) || elf->ehdr.ehdr32.e_ident[EI_DATA] != ELFDATA2LSB) break; is32 = grub_elf_is_elf32 (elf); is64 = grub_elf_is_elf64 (elf); if (!is32 && !is64) break; if (!is32 && type == IS_X86_KNETBSD32) break; if (!is64 && type == IS_X86_KNETBSD64) break; if (is64) ret = grub_file_check_netbsd64 (elf); if (is32) ret = grub_file_check_netbsd32 (elf); break; } case IS_X86_KFREEBSD: case IS_X86_KFREEBSD32: case IS_X86_KFREEBSD64: { Elf32_Ehdr ehdr; int is32, is64; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_type != grub_cpu_to_le16_compile_time (ET_EXEC) || ehdr.e_ident[EI_DATA] != ELFDATA2LSB) break; if (ehdr.e_ident[EI_OSABI] != ELFOSABI_FREEBSD) break; is32 = (ehdr.e_machine == grub_cpu_to_le16_compile_time (EM_386) && ehdr.e_ident[EI_CLASS] == ELFCLASS32); is64 = (ehdr.e_machine == grub_cpu_to_le16_compile_time (EM_X86_64) && ehdr.e_ident[EI_CLASS] == ELFCLASS64); if (!is32 && !is64) break; if (!is32 && (type == IS_X86_KFREEBSD32 || type == IS_X86_KNETBSD32)) break; if (!is64 && (type == IS_X86_KFREEBSD64 || type == IS_X86_KNETBSD64)) break; ret = 1; break; } case IS_MIPSEL_LINUX: { Elf32_Ehdr ehdr; if (grub_file_read (file, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) break; if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 || ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3 || ehdr.e_ident[EI_VERSION] != EV_CURRENT || ehdr.e_version != EV_CURRENT) break; if (ehdr.e_machine != grub_cpu_to_le16_compile_time (EM_MIPS) || ehdr.e_type != grub_cpu_to_le16_compile_time (ET_EXEC)) break; ret = 1; break; } case IS_ARM_LINUX: { grub_uint32_t sig, sig_pi; if (grub_file_read (file, &sig_pi, 4) != 4) break; /* Raspberry pi. */ if (sig_pi == grub_cpu_to_le32_compile_time (0xea000006)) { ret = 1; break; } if (grub_file_seek (file, 0x24) == (grub_size_t) -1) break; if (grub_file_read (file, &sig, 4) != 4) break; if (sig == grub_cpu_to_le32_compile_time (0x016f2818)) { ret = 1; break; } break; } case IS_ARM64_LINUX: { grub_uint32_t sig; if (grub_file_seek (file, 0x38) == (grub_size_t) -1) break; if (grub_file_read (file, &sig, 4) != 4) break; if (sig == grub_cpu_to_le32_compile_time (0x644d5241)) { ret = 1; break; } break; } case IS_PAE_DOMU ... IS_DOM0: { struct grub_xen_file_info xen_inf; elf = grub_xen_file (file); if (!elf) break; err = grub_xen_get_info (elf, &xen_inf); if (err) break; /* Unfortuntely no way to check if kernel supports dom0. */ if (type == IS_DOM0) ret = 1; if (type == IS_PAE_DOMU) ret = (xen_inf.arch == GRUB_XEN_FILE_I386_PAE || xen_inf.arch == GRUB_XEN_FILE_I386_PAE_BIMODE); if (type == IS_64_DOMU) ret = (xen_inf.arch == GRUB_XEN_FILE_X86_64); break; } case IS_MULTIBOOT: case IS_MULTIBOOT2: { grub_uint32_t *buffer; grub_ssize_t len; grub_size_t search_size; grub_uint32_t *header; grub_uint32_t magic; grub_size_t step; if (type == IS_MULTIBOOT2) { search_size = 32768; magic = grub_cpu_to_le32_compile_time (0xe85250d6); step = 2; } else { search_size = 8192; magic = grub_cpu_to_le32_compile_time (0x1BADB002); step = 1; } buffer = grub_malloc (search_size); if (!buffer) break; len = grub_file_read (file, buffer, search_size); if (len < 32) { grub_free (buffer); break; } /* Look for the multiboot header in the buffer. The header should be at least 12 bytes and aligned on a 4-byte boundary. */ for (header = buffer; ((char *) header <= (char *) buffer + len - (type == IS_MULTIBOOT2 ? 16 : 12)) || (header = 0); header += step) { if (header[0] == magic && !(grub_le_to_cpu32 (header[0]) + grub_le_to_cpu32 (header[1]) + grub_le_to_cpu32 (header[2]) + (type == IS_MULTIBOOT2 ? grub_le_to_cpu32 (header[3]) : 0))) break; } if (header != 0) ret = 1; grub_free (buffer); break; } case IS_X86_LINUX32: case IS_X86_LINUX: { struct linux_kernel_header lh; if (grub_file_read (file, &lh, sizeof (lh)) != sizeof (lh)) break; if (lh.boot_flag != grub_cpu_to_le16_compile_time (0xaa55)) break; if (lh.setup_sects > GRUB_LINUX_MAX_SETUP_SECTS) break; /* FIXME: some really old kernels (< 1.3.73) will fail this. */ if (lh.header != grub_cpu_to_le32_compile_time (GRUB_LINUX_MAGIC_SIGNATURE) || grub_le_to_cpu16 (lh.version) < 0x0200) break; if (type == IS_X86_LINUX) { ret = 1; break; } /* FIXME: 2.03 is not always good enough (Linux 2.4 can be 2.03 and still not support 32-bit boot. */ if (lh.header != grub_cpu_to_le32_compile_time (GRUB_LINUX_MAGIC_SIGNATURE) || grub_le_to_cpu16 (lh.version) < 0x0203) break; if (!(lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL)) break; ret = 1; break; } case IS_HIBERNATED: { grub_uint8_t hibr_file_magic[4]; if (grub_file_read (file, &hibr_file_magic, sizeof (hibr_file_magic)) != sizeof (hibr_file_magic)) break; if (grub_memcmp ("hibr", hibr_file_magic, sizeof (hibr_file_magic)) == 0 || grub_memcmp ("HIBR", hibr_file_magic, sizeof (hibr_file_magic)) == 0) ret = 1; break; } case IS_XNU64: case IS_XNU32: { macho = grub_macho_open (args[0], (type == IS_XNU64)); if (!macho) break; /* FIXME: more checks? */ ret = 1; break; } case IS_XNU_HIBR: { struct grub_xnu_hibernate_header hibhead; if (grub_file_read (file, &hibhead, sizeof (hibhead)) != sizeof (hibhead)) break; if (hibhead.magic != grub_cpu_to_le32_compile_time (GRUB_XNU_HIBERNATE_MAGIC)) break; ret = 1; break; } case IS_32_EFI: case IS_64_EFI: case IS_IA_EFI: case IS_ARM64_EFI: case IS_ARM_EFI: { char signature[4]; grub_uint32_t pe_offset; struct grub_pe32_coff_header coff_head; if (grub_file_read (file, signature, 2) != 2) break; if (signature[0] != 'M' || signature[1] != 'Z') break; if ((grub_ssize_t) grub_file_seek (file, 0x3c) == -1) break; if (grub_file_read (file, &pe_offset, 4) != 4) break; if ((grub_ssize_t) grub_file_seek (file, grub_le_to_cpu32 (pe_offset)) == -1) break; if (grub_file_read (file, signature, 4) != 4) break; if (signature[0] != 'P' || signature[1] != 'E' || signature[2] != '\0' || signature[3] != '\0') break; if (grub_file_read (file, &coff_head, sizeof (coff_head)) != sizeof (coff_head)) break; if (type == IS_32_EFI && coff_head.machine != grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_I386)) break; if (type == IS_64_EFI && coff_head.machine != grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_X86_64)) break; if (type == IS_IA_EFI && coff_head.machine != grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_IA64)) break; if (type == IS_ARM64_EFI && coff_head.machine != grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_ARM64)) break; if (type == IS_ARM_EFI && coff_head.machine != grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_ARMTHUMB_MIXED)) break; if (type == IS_IA_EFI || type == IS_64_EFI || type == IS_ARM64_EFI) { struct grub_pe64_optional_header o64; if (grub_file_read (file, &o64, sizeof (o64)) != sizeof (o64)) break; if (o64.magic != grub_cpu_to_le16_compile_time (GRUB_PE32_PE64_MAGIC)) break; if (o64.subsystem != grub_cpu_to_le16_compile_time (GRUB_PE32_SUBSYSTEM_EFI_APPLICATION)) break; ret = 1; break; } if (type == IS_32_EFI || type == IS_ARM_EFI) { struct grub_pe32_optional_header o32; if (grub_file_read (file, &o32, sizeof (o32)) != sizeof (o32)) break; if (o32.magic != grub_cpu_to_le16_compile_time (GRUB_PE32_PE32_MAGIC)) break; if (o32.subsystem != grub_cpu_to_le16_compile_time (GRUB_PE32_SUBSYSTEM_EFI_APPLICATION)) break; ret = 1; break; } break; } } if (elf) grub_elf_close (elf); else if (macho) grub_macho_close (macho); else if (file) grub_file_close (file); if (!ret && (grub_errno == GRUB_ERR_BAD_OS || grub_errno == GRUB_ERR_NONE)) /* TRANSLATORS: it's a standalone boolean value, opposite of "true". */ grub_error (GRUB_ERR_TEST_FAILURE, N_("false")); return grub_errno; }
static grub_err_t tftp_open (struct grub_file *file, const char *filename) { struct tftphdr *tftph; char *rrq; int i; int rrqlen; int hdrlen; grub_uint8_t open_data[1500]; struct grub_net_buff nb; tftp_data_t data; grub_err_t err; grub_uint8_t *nbd; grub_net_network_level_address_t addr; data = grub_zalloc (sizeof (*data)); if (!data) return grub_errno; nb.head = open_data; nb.end = open_data + sizeof (open_data); grub_netbuff_clear (&nb); grub_netbuff_reserve (&nb, 1500); err = grub_netbuff_push (&nb, sizeof (*tftph)); if (err) return err; tftph = (struct tftphdr *) nb.data; rrq = (char *) tftph->u.rrq; rrqlen = 0; tftph->opcode = grub_cpu_to_be16_compile_time (TFTP_RRQ); grub_strcpy (rrq, filename); rrqlen += grub_strlen (filename) + 1; rrq += grub_strlen (filename) + 1; grub_strcpy (rrq, "octet"); rrqlen += grub_strlen ("octet") + 1; rrq += grub_strlen ("octet") + 1; grub_strcpy (rrq, "blksize"); rrqlen += grub_strlen ("blksize") + 1; rrq += grub_strlen ("blksize") + 1; grub_strcpy (rrq, "1024"); rrqlen += grub_strlen ("1024") + 1; rrq += grub_strlen ("1024") + 1; grub_strcpy (rrq, "tsize"); rrqlen += grub_strlen ("tsize") + 1; rrq += grub_strlen ("tsize") + 1; grub_strcpy (rrq, "0"); rrqlen += grub_strlen ("0") + 1; rrq += grub_strlen ("0") + 1; hdrlen = sizeof (tftph->opcode) + rrqlen; err = grub_netbuff_unput (&nb, nb.tail - (nb.data + hdrlen)); if (err) return err; file->not_easily_seekable = 1; file->data = data; data->pq = grub_priority_queue_new (sizeof (struct grub_net_buff *), cmp); if (!data->pq) return grub_errno; err = grub_net_resolve_address (file->device->net->server, &addr); if (err) { destroy_pq (data); return err; } data->sock = grub_net_udp_open (addr, TFTP_SERVER_PORT, tftp_receive, file); if (!data->sock) { destroy_pq (data); return grub_errno; } /* Receive OACK packet. */ nbd = nb.data; for (i = 0; i < GRUB_NET_TRIES; i++) { nb.data = nbd; err = grub_net_send_udp_packet (data->sock, &nb); if (err) { grub_net_udp_close (data->sock); destroy_pq (data); return err; } grub_net_poll_cards (GRUB_NET_INTERVAL + (i * GRUB_NET_INTERVAL_ADDITION), &data->have_oack); if (data->have_oack) break; } if (!data->have_oack) grub_error (GRUB_ERR_TIMEOUT, N_("time out opening `%s'"), filename); else grub_error_load (&data->save_err); if (grub_errno) { grub_net_udp_close (data->sock); destroy_pq (data); return grub_errno; } file->size = data->file_size; return GRUB_ERR_NONE; }