1 /*
2  * Copyright 2018 Google Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "bt.hpp"
18 #include "io.hpp"
19 #include "lpc.hpp"
20 #include "net.hpp"
21 #include "p2a.hpp"
22 #include "pci.hpp"
23 #include "pciaccess.hpp"
24 #include "progress.hpp"
25 #include "tool_errors.hpp"
26 #include "updater.hpp"
27 
28 /* Use CLI11 argument parser once in openbmc/meta-oe or whatever. */
29 #include <getopt.h>
30 
31 #include <ipmiblob/blob_handler.hpp>
32 #include <ipmiblob/ipmi_handler.hpp>
33 
34 #include <algorithm>
35 #include <cstdio>
36 #include <cstdlib>
37 #include <exception>
38 #include <iostream>
39 #include <iterator>
40 #include <limits>
41 #include <memory>
42 #include <string>
43 #include <vector>
44 
45 #define IPMILPC "ipmilpc"
46 #define IPMIPCI "ipmipci"
47 #define IPMIPCI_SKIP_BRIDGE_DISABLE "ipmipci-skip-bridge-disable"
48 #define IPMIBT "ipmibt"
49 #define IPMINET "ipminet"
50 
51 namespace
52 {
53 const std::vector<std::string> interfaceList = {
54     IPMINET, IPMIBT, IPMILPC, IPMIPCI, IPMIPCI_SKIP_BRIDGE_DISABLE};
55 } // namespace
56 
usage(const char * program)57 void usage(const char* program)
58 {
59     std::fprintf(
60         stderr,
61         "Usage: %s --command <command> --interface <interface> --image "
62         "<image file> --sig <signature file> --type <layout> "
63         "[--ignore-update]\n",
64         program);
65 
66     std::fprintf(stderr, "interfaces: ");
67     std::copy(interfaceList.begin(), interfaceList.end(),
68               std::ostream_iterator<std::string>(std::cerr, ", "));
69     std::fprintf(stderr, "\n");
70 
71     std::fprintf(stderr, "layouts examples: image, bios\n");
72     std::fprintf(stderr,
73                  "the type field specifies '/flash/{layout}' for a handler\n");
74 }
75 
checkCommand(const std::string & command)76 bool checkCommand(const std::string& command)
77 {
78     return (command == "update");
79 }
80 
checkInterface(const std::string & interface)81 bool checkInterface(const std::string& interface)
82 {
83     auto intf =
84         std::find(interfaceList.begin(), interfaceList.end(), interface);
85     return (intf != interfaceList.end());
86 }
87 
main(int argc,char * argv[])88 int main(int argc, char* argv[])
89 {
90     std::string command, interface, imagePath, signaturePath, type, host;
91     std::string port = "623";
92     char* valueEnd = nullptr;
93     long address = 0;
94     long length = 0;
95     std::uint32_t hostAddress = 0;
96     std::uint32_t hostLength = 0;
97     bool ignoreUpdate = false;
98 
99     while (1)
100     {
101         // clang-format off
102         static struct option long_options[] = {
103             {"command", required_argument, 0, 'c'},
104             {"interface", required_argument, 0, 'i'},
105             {"image", required_argument, 0, 'm'},
106             {"sig", required_argument, 0, 's'},
107             {"address", required_argument, 0, 'a'},
108             {"length", required_argument, 0, 'l'},
109             {"type", required_argument, 0, 't'},
110             {"ignore-update", no_argument, 0, 'u'},
111             {"host", required_argument, 0, 'H'},
112             {"port", optional_argument, 0, 'p'},
113             {0, 0, 0, 0}
114         };
115         // clang-format on
116 
117         int option_index = 0;
118         int c = getopt_long(argc, argv, "c:i:m:s:a:l:t:uH:p:", long_options,
119                             &option_index);
120         if (c == -1)
121         {
122             break;
123         }
124 
125         switch (c)
126         {
127             case 'c':
128                 command = std::string{optarg};
129                 if (!checkCommand(command))
130                 {
131                     usage(argv[0]);
132                     exit(EXIT_FAILURE);
133                 }
134 
135                 break;
136             case 'i':
137                 interface = std::string{optarg};
138                 if (!checkInterface(interface))
139                 {
140                     usage(argv[0]);
141                     exit(EXIT_FAILURE);
142                 }
143                 break;
144             case 'm':
145                 imagePath = std::string{optarg};
146                 break;
147             case 's':
148                 signaturePath = std::string{optarg};
149                 break;
150             case 'a':
151                 address = std::strtol(&optarg[0], &valueEnd, 0);
152                 if (valueEnd == nullptr)
153                 {
154                     usage(argv[0]);
155                     exit(EXIT_FAILURE);
156                 }
157                 if (address > std::numeric_limits<std::uint32_t>::max())
158                 {
159                     std::fprintf(stderr, "Address beyond 32-bit limit.\n");
160                     usage(argv[0]);
161                     exit(EXIT_FAILURE);
162                 }
163                 hostAddress = static_cast<std::uint32_t>(address);
164                 break;
165             case 'l':
166                 length = std::strtol(&optarg[0], &valueEnd, 0);
167                 if (valueEnd == nullptr)
168                 {
169                     usage(argv[0]);
170                     exit(EXIT_FAILURE);
171                 }
172                 if (length > std::numeric_limits<std::uint32_t>::max())
173                 {
174                     std::fprintf(stderr, "Length beyond 32-bit limit.\n");
175                     usage(argv[0]);
176                     exit(EXIT_FAILURE);
177                 }
178                 hostLength = static_cast<std::uint32_t>(length);
179                 break;
180             case 't':
181                 type = std::string{optarg};
182                 break;
183             case 'u':
184                 ignoreUpdate = true;
185                 break;
186             case 'H':
187                 host = std::string{optarg};
188                 break;
189             case 'p':
190                 port = std::string{optarg};
191                 break;
192             default:
193                 usage(argv[0]);
194                 exit(EXIT_FAILURE);
195         }
196     }
197 
198     if (command.empty())
199     {
200         usage(argv[0]);
201         exit(EXIT_FAILURE);
202     }
203 
204     /* They want to update the firmware. */
205     if (command == "update")
206     {
207         if (interface.empty() || imagePath.empty() || signaturePath.empty() ||
208             type.empty())
209         {
210             usage(argv[0]);
211             exit(EXIT_FAILURE);
212         }
213 
214         auto ipmi = ipmiblob::IpmiHandler::CreateIpmiHandler();
215         ipmiblob::BlobHandler blob(std::move(ipmi));
216 #ifdef ENABLE_PPC
217         const std::string ppcMemPath = "/sys/kernel/debug/powerpc/lpc/fw";
218         host_tool::PpcMemDevice devmem(ppcMemPath);
219 #else
220         host_tool::DevMemDevice devmem;
221 #endif
222         host_tool::ProgressStdoutIndicator progress;
223 
224         std::unique_ptr<host_tool::DataInterface> handler;
225 
226         /* Input has already been validated in this case. */
227         if (interface == IPMIBT)
228         {
229             handler =
230                 std::make_unique<host_tool::BtDataHandler>(&blob, &progress);
231         }
232         else if (interface == IPMINET)
233         {
234             if (host.empty())
235             {
236                 std::fprintf(stderr, "Host not specified\n");
237                 exit(EXIT_FAILURE);
238             }
239             handler = std::make_unique<host_tool::NetDataHandler>(
240                 &blob, &progress, host, port);
241         }
242         else if (interface == IPMILPC)
243         {
244             if (hostAddress == 0 || hostLength == 0)
245             {
246                 std::fprintf(stderr, "Address or Length were 0\n");
247                 exit(EXIT_FAILURE);
248             }
249             handler = std::make_unique<host_tool::LpcDataHandler>(
250                 &blob, &devmem, hostAddress, hostLength, &progress);
251         }
252         else if (interface == IPMIPCI)
253         {
254             auto& pci = host_tool::PciAccessImpl::getInstance();
255             handler = std::make_unique<host_tool::P2aDataHandler>(
256                 &blob, &pci, &progress);
257         }
258         else if (interface == IPMIPCI_SKIP_BRIDGE_DISABLE)
259         {
260             auto& pci = host_tool::PciAccessImpl::getInstance();
261             handler = std::make_unique<host_tool::P2aDataHandler>(
262                 &blob, &pci, &progress, true);
263         }
264 
265         if (!handler)
266         {
267             /* TODO(venture): use a custom exception. */
268             std::fprintf(stderr, "Interface %s is unavailable\n",
269                          interface.c_str());
270             exit(EXIT_FAILURE);
271         }
272 
273         /* The parameters are all filled out. */
274         try
275         {
276             host_tool::UpdateHandler updater(&blob, handler.get());
277             host_tool::updaterMain(&updater, &blob, imagePath, signaturePath,
278                                    type, ignoreUpdate);
279         }
280         catch (const host_tool::ToolException& e)
281         {
282             std::fprintf(stderr, "Exception received: %s\n", e.what());
283             return -1;
284         }
285         catch (const std::exception& e)
286         {
287             std::fprintf(stderr, "Unexpected exception received: %s\n",
288                          e.what());
289             return -1;
290         }
291     }
292 
293     return 0;
294 }
295