xref: /openbmc/phosphor-networkd/src/ncsi_netlink_main.cpp (revision 0963c4b785e956811c67ba7f0b72062cb4aacbaa)
1 /**
2  * Copyright © 2018 IBM Corporation
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 #include "argument.hpp"
17 #include "ncsi_util.hpp"
18 
19 #include <string.h>
20 #include <unistd.h>
21 
22 #include <phosphor-logging/lg2.hpp>
23 #include <stdplus/numeric/str.hpp>
24 #include <stdplus/str/buf.hpp>
25 
26 #include <string>
27 #include <vector>
28 
exitWithError(const char * err,char ** argv)29 static void exitWithError(const char* err, char** argv)
30 {
31     phosphor::network::ncsi::ArgumentParser::usage(argv);
32     lg2::error("ERROR: {ERROR}", "ERROR", err);
33     exit(EXIT_FAILURE);
34 }
35 
printInfo(phosphor::network::ncsi::InterfaceInfo & info)36 static void printInfo(phosphor::network::ncsi::InterfaceInfo& info)
37 {
38     using namespace phosphor::network::ncsi;
39 
40     for (PackageInfo& pkg : info.packages)
41     {
42         lg2::debug("Package id : {ID}", "ID", pkg.id);
43         if (pkg.forced)
44         {
45             lg2::debug("  package is forced");
46         }
47         for (ChannelInfo& chan : pkg.channels)
48         {
49             lg2::debug("    Channel id : {ID}", "ID", chan.id);
50             if (chan.forced)
51             {
52                 lg2::debug("    channel is forced");
53             }
54             if (chan.active)
55             {
56                 lg2::debug("    channel is active");
57             }
58 
59             lg2::debug("      version {MAJOR}.{MINOR} ({STR})", "MAJOR",
60                        chan.version_major, "MINOR", chan.version_minor, "STR",
61                        chan.version);
62 
63             lg2::debug("      link state {LINK}", "LINK", lg2::hex,
64                        chan.link_state);
65 
66             auto& vlans = chan.vlan_ids;
67 
68             if (!vlans.empty())
69             {
70                 lg2::debug("      Actve VLAN IDs:");
71                 for (uint16_t vlan : vlans)
72                 {
73                     lg2::debug("        VID: {VLAN_ID}", "VLAN_ID", vlan);
74                 }
75             }
76         }
77     }
78 }
79 
main(int argc,char ** argv)80 int main(int argc, char** argv)
81 {
82     using namespace phosphor::network;
83     using namespace phosphor::network::ncsi;
84     // Read arguments.
85     auto options = ArgumentParser(argc, argv);
86     int packageInt{};
87     int channelInt{};
88     int indexInt{};
89 
90     // Parse out interface argument.
91     auto ifIndex = (options)["index"];
92     try
93     {
94         indexInt = stoi(ifIndex, nullptr);
95     }
96     catch (const std::exception& e)
97     {
98         exitWithError("Interface not specified.", argv);
99     }
100 
101     if (indexInt < 0)
102     {
103         exitWithError("Interface value should be greater than equal to 0",
104                       argv);
105     }
106 
107     NetlinkInterface interface(indexInt);
108 
109     // Parse out package argument.
110     auto package = (options)["package"];
111     try
112     {
113         packageInt = stoi(package, nullptr);
114     }
115     catch (const std::exception& e)
116     {
117         packageInt = DEFAULT_VALUE;
118     }
119 
120     if (packageInt < 0)
121     {
122         packageInt = DEFAULT_VALUE;
123     }
124 
125     // Parse out channel argument.
126     auto channel = (options)["channel"];
127     try
128     {
129         channelInt = stoi(channel, nullptr);
130     }
131     catch (const std::exception& e)
132     {
133         channelInt = DEFAULT_VALUE;
134     }
135 
136     if (channelInt < 0)
137     {
138         channelInt = DEFAULT_VALUE;
139     }
140 
141     auto payloadStr = (options)["oem-payload"];
142     if (!payloadStr.empty())
143     {
144         if (payloadStr.size() % 2 || payloadStr.size() < 2)
145             exitWithError("Payload invalid: specify two hex digits per byte.",
146                           argv);
147 
148         // Payload string is in the format <type>[<payload>]
149         // (e.g. "50000001572100"), where the first two characters (i.e. "50")
150         // represent the command type, and the rest the payload. Split this
151         // up for the ncsi-cmd operation, which has these as separate arguments.
152         std::string typeStr(payloadStr.substr(0, 2));
153         std::string dataStr(payloadStr.substr(2));
154 
155         if (packageInt == DEFAULT_VALUE)
156         {
157             exitWithError("Package not specified.", argv);
158         }
159 
160         std::vector<std::string> args = {
161             "ncsi-cmd",
162             "-i",
163             std::to_string(indexInt),
164             "-p",
165             std::to_string(packageInt),
166         };
167 
168         if (channelInt != DEFAULT_VALUE)
169         {
170             args.push_back("-c");
171             args.push_back(std::to_string(channelInt));
172         }
173 
174         args.push_back("raw");
175         args.push_back(typeStr);
176         args.push_back(dataStr);
177 
178         /* Convert to C argv array. execvp()'s argv argument is not const,
179          * whereas .c_str() is, so we need to strdup here.
180          */
181         char** argv = new char*[args.size() + 1]();
182         for (size_t i = 0; i < args.size(); i++)
183         {
184             argv[i] = strdup(args[i].c_str());
185         }
186         argv[args.size()] = NULL;
187 
188         lg2::debug("ncsi-netlink [..] -o is deprecated by ncsi-cmd");
189         execvp(argv[0], argv);
190         lg2::error("exec failed; use ncsi-cmd directly");
191 
192         for (size_t i = 0; i < args.size(); i++)
193         {
194             free(argv[i]);
195         }
196         delete[] argv;
197         return EXIT_FAILURE;
198     }
199     else if ((options)["set"] == "true")
200     {
201         // Can not perform set operation without package.
202         if (packageInt == DEFAULT_VALUE)
203         {
204             exitWithError("Package not specified.", argv);
205         }
206         return interface.setChannel(packageInt, channelInt);
207     }
208     else if ((options)["info"] == "true")
209     {
210         auto info = interface.getInfo(packageInt);
211         if (!info)
212         {
213             return EXIT_FAILURE;
214         }
215         printInfo(*info);
216     }
217     else if ((options)["clear"] == "true")
218     {
219         return interface.clearInterface();
220     }
221     else if (!(options)["pmask"].empty())
222     {
223         unsigned int mask{};
224         try
225         {
226             size_t lastChar{};
227             mask = std::stoul((options)["pmask"], &lastChar, 0);
228             if (lastChar < (options["pmask"].size()))
229             {
230                 exitWithError("Package mask value is not valid", argv);
231             }
232         }
233         catch (const std::exception& e)
234         {
235             exitWithError("Package mask value is not valid", argv);
236         }
237         return interface.setPackageMask(mask);
238     }
239     else if (!(options)["cmask"].empty())
240     {
241         if (packageInt == DEFAULT_VALUE)
242         {
243             exitWithError("Package is not specified", argv);
244         }
245         unsigned int mask{};
246         try
247         {
248             size_t lastChar{};
249             mask = stoul((options)["cmask"], &lastChar, 0);
250             if (lastChar < (options["cmask"].size()))
251             {
252                 exitWithError("Channel mask value is not valid", argv);
253             }
254         }
255         catch (const std::exception& e)
256         {
257             exitWithError("Channel mask value is not valid", argv);
258         }
259         return interface.setChannelMask(packageInt, mask);
260     }
261     else
262     {
263         exitWithError("No Command specified", argv);
264     }
265     return 0;
266 }
267