blob: 84d37eafc9a0fd90b0f8036d4c8e8b1b3c652dcf [file] [log] [blame]
vishwabmcba0bd5f2015-09-30 16:50:23 +05301#include <stdio.h>
2#include <dlfcn.h>
3#include <iostream>
4#include <unistd.h>
5#include <assert.h>
6#include <dirent.h>
Chris Austen0ba649e2015-10-13 12:28:13 -05007#include <systemd/sd-bus.h>
vishwabmcba0bd5f2015-09-30 16:50:23 +05308#include <string.h>
9#include <stdlib.h>
10#include <map>
Patrick Williams53a360e2016-08-12 22:01:02 -050011#include "ipmid.hpp"
Chris Austen0ba649e2015-10-13 12:28:13 -050012#include <sys/time.h>
13#include <errno.h>
Brad Bishop35518682016-07-22 08:35:41 -040014#include <mapper.h>
Chris Austen0012e9b2015-10-22 01:37:46 -050015#include "sensorhandler.h"
Tom Joseph9a61b4f2016-07-11 06:56:11 -050016#include <vector>
17#include <algorithm>
18#include <iterator>
Patrick Williams4b9efaa2016-08-12 21:59:51 -050019#include <ipmiwhitelist.hpp>
Chris Austen0ba649e2015-10-13 12:28:13 -050020
Chris Austen0ba649e2015-10-13 12:28:13 -050021sd_bus *bus = NULL;
vishwab9f559a2016-01-13 01:53:08 -060022sd_bus_slot *ipmid_slot = NULL;
Chris Austen30195fa2015-11-13 14:39:19 -060023
Tom Joseph9a61b4f2016-07-11 06:56:11 -050024// Initialise restricted mode to true
25bool restricted_mode = true;
26
Chris Austen41a4b312015-10-25 03:45:42 -050027FILE *ipmiio, *ipmidbus, *ipmicmddetails;
vishwabmcba0bd5f2015-09-30 16:50:23 +053028
Chris Austen99497312015-10-22 13:00:16 -050029void print_usage(void) {
30 fprintf(stderr, "Options: [-d mask]\n");
31 fprintf(stderr, " mask : 0x01 - Print ipmi packets\n");
32 fprintf(stderr, " mask : 0x02 - Print DBUS operations\n");
33 fprintf(stderr, " mask : 0x04 - Print ipmi command details\n");
34 fprintf(stderr, " mask : 0xFF - Print all trace\n");
35}
36
Tom Joseph9a61b4f2016-07-11 06:56:11 -050037// Host settings in DBUS
Tom Joseph9a61b4f2016-07-11 06:56:11 -050038constexpr char settings_host_object[] = "/org/openbmc/settings/host0";
39constexpr char settings_host_intf[] = "org.freedesktop.DBus.Properties";
40
Jeremy Kerre41081f2015-10-27 12:11:36 +080041const char * DBUS_INTF = "org.openbmc.HostIpmi";
vishwabmcba0bd5f2015-09-30 16:50:23 +053042
Jeremy Kerre41081f2015-10-27 12:11:36 +080043const char * FILTER = "type='signal',interface='org.openbmc.HostIpmi',member='ReceivedMessage'";
Tom Joseph9a61b4f2016-07-11 06:56:11 -050044constexpr char RESTRICTED_MODE_FILTER[] = "type='signal',interface='org.freedesktop.DBus.Properties',path='/org/openbmc/settings/host0'";
Chris Austen0ba649e2015-10-13 12:28:13 -050045
vishwabmcba0bd5f2015-09-30 16:50:23 +053046typedef std::pair<ipmi_netfn_t, ipmi_cmd_t> ipmi_fn_cmd_t;
47typedef std::pair<ipmid_callback_t, ipmi_context_t> ipmi_fn_context_t;
48
49// Global data structure that contains the IPMI command handler's registrations.
50std::map<ipmi_fn_cmd_t, ipmi_fn_context_t> g_ipmid_router_map;
51
Nan Li36c0cb62016-03-31 11:16:08 +080052// IPMI Spec, shared Reservation ID.
53unsigned short g_sel_reserve = 0xFFFF;
54
55unsigned short get_sel_reserve_id(void)
56{
57 return g_sel_reserve;
58}
Chris Austen0ba649e2015-10-13 12:28:13 -050059
Chris Austen0ba649e2015-10-13 12:28:13 -050060#ifndef HEXDUMP_COLS
61#define HEXDUMP_COLS 16
62#endif
63
Chris Austen99497312015-10-22 13:00:16 -050064void hexdump(FILE *s, void *mem, size_t len)
Chris Austen0ba649e2015-10-13 12:28:13 -050065{
66 unsigned int i, j;
Chris Austen120f7322015-10-14 23:27:31 -050067
Chris Austen0ba649e2015-10-13 12:28:13 -050068 for(i = 0; i < len + ((len % HEXDUMP_COLS) ? (HEXDUMP_COLS - len % HEXDUMP_COLS) : 0); i++)
69 {
70 /* print offset */
71 if(i % HEXDUMP_COLS == 0)
72 {
Chris Austen99497312015-10-22 13:00:16 -050073 fprintf(s,"0x%06x: ", i);
Chris Austen0ba649e2015-10-13 12:28:13 -050074 }
Chris Austen120f7322015-10-14 23:27:31 -050075
Chris Austen0ba649e2015-10-13 12:28:13 -050076 /* print hex data */
77 if(i < len)
78 {
Chris Austen99497312015-10-22 13:00:16 -050079 fprintf(s,"%02x ", 0xFF & ((char*)mem)[i]);
Chris Austen0ba649e2015-10-13 12:28:13 -050080 }
81 else /* end of block, just aligning for ASCII dump */
82 {
Chris Austen99497312015-10-22 13:00:16 -050083 fprintf(s," ");
Chris Austen0ba649e2015-10-13 12:28:13 -050084 }
Chris Austen120f7322015-10-14 23:27:31 -050085
Chris Austen0ba649e2015-10-13 12:28:13 -050086 /* print ASCII dump */
87 if(i % HEXDUMP_COLS == (HEXDUMP_COLS - 1))
88 {
89 for(j = i - (HEXDUMP_COLS - 1); j <= i; j++)
90 {
91 if(j >= len) /* end of block, not really printing */
92 {
Chris Austen99497312015-10-22 13:00:16 -050093 fputc(' ', s);
Chris Austen0ba649e2015-10-13 12:28:13 -050094 }
95 else if(isprint(((char*)mem)[j])) /* printable char */
96 {
Chris Austen99497312015-10-22 13:00:16 -050097 fputc(0xFF & ((char*)mem)[j], s);
Chris Austen0ba649e2015-10-13 12:28:13 -050098 }
99 else /* other char */
100 {
Chris Austen99497312015-10-22 13:00:16 -0500101 fputc('.',s);
Chris Austen0ba649e2015-10-13 12:28:13 -0500102 }
103 }
Chris Austen99497312015-10-22 13:00:16 -0500104 fputc('\n',s);
Chris Austen0ba649e2015-10-13 12:28:13 -0500105 }
106 }
107}
108
109
vishwabmcba0bd5f2015-09-30 16:50:23 +0530110// Method that gets called by shared libraries to get their command handlers registered
111void ipmi_register_callback(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
112 ipmi_context_t context, ipmid_callback_t handler)
113{
114 // Pack NetFn and Command in one.
115 auto netfn_and_cmd = std::make_pair(netfn, cmd);
116
117 // Pack Function handler and Data in another.
118 auto handler_and_context = std::make_pair(handler, context);
119
120 // Check if the registration has already been made..
121 auto iter = g_ipmid_router_map.find(netfn_and_cmd);
122 if(iter != g_ipmid_router_map.end())
123 {
124 fprintf(stderr,"ERROR : Duplicate registration for NetFn [0x%X], Cmd:[0x%X]\n",netfn, cmd);
125 }
126 else
127 {
128 // This is a fresh registration.. Add it to the map.
129 g_ipmid_router_map.emplace(netfn_and_cmd, handler_and_context);
130 }
131
132 return;
133}
134
135// Looks at the map and calls corresponding handler functions.
136ipmi_ret_t ipmi_netfn_router(ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
137 ipmi_response_t response, ipmi_data_len_t data_len)
138{
139 // return from the Command handlers.
140 ipmi_ret_t rc = IPMI_CC_INVALID;
141
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500142 // If restricted mode is true and command is not whitelisted, don't
143 // execute the command
144 if(restricted_mode)
145 {
146 if (!std::binary_search(whitelist.cbegin(), whitelist.cend(),
147 std::make_pair(netfn, cmd)))
148 {
149 printf("Net function:[0x%X], Command:[0x%X] is not whitelisted\n",
150 netfn, cmd);
151 rc = IPMI_CC_INSUFFICIENT_PRIVILEGE;
152 memcpy(response, &rc, IPMI_CC_LEN);
153 *data_len = IPMI_CC_LEN;
154 return rc;
155 }
156 }
157
vishwabmcba0bd5f2015-09-30 16:50:23 +0530158 // Walk the map that has the registered handlers and invoke the approprite
159 // handlers for matching commands.
160 auto iter = g_ipmid_router_map.find(std::make_pair(netfn, cmd));
161 if(iter == g_ipmid_router_map.end())
162 {
Chris Austen99497312015-10-22 13:00:16 -0500163 fprintf(stderr, "No registered handlers for NetFn:[0x%X], Cmd:[0x%X]"
vishwabmcba0bd5f2015-09-30 16:50:23 +0530164 " trying Wilcard implementation \n",netfn, cmd);
165
166 // Now that we did not find any specific [NetFn,Cmd], tuple, check for
167 // NetFn, WildCard command present.
168 iter = g_ipmid_router_map.find(std::make_pair(netfn, IPMI_CMD_WILDCARD));
169 if(iter == g_ipmid_router_map.end())
170 {
Chris Austen99497312015-10-22 13:00:16 -0500171 fprintf(stderr, "No Registered handlers for NetFn:[0x%X],Cmd:[0x%X]\n",netfn, IPMI_CMD_WILDCARD);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530172
173 // Respond with a 0xC1
174 memcpy(response, &rc, IPMI_CC_LEN);
175 *data_len = IPMI_CC_LEN;
176 return rc;
177 }
178 }
179
180#ifdef __IPMI_DEBUG__
181 // We have either a perfect match -OR- a wild card atleast,
182 printf("Calling Net function:[0x%X], Command:[0x%X]\n", netfn, cmd);
183#endif
184
185 // Extract the map data onto appropriate containers
186 auto handler_and_context = iter->second;
187
188 // Creating a pointer type casted to char* to make sure we advance 1 byte
189 // when we advance pointer to next's address. advancing void * would not
190 // make sense.
191 char *respo = &((char *)response)[IPMI_CC_LEN];
192
193 // Response message from the plugin goes into a byte post the base response
194 rc = (handler_and_context.first) (netfn, cmd, request, respo,
195 data_len, handler_and_context.second);
Chris Austen120f7322015-10-14 23:27:31 -0500196
vishwabmcba0bd5f2015-09-30 16:50:23 +0530197 // Now copy the return code that we got from handler and pack it in first
198 // byte.
199 memcpy(response, &rc, IPMI_CC_LEN);
Chris Austen120f7322015-10-14 23:27:31 -0500200
vishwabmcba0bd5f2015-09-30 16:50:23 +0530201 // Data length is now actual data + completion code.
202 *data_len = *data_len + IPMI_CC_LEN;
203
204 return rc;
205}
206
vishwabmcba0bd5f2015-09-30 16:50:23 +0530207
vishwabmcba0bd5f2015-09-30 16:50:23 +0530208
vishwabmcba0bd5f2015-09-30 16:50:23 +0530209
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800210static int send_ipmi_message(sd_bus_message *req, unsigned char seq, unsigned char netfn, unsigned char lun, unsigned char cmd, unsigned char cc, unsigned char *buf, unsigned char len) {
vishwabmcba0bd5f2015-09-30 16:50:23 +0530211
Chris Austen0ba649e2015-10-13 12:28:13 -0500212 sd_bus_error error = SD_BUS_ERROR_NULL;
213 sd_bus_message *reply = NULL, *m=NULL;
Jeremy Kerre41081f2015-10-27 12:11:36 +0800214 const char *dest, *path;
Chris Austen0ba649e2015-10-13 12:28:13 -0500215 int r, pty;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530216
Jeremy Kerre41081f2015-10-27 12:11:36 +0800217 dest = sd_bus_message_get_sender(req);
218 path = sd_bus_message_get_path(req);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530219
Jeremy Kerre41081f2015-10-27 12:11:36 +0800220 r = sd_bus_message_new_method_call(bus,&m,dest,path,DBUS_INTF,"sendMessage");
Chris Austen0ba649e2015-10-13 12:28:13 -0500221 if (r < 0) {
222 fprintf(stderr, "Failed to add the method object: %s\n", strerror(-r));
223 return -1;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530224 }
225
vishwabmcba0bd5f2015-09-30 16:50:23 +0530226
Chris Austenabfb5e82015-10-13 12:29:24 -0500227 // Responses in IPMI require a bit set. So there ya go...
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800228 netfn |= 0x01;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530229
Chris Austen0ba649e2015-10-13 12:28:13 -0500230
231 // Add the bytes needed for the methods to be called
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800232 r = sd_bus_message_append(m, "yyyyy", seq, netfn, lun, cmd, cc);
Chris Austen0ba649e2015-10-13 12:28:13 -0500233 if (r < 0) {
234 fprintf(stderr, "Failed add the netfn and others : %s\n", strerror(-r));
Chris Austen169395e2015-12-02 20:56:15 -0600235 goto final;
Chris Austen0ba649e2015-10-13 12:28:13 -0500236 }
Chris Austen120f7322015-10-14 23:27:31 -0500237
Chris Austen0ba649e2015-10-13 12:28:13 -0500238 r = sd_bus_message_append_array(m, 'y', buf, len);
239 if (r < 0) {
240 fprintf(stderr, "Failed to add the string of response bytes: %s\n", strerror(-r));
Chris Austen169395e2015-12-02 20:56:15 -0600241 goto final;
Chris Austen0ba649e2015-10-13 12:28:13 -0500242 }
243
244
245
246 // Call the IPMI responder on the bus so the message can be sent to the CEC
247 r = sd_bus_call(bus, m, 0, &error, &reply);
248 if (r < 0) {
Chris Austen169395e2015-12-02 20:56:15 -0600249 fprintf(stderr, "Failed to call the method: %s\n", strerror(-r));
Chris Austen6bd23962015-12-07 21:31:48 -0600250 fprintf(stderr, "Dest: %s, Path: %s\n", dest, path);
Chris Austen169395e2015-12-02 20:56:15 -0600251 goto final;
Chris Austen0ba649e2015-10-13 12:28:13 -0500252 }
253
254 r = sd_bus_message_read(reply, "x", &pty);
Chris Austen0ba649e2015-10-13 12:28:13 -0500255 if (r < 0) {
256 fprintf(stderr, "Failed to get a rc from the method: %s\n", strerror(-r));
Chris Austen0ba649e2015-10-13 12:28:13 -0500257 }
258
Chris Austen169395e2015-12-02 20:56:15 -0600259final:
Chris Austen0ba649e2015-10-13 12:28:13 -0500260 sd_bus_error_free(&error);
vishwa1eaea4f2016-02-26 11:57:40 -0600261 m = sd_bus_message_unref(m);
262 reply = sd_bus_message_unref(reply);
Chris Austen0ba649e2015-10-13 12:28:13 -0500263
Chris Austen0ba649e2015-10-13 12:28:13 -0500264 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
Chris Austen0ba649e2015-10-13 12:28:13 -0500265}
266
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500267void cache_restricted_mode()
268{
269 sd_bus *bus = ipmid_get_sd_bus_connection();
270 sd_bus_message *reply = NULL;
271 sd_bus_error error = SD_BUS_ERROR_NULL;
272 int rc = 0;
Sergey Solomineb9b8142016-08-23 09:07:28 -0500273 char *busname = NULL;
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500274
Sergey Solomineb9b8142016-08-23 09:07:28 -0500275 rc = mapper_get_service(bus, settings_host_object, &busname);
276 if (rc < 0) {
Brad Bishop819ddd42016-10-05 21:19:19 -0400277 fprintf(stderr, "Failed to get %s busname: %s\n",
278 settings_host_object, strerror(-rc));
Sergey Solomineb9b8142016-08-23 09:07:28 -0500279 goto cleanup;
280 }
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500281 rc = sd_bus_call_method(bus,
Sergey Solomineb9b8142016-08-23 09:07:28 -0500282 busname,
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500283 settings_host_object,
284 settings_host_intf,
285 "Get",
286 &error,
287 &reply,
288 "ss",
Sergey Solomineb9b8142016-08-23 09:07:28 -0500289 "org.openbmc.settings.Host",
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500290 "restricted_mode");
291 if(rc < 0)
292 {
293 fprintf(stderr, "Failed sd_bus_call_method method for restricted mode: %s\n",
294 strerror(-rc));
295 goto cleanup;
296 }
297
298 rc = sd_bus_message_read(reply, "v", "b", &restricted_mode);
299 if(rc < 0)
300 {
301 fprintf(stderr, "Failed to parse response message for restricted mode: %s\n",
302 strerror(-rc));
303 // Fail-safe to restricted mode
304 restricted_mode = true;
305 }
306
307 printf("Restricted mode = %d\n", restricted_mode);
308
309cleanup:
310 sd_bus_error_free(&error);
311 reply = sd_bus_message_unref(reply);
Sergey Solomineb9b8142016-08-23 09:07:28 -0500312 free(busname);
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500313}
314
315static int handle_restricted_mode_change(sd_bus_message *m, void *user_data,
316 sd_bus_error *ret_error)
317{
318 cache_restricted_mode();
319 return 0;
320}
321
Chris Austen0ba649e2015-10-13 12:28:13 -0500322static int handle_ipmi_command(sd_bus_message *m, void *user_data, sd_bus_error
323 *ret_error) {
324 int r = 0;
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800325 unsigned char sequence, netfn, lun, cmd;
Chris Austen0ba649e2015-10-13 12:28:13 -0500326 const void *request;
327 size_t sz;
328 size_t resplen =MAX_IPMI_BUFFER;
329 unsigned char response[MAX_IPMI_BUFFER];
330
Chris Austen0ba649e2015-10-13 12:28:13 -0500331 memset(response, 0, MAX_IPMI_BUFFER);
332
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800333 r = sd_bus_message_read(m, "yyyy", &sequence, &netfn, &lun, &cmd);
Chris Austen0ba649e2015-10-13 12:28:13 -0500334 if (r < 0) {
335 fprintf(stderr, "Failed to parse signal message: %s\n", strerror(-r));
336 return -1;
337 }
338
339 r = sd_bus_message_read_array(m, 'y', &request, &sz );
340 if (r < 0) {
341 fprintf(stderr, "Failed to parse signal message: %s\n", strerror(-r));
342 return -1;
343 }
344
Chris Austen99497312015-10-22 13:00:16 -0500345 fprintf(ipmiio, "IPMI Incoming: Seq 0x%02x, NetFn 0x%02x, CMD: 0x%02x \n", sequence, netfn, cmd);
346 hexdump(ipmiio, (void*)request, sz);
Chris Austen0ba649e2015-10-13 12:28:13 -0500347
Chris Austen120f7322015-10-14 23:27:31 -0500348 // Allow the length field to be used for both input and output of the
Chris Austen0ba649e2015-10-13 12:28:13 -0500349 // ipmi call
350 resplen = sz;
351
Chris Austen120f7322015-10-14 23:27:31 -0500352 // Now that we have parsed the entire byte array from the caller
vishwabmcba0bd5f2015-09-30 16:50:23 +0530353 // we can call the ipmi router to do the work...
Chris Austen0ba649e2015-10-13 12:28:13 -0500354 r = ipmi_netfn_router(netfn, cmd, (void *)request, (void *)response, &resplen);
355 if(r != 0)
vishwabmcba0bd5f2015-09-30 16:50:23 +0530356 {
Chris Austen0ba649e2015-10-13 12:28:13 -0500357 fprintf(stderr,"ERROR:[0x%X] handling NetFn:[0x%X], Cmd:[0x%X]\n",r, netfn, cmd);
Nan Li80be4b92016-05-23 19:30:49 +0800358
tomjose7ec0add2016-06-27 07:59:28 -0500359 if(r < 0) {
Nan Li80be4b92016-05-23 19:30:49 +0800360 response[0] = IPMI_CC_UNSPECIFIED_ERROR;
361 }
vishwabmcba0bd5f2015-09-30 16:50:23 +0530362 }
363
Chris Austen99497312015-10-22 13:00:16 -0500364 fprintf(ipmiio, "IPMI Response:\n");
365 hexdump(ipmiio, (void*)response, resplen);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530366
Chris Austen0ba649e2015-10-13 12:28:13 -0500367 // Send the response buffer from the ipmi command
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800368 r = send_ipmi_message(m, sequence, netfn, lun, cmd, response[0],
369 ((unsigned char *)response) + 1, resplen - 1);
Chris Austen0ba649e2015-10-13 12:28:13 -0500370 if (r < 0) {
371 fprintf(stderr, "Failed to send the response message\n");
372 return -1;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530373 }
374
vishwabmcba0bd5f2015-09-30 16:50:23 +0530375
Chris Austen0ba649e2015-10-13 12:28:13 -0500376 return 0;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530377}
378
Chris Austen0ba649e2015-10-13 12:28:13 -0500379
vishwabmcba0bd5f2015-09-30 16:50:23 +0530380//----------------------------------------------------------------------
381// handler_select
382// Select all the files ending with with .so. in the given diretcory
383// @d: dirent structure containing the file name
384//----------------------------------------------------------------------
385int handler_select(const struct dirent *entry)
386{
387 // To hold ".so" from entry->d_name;
388 char dname_copy[4] = {0};
389
390 // We want to avoid checking for everything and isolate to the ones having
Adriana Kobylak87e080b2016-07-10 13:16:53 -0500391 // .so.* or .so in them.
392 // Check for versioned libraries .so.*
393 if(strstr(entry->d_name, IPMI_PLUGIN_SONAME_EXTN))
394 {
395 return 1;
396 }
397 // Check for non versioned libraries .so
398 else if(strstr(entry->d_name, IPMI_PLUGIN_EXTN))
vishwabmcba0bd5f2015-09-30 16:50:23 +0530399 {
400 // It is possible that .so could be anywhere in the string but unlikely
Chris Austen120f7322015-10-14 23:27:31 -0500401 // But being careful here. Get the base address of the string, move
vishwabmcba0bd5f2015-09-30 16:50:23 +0530402 // until end and come back 3 steps and that gets what we need.
403 strcpy(dname_copy, (entry->d_name + strlen(entry->d_name)-strlen(IPMI_PLUGIN_EXTN)));
404 if(strcmp(dname_copy, IPMI_PLUGIN_EXTN) == 0)
405 {
406 return 1;
407 }
408 }
409 return 0;
410}
411
412// This will do a dlopen of every .so in ipmi_lib_path and will dlopen everything so that they will
Chris Austen120f7322015-10-14 23:27:31 -0500413// register a callback handler
vishwabmcba0bd5f2015-09-30 16:50:23 +0530414void ipmi_register_callback_handlers(const char* ipmi_lib_path)
415{
416 // For walking the ipmi_lib_path
417 struct dirent **handler_list;
418 int num_handlers = 0;
419
420 // This is used to check and abort if someone tries to register a bad one.
421 void *lib_handler = NULL;
422
423 if(ipmi_lib_path == NULL)
424 {
425 fprintf(stderr,"ERROR; No handlers to be registered for ipmi.. Aborting\n");
426 assert(0);
427 }
428 else
429 {
430 // 1: Open ipmi_lib_path. Its usually "/usr/lib/phosphor-host-ipmid"
431 // 2: Scan the directory for the files that end with .so
Chris Austen120f7322015-10-14 23:27:31 -0500432 // 3: For each one of them, just do a 'dlopen' so that they register
vishwabmcba0bd5f2015-09-30 16:50:23 +0530433 // the handlers for callback routines.
434
435 std::string handler_fqdn = ipmi_lib_path;
Chris Austen120f7322015-10-14 23:27:31 -0500436
vishwabmcba0bd5f2015-09-30 16:50:23 +0530437 // Append a "/" since we need to add the name of the .so. If there is
438 // already a .so, adding one more is not any harm.
439 handler_fqdn += "/";
440
441 num_handlers = scandir(ipmi_lib_path, &handler_list, handler_select, alphasort);
Nan Li36c0cb62016-03-31 11:16:08 +0800442 if (num_handlers < 0)
443 return;
Jeremy Kerr5e8f85e2015-10-27 13:43:54 +0800444
vishwabmcba0bd5f2015-09-30 16:50:23 +0530445 while(num_handlers--)
446 {
Chris Austen54030262015-10-13 12:30:46 -0500447 handler_fqdn = ipmi_lib_path;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530448 handler_fqdn += handler_list[num_handlers]->d_name;
Chris Austen54030262015-10-13 12:30:46 -0500449 printf("Registering handler:[%s]\n",handler_fqdn.c_str());
450
vishwabmcba0bd5f2015-09-30 16:50:23 +0530451 lib_handler = dlopen(handler_fqdn.c_str(), RTLD_NOW);
Nan Li36c0cb62016-03-31 11:16:08 +0800452
vishwabmcba0bd5f2015-09-30 16:50:23 +0530453 if(lib_handler == NULL)
454 {
Chris Austen120f7322015-10-14 23:27:31 -0500455 fprintf(stderr,"ERROR opening [%s]: %s\n",
456 handler_fqdn.c_str(), dlerror());
vishwabmcba0bd5f2015-09-30 16:50:23 +0530457 }
458 // Wipe the memory allocated for this particular entry.
459 free(handler_list[num_handlers]);
460 }
Nan Li36c0cb62016-03-31 11:16:08 +0800461
vishwabmcba0bd5f2015-09-30 16:50:23 +0530462 // Done with all registration.
463 free(handler_list);
464 }
465
466 // TODO : What to be done on the memory that is given by dlopen ?.
467 return;
468}
469
Chris Austen30195fa2015-11-13 14:39:19 -0600470sd_bus *ipmid_get_sd_bus_connection(void) {
471 return bus;
472}
473
vishwab9f559a2016-01-13 01:53:08 -0600474sd_bus_slot *ipmid_get_sd_bus_slot(void) {
475 return ipmid_slot;
476}
477
vishwabmcba0bd5f2015-09-30 16:50:23 +0530478int main(int argc, char *argv[])
479{
Chris Austen0ba649e2015-10-13 12:28:13 -0500480 int r;
Chris Austen99497312015-10-22 13:00:16 -0500481 unsigned long tvalue;
482 int c;
483
484
485
486 // This file and subsequient switch is for turning on levels
487 // of trace
488 ipmicmddetails = ipmiio = ipmidbus = fopen("/dev/null", "w");
489
490 while ((c = getopt (argc, argv, "h:d:")) != -1)
491 switch (c) {
492 case 'd':
493 tvalue = strtoul(optarg, NULL, 16);
494 if (1&tvalue) {
495 ipmiio = stdout;
496 }
497 if (2&tvalue) {
498 ipmidbus = stdout;
499 }
500 if (4&tvalue) {
501 ipmicmddetails = stdout;
502 }
503 break;
504 case 'h':
505 case '?':
506 print_usage();
507 return 1;
508 }
Chris Austen0ba649e2015-10-13 12:28:13 -0500509
510
Chris Austen0ba649e2015-10-13 12:28:13 -0500511 /* Connect to system bus */
512 r = sd_bus_open_system(&bus);
513 if (r < 0) {
514 fprintf(stderr, "Failed to connect to system bus: %s\n",
515 strerror(-r));
516 goto finish;
517 }
vishwabmcba0bd5f2015-09-30 16:50:23 +0530518
Chris Austen30195fa2015-11-13 14:39:19 -0600519 // Register all the handlers that provider implementation to IPMI commands.
520 ipmi_register_callback_handlers(HOST_IPMI_LIB_PATH);
521
vishwa36993272015-11-20 12:43:49 -0600522 // Watch for BT messages
vishwab9f559a2016-01-13 01:53:08 -0600523 r = sd_bus_add_match(bus, &ipmid_slot, FILTER, handle_ipmi_command, NULL);
Chris Austen0ba649e2015-10-13 12:28:13 -0500524 if (r < 0) {
525 fprintf(stderr, "Failed: sd_bus_add_match: %s : %s\n", strerror(-r), FILTER);
526 goto finish;
527 }
vishwabmcba0bd5f2015-09-30 16:50:23 +0530528
Tom Joseph9a61b4f2016-07-11 06:56:11 -0500529 // Wait for changes on Restricted mode
530 r = sd_bus_add_match(bus, &ipmid_slot, RESTRICTED_MODE_FILTER, handle_restricted_mode_change, NULL);
531 if (r < 0) {
532 fprintf(stderr, "Failed: sd_bus_add_match: %s : %s\n", strerror(-r), RESTRICTED_MODE_FILTER);
533 goto finish;
534 }
535
536 // Initialise restricted mode
537 cache_restricted_mode();
vishwabmcba0bd5f2015-09-30 16:50:23 +0530538
Chris Austen0ba649e2015-10-13 12:28:13 -0500539 for (;;) {
540 /* Process requests */
Chris Austen0ba649e2015-10-13 12:28:13 -0500541 r = sd_bus_process(bus, NULL);
542 if (r < 0) {
543 fprintf(stderr, "Failed to process bus: %s\n", strerror(-r));
544 goto finish;
545 }
546 if (r > 0) {
547 continue;
548 }
549
550 r = sd_bus_wait(bus, (uint64_t) - 1);
551 if (r < 0) {
552 fprintf(stderr, "Failed to wait on bus: %s\n", strerror(-r));
553 goto finish;
554 }
555 }
556
557finish:
vishwab9f559a2016-01-13 01:53:08 -0600558 sd_bus_slot_unref(ipmid_slot);
Chris Austen0ba649e2015-10-13 12:28:13 -0500559 sd_bus_unref(bus);
560 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
561
vishwabmcba0bd5f2015-09-30 16:50:23 +0530562}