static grub_err_t http_establish (struct grub_file *file, grub_off_t offset, int initial) { http_data_t data = file->data; grub_uint8_t *ptr; int i; struct grub_net_buff *nb; grub_err_t err; nb = grub_netbuff_alloc (GRUB_NET_TCP_RESERVE_SIZE + sizeof ("GET ") - 1 + grub_strlen (data->filename) + sizeof (" HTTP/1.1\r\nHost: ") - 1 + grub_strlen (file->device->net->server) + sizeof ("\r\nUser-Agent: " PACKAGE_STRING "\r\n") - 1 + sizeof ("Range: bytes=XXXXXXXXXXXXXXXXXXXX" "-\r\n\r\n")); if (!nb) return grub_errno; grub_netbuff_reserve (nb, GRUB_NET_TCP_RESERVE_SIZE); ptr = nb->tail; err = grub_netbuff_put (nb, sizeof ("GET ") - 1); if (err) { grub_netbuff_free (nb); return err; } grub_memcpy (ptr, "GET ", sizeof ("GET ") - 1); ptr = nb->tail; err = grub_netbuff_put (nb, grub_strlen (data->filename)); if (err) { grub_netbuff_free (nb); return err; } grub_memcpy (ptr, data->filename, grub_strlen (data->filename)); ptr = nb->tail; err = grub_netbuff_put (nb, sizeof (" HTTP/1.1\r\nHost: ") - 1); if (err) { grub_netbuff_free (nb); return err; } grub_memcpy (ptr, " HTTP/1.1\r\nHost: ", sizeof (" HTTP/1.1\r\nHost: ") - 1); ptr = nb->tail; err = grub_netbuff_put (nb, grub_strlen (file->device->net->server)); if (err) { grub_netbuff_free (nb); return err; } grub_memcpy (ptr, file->device->net->server, grub_strlen (file->device->net->server)); ptr = nb->tail; err = grub_netbuff_put (nb, sizeof ("\r\nUser-Agent: " PACKAGE_STRING "\r\n") - 1); if (err) { grub_netbuff_free (nb); return err; } grub_memcpy (ptr, "\r\nUser-Agent: " PACKAGE_STRING "\r\n", sizeof ("\r\nUser-Agent: " PACKAGE_STRING "\r\n") - 1); if (!initial) { ptr = nb->tail; grub_snprintf ((char *) ptr, sizeof ("Range: bytes=XXXXXXXXXXXXXXXXXXXX-" "\r\n" "\r\n"), "Range: bytes=%" PRIuGRUB_UINT64_T "-\r\n\r\n", offset); grub_netbuff_put (nb, grub_strlen ((char *) ptr)); } ptr = nb->tail; grub_netbuff_put (nb, 2); grub_memcpy (ptr, "\r\n", 2); data->sock = grub_net_tcp_open (file->device->net->server, HTTP_PORT, http_receive, http_err, http_err, file); if (!data->sock) { grub_netbuff_free (nb); return grub_errno; } // grub_net_poll_cards (5000); err = grub_net_send_tcp_packet (data->sock, nb, 1); if (err) { grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); return err; } for (i = 0; !data->headers_recv && i < 100; i++) { grub_net_tcp_retransmit (); grub_net_poll_cards (300, &data->headers_recv); } if (!data->headers_recv) { grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); if (data->err) { char *str = data->errmsg; err = grub_error (data->err, "%s", str); grub_free (str); data->errmsg = 0; return data->err; } return grub_error (GRUB_ERR_TIMEOUT, N_("time out opening `%s'"), data->filename); } 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 http_receive (grub_net_tcp_socket_t sock __attribute__ ((unused)), struct grub_net_buff *nb, void *f) { grub_file_t file = f; http_data_t data = file->data; grub_err_t err; while (1) { char *ptr = (char *) nb->data; if ((!data->headers_recv || data->in_chunk_len) && data->current_line) { int have_line = 1; char *t; ptr = grub_memchr (nb->data, '\n', nb->tail - nb->data); if (ptr) ptr++; else { have_line = 0; ptr = (char *) nb->tail; } t = grub_realloc (data->current_line, data->current_line_len + (ptr - (char *) nb->data)); if (!t) { grub_netbuff_free (nb); grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); return grub_errno; } data->current_line = t; grub_memcpy (data->current_line + data->current_line_len, nb->data, ptr - (char *) nb->data); data->current_line_len += ptr - (char *) nb->data; if (!have_line) { grub_netbuff_free (nb); return GRUB_ERR_NONE; } err = parse_line (file, data, data->current_line, data->current_line_len); grub_free (data->current_line); data->current_line = 0; data->current_line_len = 0; if (err) { grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); grub_netbuff_free (nb); return err; } } while (ptr < (char *) nb->tail && (!data->headers_recv || data->in_chunk_len)) { char *ptr2; ptr2 = grub_memchr (ptr, '\n', (char *) nb->tail - ptr); if (!ptr2) { data->current_line = grub_malloc ((char *) nb->tail - ptr); if (!data->current_line) { grub_netbuff_free (nb); grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); return grub_errno; } data->current_line_len = (char *) nb->tail - ptr; grub_memcpy (data->current_line, ptr, data->current_line_len); grub_netbuff_free (nb); return GRUB_ERR_NONE; } err = parse_line (file, data, ptr, ptr2 - ptr); if (err) { grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); grub_netbuff_free (nb); return err; } ptr = ptr2 + 1; } if (((char *) nb->tail - ptr) <= 0) { grub_netbuff_free (nb); return GRUB_ERR_NONE; } err = grub_netbuff_pull (nb, ptr - (char *) nb->data); if (err) { grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT); grub_netbuff_free (nb); return err; } if (!(data->chunked && (grub_ssize_t) data->chunk_rem < nb->tail - nb->data)) { grub_net_put_packet (&file->device->net->packs, nb); if (file->device->net->packs.count >= 20) file->device->net->stall = 1; if (file->device->net->packs.count >= 100) grub_net_tcp_stall (data->sock); if (data->chunked) data->chunk_rem -= nb->tail - nb->data; return GRUB_ERR_NONE; } if (data->chunk_rem) { struct grub_net_buff *nb2; nb2 = grub_netbuff_alloc (data->chunk_rem); if (!nb2) return grub_errno; grub_netbuff_put (nb2, data->chunk_rem); grub_memcpy (nb2->data, nb->data, data->chunk_rem); if (file->device->net->packs.count >= 20) { file->device->net->stall = 1; grub_net_tcp_stall (data->sock); } grub_net_put_packet (&file->device->net->packs, nb2); grub_netbuff_pull (nb, data->chunk_rem); } data->in_chunk_len = 1; } }