cmd/pxe.c

   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 <command.h>
   8 #include <fs.h>
   9 #include <net.h>
  10 #include <net6.h>
  11 #include <malloc.h>
  12 #include <vsprintf.h>
  13
  14 #include "pxe_utils.h"
  15
  16 #ifdef CONFIG_CMD_NET
  17 const 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
  29 static 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  */
  63 static 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  */
  77 static 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  */
  95 static 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  */
 115 static 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
 134 int 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, false))
 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
 177 error_exit:
 178         pxe_destroy_ctx(&ctx);
 179
 180         return -ENOENT;
 181 done:
 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  */
 208 static int
 209 do_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  */
 260 static int
 261 do_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, false)) {
 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
 305 static 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
 310 static 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
 329 U_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 */