1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright 2010-2011 Calxeda, Inc. 4 * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved. 5 */ 6 7#include <common.h> 8#include <command.h> 9#include <fs.h> 10#include <net.h> 11#include <net6.h> 12#include <malloc.h> 13 14#include "pxe_utils.h" 15 16#ifdef CONFIG_CMD_NET 17const char *pxe_default_paths[] = { 18#ifdef CONFIG_SYS_SOC 19#ifdef CONFIG_SYS_BOARD 20 "default-" CONFIG_SYS_ARCH "-" CONFIG_SYS_SOC "-" CONFIG_SYS_BOARD, 21#endif 22 "default-" CONFIG_SYS_ARCH "-" CONFIG_SYS_SOC, 23#endif 24 "default-" CONFIG_SYS_ARCH, 25 "default", 26 NULL 27}; 28 29static int do_get_tftp(struct pxe_context *ctx, const char *file_path, 30 char *file_addr, ulong *sizep) 31{ 32 char *tftp_argv[] = {"tftp", NULL, NULL, NULL}; 33 int ret; 34 int num_args; 35 36 tftp_argv[1] = file_addr; 37 tftp_argv[2] = (void *)file_path; 38 if (ctx->use_ipv6) { 39 tftp_argv[3] = USE_IP6_CMD_PARAM; 40 num_args = 4; 41 } else { 42 num_args = 3; 43 } 44 45 if (do_tftpb(ctx->cmdtp, 0, num_args, tftp_argv)) 46 return -ENOENT; 47 48 ret = pxe_get_file_size(sizep); 49 if (ret) 50 return log_msg_ret("tftp", ret); 51 ctx->pxe_file_size = *sizep; 52 53 return 1; 54} 55 56/* 57 * Looks for a pxe file with specified config file name, 58 * which is received from DHCPv4 option 209 or 59 * DHCPv6 option 60. 60 * 61 * Returns 1 on success or < 0 on error. 62 */ 63static int pxe_dhcp_option_path(struct pxe_context *ctx, unsigned long pxefile_addr_r) 64{ 65 int ret = get_pxe_file(ctx, pxelinux_configfile, pxefile_addr_r); 66 67 free(pxelinux_configfile); 68 69 return ret; 70} 71 72/* 73 * Looks for a pxe file with a name based on the pxeuuid environment variable. 74 * 75 * Returns 1 on success or < 0 on error. 76 */ 77static int pxe_uuid_path(struct pxe_context *ctx, unsigned long pxefile_addr_r) 78{ 79 char *uuid_str; 80 81 uuid_str = from_env("pxeuuid"); 82 83 if (!uuid_str) 84 return -ENOENT; 85 86 return get_pxelinux_path(ctx, uuid_str, pxefile_addr_r); 87} 88 89/* 90 * Looks for a pxe file with a name based on the 'ethaddr' environment 91 * variable. 92 * 93 * Returns 1 on success or < 0 on error. 94 */ 95static int pxe_mac_path(struct pxe_context *ctx, unsigned long pxefile_addr_r) 96{ 97 char mac_str[21]; 98 int err; 99 100 err = format_mac_pxe(mac_str, sizeof(mac_str)); 101 102 if (err < 0) 103 return err; 104 105 return get_pxelinux_path(ctx, mac_str, pxefile_addr_r); 106} 107 108/* 109 * Looks for pxe files with names based on our IP address. See pxelinux 110 * documentation for details on what these file names look like. We match 111 * that exactly. 112 * 113 * Returns 1 on success or < 0 on error. 114 */ 115static int pxe_ipaddr_paths(struct pxe_context *ctx, unsigned long pxefile_addr_r) 116{ 117 char ip_addr[9]; 118 int mask_pos, err; 119 120 sprintf(ip_addr, "%08X", ntohl(net_ip.s_addr)); 121 122 for (mask_pos = 7; mask_pos >= 0; mask_pos--) { 123 err = get_pxelinux_path(ctx, ip_addr, pxefile_addr_r); 124 125 if (err > 0) 126 return err; 127 128 ip_addr[mask_pos] = '\0'; 129 } 130 131 return -ENOENT; 132} 133 134int pxe_get(ulong pxefile_addr_r, char **bootdirp, ulong *sizep, bool use_ipv6) 135{ 136 struct cmd_tbl cmdtp[] = {}; /* dummy */ 137 struct pxe_context ctx; 138 int i; 139 140 if (pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL, false, 141 env_get("bootfile"), use_ipv6)) 142 return -ENOMEM; 143 144 if (IS_ENABLED(CONFIG_BOOTP_PXE_DHCP_OPTION) && 145 pxelinux_configfile && !use_ipv6) { 146 if (pxe_dhcp_option_path(&ctx, pxefile_addr_r) > 0) 147 goto done; 148 149 goto error_exit; 150 } 151 152 if (IS_ENABLED(CONFIG_DHCP6_PXE_DHCP_OPTION) && 153 pxelinux_configfile && use_ipv6) { 154 if (pxe_dhcp_option_path(&ctx, pxefile_addr_r) > 0) 155 goto done; 156 157 goto error_exit; 158 } 159 160 /* 161 * Keep trying paths until we successfully get a file we're looking 162 * for. 163 */ 164 if (pxe_uuid_path(&ctx, pxefile_addr_r) > 0 || 165 pxe_mac_path(&ctx, pxefile_addr_r) > 0 || 166 pxe_ipaddr_paths(&ctx, pxefile_addr_r) > 0) 167 goto done; 168 169 i = 0; 170 while (pxe_default_paths[i]) { 171 if (get_pxelinux_path(&ctx, pxe_default_paths[i], 172 pxefile_addr_r) > 0) 173 goto done; 174 i++; 175 } 176 177error_exit: 178 pxe_destroy_ctx(&ctx); 179 180 return -ENOENT; 181done: 182 *bootdirp = env_get("bootfile"); 183 184 /* 185 * The PXE file size is returned but not the name. It is probably not 186 * that useful. 187 */ 188 *sizep = ctx.pxe_file_size; 189 pxe_destroy_ctx(&ctx); 190 191 return 0; 192} 193 194/* 195 * Entry point for the 'pxe get' command. 196 * This Follows pxelinux's rules to download a config file from a tftp server. 197 * The file is stored at the location given by the pxefile_addr_r environment 198 * variable, which must be set. 199 * 200 * UUID comes from pxeuuid env variable, if defined 201 * MAC addr comes from ethaddr env variable, if defined 202 * IP 203 * 204 * see http://syslinux.zytor.com/wiki/index.php/PXELINUX 205 * 206 * Returns 0 on success or 1 on error. 207 */ 208static int 209do_pxe_get(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) 210{ 211 char *pxefile_addr_str; 212 ulong pxefile_addr_r; 213 char *fname; 214 ulong size; 215 int ret; 216 bool use_ipv6 = false; 217 218 if (IS_ENABLED(CONFIG_IPV6)) { 219 if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) 220 use_ipv6 = true; 221 222 if (!(argc == 1 || (argc == 2 && use_ipv6))) 223 return CMD_RET_USAGE; 224 } else { 225 if (argc != 1) 226 return CMD_RET_USAGE; 227 } 228 229 pxefile_addr_str = from_env("pxefile_addr_r"); 230 231 if (!pxefile_addr_str) 232 return 1; 233 234 ret = strict_strtoul(pxefile_addr_str, 16, 235 (unsigned long *)&pxefile_addr_r); 236 if (ret < 0) 237 return 1; 238 239 ret = pxe_get(pxefile_addr_r, &fname, &size, use_ipv6); 240 switch (ret) { 241 case 0: 242 printf("Config file '%s' found\n", fname); 243 break; 244 case -ENOMEM: 245 printf("Out of memory\n"); 246 return CMD_RET_FAILURE; 247 default: 248 printf("Config file not found\n"); 249 return CMD_RET_FAILURE; 250 } 251 252 return 0; 253} 254 255/* 256 * Boots a system using a pxe file 257 * 258 * Returns 0 on success, 1 on error. 259 */ 260static int 261do_pxe_boot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) 262{ 263 unsigned long pxefile_addr_r; 264 char *pxefile_addr_str; 265 struct pxe_context ctx; 266 int ret; 267 bool use_ipv6 = false; 268 269 if (IS_ENABLED(CONFIG_IPV6)) { 270 if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) 271 use_ipv6 = true; 272 } 273 274 if (argc == 1 || (argc == 2 && use_ipv6)) { 275 pxefile_addr_str = from_env("pxefile_addr_r"); 276 if (!pxefile_addr_str) 277 return 1; 278 279 } else if (argc == 2 || (argc == 3 && use_ipv6)) { 280 pxefile_addr_str = argv[1]; 281 } else { 282 return CMD_RET_USAGE; 283 } 284 285 if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) { 286 printf("Invalid pxefile address: %s\n", pxefile_addr_str); 287 return 1; 288 } 289 290 if (pxe_setup_ctx(&ctx, cmdtp, do_get_tftp, NULL, false, 291 env_get("bootfile"), use_ipv6)) { 292 printf("Out of memory\n"); 293 return CMD_RET_FAILURE; 294 } 295 ret = pxe_process(&ctx, pxefile_addr_r, false); 296 pxe_destroy_ctx(&ctx); 297 if (ret) 298 return CMD_RET_FAILURE; 299 300 copy_filename(net_boot_file_name, "", sizeof(net_boot_file_name)); 301 302 return 0; 303} 304 305static struct cmd_tbl cmd_pxe_sub[] = { 306 U_BOOT_CMD_MKENT(get, 2, 1, do_pxe_get, "", ""), 307 U_BOOT_CMD_MKENT(boot, 3, 1, do_pxe_boot, "", "") 308}; 309 310static int do_pxe(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) 311{ 312 struct cmd_tbl *cp; 313 314 if (argc < 2) 315 return CMD_RET_USAGE; 316 317 /* drop initial "pxe" arg */ 318 argc--; 319 argv++; 320 321 cp = find_cmd_tbl(argv[0], cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub)); 322 323 if (cp) 324 return cp->cmd(cmdtp, flag, argc, argv); 325 326 return CMD_RET_USAGE; 327} 328 329U_BOOT_CMD(pxe, 4, 1, do_pxe, 330 "get and boot from pxe files", 331 "get [" USE_IP6_CMD_PARAM "] - try to retrieve a pxe file using tftp\n" 332 "pxe boot [pxefile_addr_r] [-ipv6] - boot from the pxe file at pxefile_addr_r\n" 333); 334 335#endif /* CONFIG_CMD_NET */ 336