blob: 0c7be7b3d0005c9997b30000d110e33499b49812 [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>
11#include "ipmid.H"
Chris Austen0ba649e2015-10-13 12:28:13 -050012#include <sys/time.h>
13#include <errno.h>
Chris Austen0012e9b2015-10-22 01:37:46 -050014#include "sensorhandler.h"
Chris Austen0ba649e2015-10-13 12:28:13 -050015
16
17sd_bus *bus = NULL;
Chris Austen41a4b312015-10-25 03:45:42 -050018FILE *ipmiio, *ipmidbus, *ipmicmddetails;
vishwabmcba0bd5f2015-09-30 16:50:23 +053019
Chris Austen99497312015-10-22 13:00:16 -050020void print_usage(void) {
21 fprintf(stderr, "Options: [-d mask]\n");
22 fprintf(stderr, " mask : 0x01 - Print ipmi packets\n");
23 fprintf(stderr, " mask : 0x02 - Print DBUS operations\n");
24 fprintf(stderr, " mask : 0x04 - Print ipmi command details\n");
25 fprintf(stderr, " mask : 0xFF - Print all trace\n");
26}
27
28
29
Jeremy Kerre41081f2015-10-27 12:11:36 +080030const char * DBUS_INTF = "org.openbmc.HostIpmi";
vishwabmcba0bd5f2015-09-30 16:50:23 +053031
Jeremy Kerre41081f2015-10-27 12:11:36 +080032const char * FILTER = "type='signal',interface='org.openbmc.HostIpmi',member='ReceivedMessage'";
Chris Austen0ba649e2015-10-13 12:28:13 -050033
34
vishwabmcba0bd5f2015-09-30 16:50:23 +053035typedef std::pair<ipmi_netfn_t, ipmi_cmd_t> ipmi_fn_cmd_t;
36typedef std::pair<ipmid_callback_t, ipmi_context_t> ipmi_fn_context_t;
37
38// Global data structure that contains the IPMI command handler's registrations.
39std::map<ipmi_fn_cmd_t, ipmi_fn_context_t> g_ipmid_router_map;
40
Chris Austen0ba649e2015-10-13 12:28:13 -050041
42
43#ifndef HEXDUMP_COLS
44#define HEXDUMP_COLS 16
45#endif
46
Chris Austen99497312015-10-22 13:00:16 -050047void hexdump(FILE *s, void *mem, size_t len)
Chris Austen0ba649e2015-10-13 12:28:13 -050048{
49 unsigned int i, j;
Chris Austen120f7322015-10-14 23:27:31 -050050
Chris Austen0ba649e2015-10-13 12:28:13 -050051 for(i = 0; i < len + ((len % HEXDUMP_COLS) ? (HEXDUMP_COLS - len % HEXDUMP_COLS) : 0); i++)
52 {
53 /* print offset */
54 if(i % HEXDUMP_COLS == 0)
55 {
Chris Austen99497312015-10-22 13:00:16 -050056 fprintf(s,"0x%06x: ", i);
Chris Austen0ba649e2015-10-13 12:28:13 -050057 }
Chris Austen120f7322015-10-14 23:27:31 -050058
Chris Austen0ba649e2015-10-13 12:28:13 -050059 /* print hex data */
60 if(i < len)
61 {
Chris Austen99497312015-10-22 13:00:16 -050062 fprintf(s,"%02x ", 0xFF & ((char*)mem)[i]);
Chris Austen0ba649e2015-10-13 12:28:13 -050063 }
64 else /* end of block, just aligning for ASCII dump */
65 {
Chris Austen99497312015-10-22 13:00:16 -050066 fprintf(s," ");
Chris Austen0ba649e2015-10-13 12:28:13 -050067 }
Chris Austen120f7322015-10-14 23:27:31 -050068
Chris Austen0ba649e2015-10-13 12:28:13 -050069 /* print ASCII dump */
70 if(i % HEXDUMP_COLS == (HEXDUMP_COLS - 1))
71 {
72 for(j = i - (HEXDUMP_COLS - 1); j <= i; j++)
73 {
74 if(j >= len) /* end of block, not really printing */
75 {
Chris Austen99497312015-10-22 13:00:16 -050076 fputc(' ', s);
Chris Austen0ba649e2015-10-13 12:28:13 -050077 }
78 else if(isprint(((char*)mem)[j])) /* printable char */
79 {
Chris Austen99497312015-10-22 13:00:16 -050080 fputc(0xFF & ((char*)mem)[j], s);
Chris Austen0ba649e2015-10-13 12:28:13 -050081 }
82 else /* other char */
83 {
Chris Austen99497312015-10-22 13:00:16 -050084 fputc('.',s);
Chris Austen0ba649e2015-10-13 12:28:13 -050085 }
86 }
Chris Austen99497312015-10-22 13:00:16 -050087 fputc('\n',s);
Chris Austen0ba649e2015-10-13 12:28:13 -050088 }
89 }
90}
91
92
vishwabmcba0bd5f2015-09-30 16:50:23 +053093// Method that gets called by shared libraries to get their command handlers registered
94void ipmi_register_callback(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
95 ipmi_context_t context, ipmid_callback_t handler)
96{
97 // Pack NetFn and Command in one.
98 auto netfn_and_cmd = std::make_pair(netfn, cmd);
99
100 // Pack Function handler and Data in another.
101 auto handler_and_context = std::make_pair(handler, context);
102
103 // Check if the registration has already been made..
104 auto iter = g_ipmid_router_map.find(netfn_and_cmd);
105 if(iter != g_ipmid_router_map.end())
106 {
107 fprintf(stderr,"ERROR : Duplicate registration for NetFn [0x%X], Cmd:[0x%X]\n",netfn, cmd);
108 }
109 else
110 {
111 // This is a fresh registration.. Add it to the map.
112 g_ipmid_router_map.emplace(netfn_and_cmd, handler_and_context);
113 }
114
115 return;
116}
117
118// Looks at the map and calls corresponding handler functions.
119ipmi_ret_t ipmi_netfn_router(ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
120 ipmi_response_t response, ipmi_data_len_t data_len)
121{
122 // return from the Command handlers.
123 ipmi_ret_t rc = IPMI_CC_INVALID;
124
125 // Walk the map that has the registered handlers and invoke the approprite
126 // handlers for matching commands.
127 auto iter = g_ipmid_router_map.find(std::make_pair(netfn, cmd));
128 if(iter == g_ipmid_router_map.end())
129 {
Chris Austen99497312015-10-22 13:00:16 -0500130 fprintf(stderr, "No registered handlers for NetFn:[0x%X], Cmd:[0x%X]"
vishwabmcba0bd5f2015-09-30 16:50:23 +0530131 " trying Wilcard implementation \n",netfn, cmd);
132
133 // Now that we did not find any specific [NetFn,Cmd], tuple, check for
134 // NetFn, WildCard command present.
135 iter = g_ipmid_router_map.find(std::make_pair(netfn, IPMI_CMD_WILDCARD));
136 if(iter == g_ipmid_router_map.end())
137 {
Chris Austen99497312015-10-22 13:00:16 -0500138 fprintf(stderr, "No Registered handlers for NetFn:[0x%X],Cmd:[0x%X]\n",netfn, IPMI_CMD_WILDCARD);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530139
140 // Respond with a 0xC1
141 memcpy(response, &rc, IPMI_CC_LEN);
142 *data_len = IPMI_CC_LEN;
143 return rc;
144 }
145 }
146
147#ifdef __IPMI_DEBUG__
148 // We have either a perfect match -OR- a wild card atleast,
149 printf("Calling Net function:[0x%X], Command:[0x%X]\n", netfn, cmd);
150#endif
151
152 // Extract the map data onto appropriate containers
153 auto handler_and_context = iter->second;
154
155 // Creating a pointer type casted to char* to make sure we advance 1 byte
156 // when we advance pointer to next's address. advancing void * would not
157 // make sense.
158 char *respo = &((char *)response)[IPMI_CC_LEN];
159
160 // Response message from the plugin goes into a byte post the base response
161 rc = (handler_and_context.first) (netfn, cmd, request, respo,
162 data_len, handler_and_context.second);
Chris Austen120f7322015-10-14 23:27:31 -0500163
vishwabmcba0bd5f2015-09-30 16:50:23 +0530164 // Now copy the return code that we got from handler and pack it in first
165 // byte.
166 memcpy(response, &rc, IPMI_CC_LEN);
Chris Austen120f7322015-10-14 23:27:31 -0500167
vishwabmcba0bd5f2015-09-30 16:50:23 +0530168 // Data length is now actual data + completion code.
169 *data_len = *data_len + IPMI_CC_LEN;
170
171 return rc;
172}
173
vishwabmcba0bd5f2015-09-30 16:50:23 +0530174
vishwabmcba0bd5f2015-09-30 16:50:23 +0530175
vishwabmcba0bd5f2015-09-30 16:50:23 +0530176
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800177static 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 +0530178
Chris Austen0ba649e2015-10-13 12:28:13 -0500179 sd_bus_error error = SD_BUS_ERROR_NULL;
180 sd_bus_message *reply = NULL, *m=NULL;
Jeremy Kerre41081f2015-10-27 12:11:36 +0800181 const char *dest, *path;
Chris Austen0ba649e2015-10-13 12:28:13 -0500182 int r, pty;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530183
Jeremy Kerre41081f2015-10-27 12:11:36 +0800184 dest = sd_bus_message_get_sender(req);
185 path = sd_bus_message_get_path(req);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530186
Jeremy Kerre41081f2015-10-27 12:11:36 +0800187 r = sd_bus_message_new_method_call(bus,&m,dest,path,DBUS_INTF,"sendMessage");
Chris Austen0ba649e2015-10-13 12:28:13 -0500188 if (r < 0) {
189 fprintf(stderr, "Failed to add the method object: %s\n", strerror(-r));
190 return -1;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530191 }
192
vishwabmcba0bd5f2015-09-30 16:50:23 +0530193
Chris Austenabfb5e82015-10-13 12:29:24 -0500194 // Responses in IPMI require a bit set. So there ya go...
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800195 netfn |= 0x01;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530196
Chris Austen0ba649e2015-10-13 12:28:13 -0500197
198 // Add the bytes needed for the methods to be called
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800199 r = sd_bus_message_append(m, "yyyyy", seq, netfn, lun, cmd, cc);
Chris Austen0ba649e2015-10-13 12:28:13 -0500200 if (r < 0) {
201 fprintf(stderr, "Failed add the netfn and others : %s\n", strerror(-r));
202 return -1;
203 }
Chris Austen120f7322015-10-14 23:27:31 -0500204
Chris Austen0ba649e2015-10-13 12:28:13 -0500205 r = sd_bus_message_append_array(m, 'y', buf, len);
206 if (r < 0) {
207 fprintf(stderr, "Failed to add the string of response bytes: %s\n", strerror(-r));
208 return -1;
209 }
210
211
212
213 // Call the IPMI responder on the bus so the message can be sent to the CEC
214 r = sd_bus_call(bus, m, 0, &error, &reply);
215 if (r < 0) {
216 fprintf(stderr, "Failed to call the method: %s", strerror(-r));
217 return -1;
218 }
219
220 r = sd_bus_message_read(reply, "x", &pty);
Chris Austen0ba649e2015-10-13 12:28:13 -0500221 if (r < 0) {
222 fprintf(stderr, "Failed to get a rc from the method: %s\n", strerror(-r));
223
224 }
225
Chris Austen0ba649e2015-10-13 12:28:13 -0500226 sd_bus_error_free(&error);
227 sd_bus_message_unref(m);
228
229
Chris Austen0ba649e2015-10-13 12:28:13 -0500230 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
Chris Austen0ba649e2015-10-13 12:28:13 -0500231}
232
233static int handle_ipmi_command(sd_bus_message *m, void *user_data, sd_bus_error
234 *ret_error) {
235 int r = 0;
236 const char *msg = NULL;
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800237 unsigned char sequence, netfn, lun, cmd;
Chris Austen0ba649e2015-10-13 12:28:13 -0500238 const void *request;
239 size_t sz;
240 size_t resplen =MAX_IPMI_BUFFER;
241 unsigned char response[MAX_IPMI_BUFFER];
242
Chris Austen0ba649e2015-10-13 12:28:13 -0500243 memset(response, 0, MAX_IPMI_BUFFER);
244
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800245 r = sd_bus_message_read(m, "yyyy", &sequence, &netfn, &lun, &cmd);
Chris Austen0ba649e2015-10-13 12:28:13 -0500246 if (r < 0) {
247 fprintf(stderr, "Failed to parse signal message: %s\n", strerror(-r));
248 return -1;
249 }
250
251 r = sd_bus_message_read_array(m, 'y', &request, &sz );
252 if (r < 0) {
253 fprintf(stderr, "Failed to parse signal message: %s\n", strerror(-r));
254 return -1;
255 }
256
Chris Austen99497312015-10-22 13:00:16 -0500257 fprintf(ipmiio, "IPMI Incoming: Seq 0x%02x, NetFn 0x%02x, CMD: 0x%02x \n", sequence, netfn, cmd);
258 hexdump(ipmiio, (void*)request, sz);
Chris Austen0ba649e2015-10-13 12:28:13 -0500259
Chris Austen120f7322015-10-14 23:27:31 -0500260 // Allow the length field to be used for both input and output of the
Chris Austen0ba649e2015-10-13 12:28:13 -0500261 // ipmi call
262 resplen = sz;
263
Chris Austen120f7322015-10-14 23:27:31 -0500264 // Now that we have parsed the entire byte array from the caller
vishwabmcba0bd5f2015-09-30 16:50:23 +0530265 // we can call the ipmi router to do the work...
Chris Austen0ba649e2015-10-13 12:28:13 -0500266 r = ipmi_netfn_router(netfn, cmd, (void *)request, (void *)response, &resplen);
267 if(r != 0)
vishwabmcba0bd5f2015-09-30 16:50:23 +0530268 {
Chris Austen0ba649e2015-10-13 12:28:13 -0500269 fprintf(stderr,"ERROR:[0x%X] handling NetFn:[0x%X], Cmd:[0x%X]\n",r, netfn, cmd);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530270 }
271
Chris Austen99497312015-10-22 13:00:16 -0500272 fprintf(ipmiio, "IPMI Response:\n");
273 hexdump(ipmiio, (void*)response, resplen);
vishwabmcba0bd5f2015-09-30 16:50:23 +0530274
Chris Austen0ba649e2015-10-13 12:28:13 -0500275 // Send the response buffer from the ipmi command
Jeremy Kerr2564b1a2015-10-27 13:37:17 +0800276 r = send_ipmi_message(m, sequence, netfn, lun, cmd, response[0],
277 ((unsigned char *)response) + 1, resplen - 1);
Chris Austen0ba649e2015-10-13 12:28:13 -0500278 if (r < 0) {
279 fprintf(stderr, "Failed to send the response message\n");
280 return -1;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530281 }
282
vishwabmcba0bd5f2015-09-30 16:50:23 +0530283
Chris Austen0ba649e2015-10-13 12:28:13 -0500284 return 0;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530285}
286
Chris Austen0ba649e2015-10-13 12:28:13 -0500287
vishwabmcba0bd5f2015-09-30 16:50:23 +0530288//----------------------------------------------------------------------
289// handler_select
290// Select all the files ending with with .so. in the given diretcory
291// @d: dirent structure containing the file name
292//----------------------------------------------------------------------
293int handler_select(const struct dirent *entry)
294{
295 // To hold ".so" from entry->d_name;
296 char dname_copy[4] = {0};
297
298 // We want to avoid checking for everything and isolate to the ones having
299 // .so in them.
300 if(strstr(entry->d_name, IPMI_PLUGIN_EXTN))
301 {
302 // It is possible that .so could be anywhere in the string but unlikely
Chris Austen120f7322015-10-14 23:27:31 -0500303 // But being careful here. Get the base address of the string, move
vishwabmcba0bd5f2015-09-30 16:50:23 +0530304 // until end and come back 3 steps and that gets what we need.
305 strcpy(dname_copy, (entry->d_name + strlen(entry->d_name)-strlen(IPMI_PLUGIN_EXTN)));
306 if(strcmp(dname_copy, IPMI_PLUGIN_EXTN) == 0)
307 {
308 return 1;
309 }
310 }
311 return 0;
312}
313
314// 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 -0500315// register a callback handler
vishwabmcba0bd5f2015-09-30 16:50:23 +0530316void ipmi_register_callback_handlers(const char* ipmi_lib_path)
317{
318 // For walking the ipmi_lib_path
319 struct dirent **handler_list;
320 int num_handlers = 0;
321
322 // This is used to check and abort if someone tries to register a bad one.
323 void *lib_handler = NULL;
324
325 if(ipmi_lib_path == NULL)
326 {
327 fprintf(stderr,"ERROR; No handlers to be registered for ipmi.. Aborting\n");
328 assert(0);
329 }
330 else
331 {
332 // 1: Open ipmi_lib_path. Its usually "/usr/lib/phosphor-host-ipmid"
333 // 2: Scan the directory for the files that end with .so
Chris Austen120f7322015-10-14 23:27:31 -0500334 // 3: For each one of them, just do a 'dlopen' so that they register
vishwabmcba0bd5f2015-09-30 16:50:23 +0530335 // the handlers for callback routines.
336
337 std::string handler_fqdn = ipmi_lib_path;
Chris Austen120f7322015-10-14 23:27:31 -0500338
vishwabmcba0bd5f2015-09-30 16:50:23 +0530339 // Append a "/" since we need to add the name of the .so. If there is
340 // already a .so, adding one more is not any harm.
341 handler_fqdn += "/";
342
343 num_handlers = scandir(ipmi_lib_path, &handler_list, handler_select, alphasort);
Jeremy Kerr5e8f85e2015-10-27 13:43:54 +0800344 if (num_handlers < 0)
345 return;
346
vishwabmcba0bd5f2015-09-30 16:50:23 +0530347 while(num_handlers--)
348 {
Chris Austen54030262015-10-13 12:30:46 -0500349 handler_fqdn = ipmi_lib_path;
vishwabmcba0bd5f2015-09-30 16:50:23 +0530350 handler_fqdn += handler_list[num_handlers]->d_name;
Chris Austen54030262015-10-13 12:30:46 -0500351 printf("Registering handler:[%s]\n",handler_fqdn.c_str());
352
vishwabmcba0bd5f2015-09-30 16:50:23 +0530353 lib_handler = dlopen(handler_fqdn.c_str(), RTLD_NOW);
354 if(lib_handler == NULL)
355 {
Chris Austen120f7322015-10-14 23:27:31 -0500356 fprintf(stderr,"ERROR opening [%s]: %s\n",
357 handler_fqdn.c_str(), dlerror());
vishwabmcba0bd5f2015-09-30 16:50:23 +0530358 }
359 // Wipe the memory allocated for this particular entry.
360 free(handler_list[num_handlers]);
361 }
362 // Done with all registration.
363 free(handler_list);
364 }
365
366 // TODO : What to be done on the memory that is given by dlopen ?.
367 return;
368}
369
370int main(int argc, char *argv[])
371{
Chris Austen0ba649e2015-10-13 12:28:13 -0500372 sd_bus_slot *slot = NULL;
373 int r;
374 char *mode = NULL;
Chris Austen99497312015-10-22 13:00:16 -0500375 unsigned long tvalue;
376 int c;
377
378
379
380 // This file and subsequient switch is for turning on levels
381 // of trace
382 ipmicmddetails = ipmiio = ipmidbus = fopen("/dev/null", "w");
383
384 while ((c = getopt (argc, argv, "h:d:")) != -1)
385 switch (c) {
386 case 'd':
387 tvalue = strtoul(optarg, NULL, 16);
388 if (1&tvalue) {
389 ipmiio = stdout;
390 }
391 if (2&tvalue) {
392 ipmidbus = stdout;
393 }
394 if (4&tvalue) {
395 ipmicmddetails = stdout;
396 }
397 break;
398 case 'h':
399 case '?':
400 print_usage();
401 return 1;
402 }
Chris Austen0ba649e2015-10-13 12:28:13 -0500403
404
vishwabmcba0bd5f2015-09-30 16:50:23 +0530405 // Register all the handlers that provider implementation to IPMI commands.
406 ipmi_register_callback_handlers(HOST_IPMI_LIB_PATH);
407
Chris Austen0ba649e2015-10-13 12:28:13 -0500408 /* Connect to system bus */
409 r = sd_bus_open_system(&bus);
410 if (r < 0) {
411 fprintf(stderr, "Failed to connect to system bus: %s\n",
412 strerror(-r));
413 goto finish;
414 }
vishwabmcba0bd5f2015-09-30 16:50:23 +0530415
Chris Austen0ba649e2015-10-13 12:28:13 -0500416 r = sd_bus_add_match(bus, &slot, FILTER, handle_ipmi_command, NULL);
417 if (r < 0) {
418 fprintf(stderr, "Failed: sd_bus_add_match: %s : %s\n", strerror(-r), FILTER);
419 goto finish;
420 }
vishwabmcba0bd5f2015-09-30 16:50:23 +0530421
vishwabmcba0bd5f2015-09-30 16:50:23 +0530422
Chris Austen0ba649e2015-10-13 12:28:13 -0500423 for (;;) {
424 /* Process requests */
425
426 r = sd_bus_process(bus, NULL);
427 if (r < 0) {
428 fprintf(stderr, "Failed to process bus: %s\n", strerror(-r));
429 goto finish;
430 }
431 if (r > 0) {
432 continue;
433 }
434
435 r = sd_bus_wait(bus, (uint64_t) - 1);
436 if (r < 0) {
437 fprintf(stderr, "Failed to wait on bus: %s\n", strerror(-r));
438 goto finish;
439 }
440 }
441
442finish:
443 sd_bus_slot_unref(slot);
444 sd_bus_unref(bus);
445 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
446
vishwabmcba0bd5f2015-09-30 16:50:23 +0530447}
Chris Austenb071c702015-10-15 00:00:09 -0500448
Chris Austen0012e9b2015-10-22 01:37:46 -0500449// Use a lookup table to find the interface name of a specific sensor
450// This will be used until an alternative is found. this is the first
451// step for mapping IPMI
452int find_interface_property_fru_type(dbus_interface_t *interface, const char *property_name, char *property_value) {
Chris Austenb071c702015-10-15 00:00:09 -0500453
Chris Austen0012e9b2015-10-22 01:37:46 -0500454 char *str1, *str2, *str3;
455 sd_bus_error error = SD_BUS_ERROR_NULL;
456 sd_bus_message *reply = NULL, *m=NULL;
Chris Austenb071c702015-10-15 00:00:09 -0500457
458
Chris Austen0012e9b2015-10-22 01:37:46 -0500459 int r;
460
Chris Austen0012e9b2015-10-22 01:37:46 -0500461 r = sd_bus_message_new_method_call(bus,&m,interface->bus,interface->path,"org.freedesktop.DBus.Properties","Get");
462 if (r < 0) {
463 fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
464 fprintf(stderr,"Bus: %s Path: %s Interface: %s \n",
465 interface->bus, interface->path, interface->interface);
466 }
467
468 r = sd_bus_message_append(m, "ss", "org.openbmc.InventoryItem", property_name);
469 if (r < 0) {
470 fprintf(stderr, "Failed to create a input parameter: %s", strerror(-r));
471 fprintf(stderr,"Bus: %s Path: %s Interface: %s \n",
472 interface->bus, interface->path, interface->interface);
473 }
474
475 r = sd_bus_call(bus, m, 0, &error, &reply);
476 if (r < 0) {
477 fprintf(stderr, "Failed to call the method: %s", strerror(-r));
478 goto final;
479 }
480
481 r = sd_bus_message_read(reply, "v", "s", &str1) ;
482 if (r < 0) {
483 fprintf(stderr, "Failed to get a response: %s", strerror(-r));
484 goto final;
485 }
486
487 strcpy(property_value, str1);
488
489final:
490
491 sd_bus_error_free(&error);
492 sd_bus_message_unref(m);
493
494 return r;
495}
Chris Austenb071c702015-10-15 00:00:09 -0500496
Chris Austen41a4b312015-10-25 03:45:42 -0500497
Chris Austenb071c702015-10-15 00:00:09 -0500498// Use a lookup table to find the interface name of a specific sensor
499// This will be used until an alternative is found. this is the first
500// step for mapping IPMI
501int find_openbmc_path(const char *type, const uint8_t num, dbus_interface_t *interface) {
502
503 const char *busname = "org.openbmc.managers.System";
504 const char *objname = "/org/openbmc/managers/System";
505
506 char *str1, *str2, *str3;
507 sd_bus_error error = SD_BUS_ERROR_NULL;
508 sd_bus_message *reply = NULL, *m=NULL;
509
510
511 int r;
512
513 r = sd_bus_message_new_method_call(bus,&m,busname,objname,busname,"getObjectFromByteId");
514 if (r < 0) {
515 fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
516 }
517
518 r = sd_bus_message_append(m, "sy", type, num);
519 if (r < 0) {
520 fprintf(stderr, "Failed to create a input parameter: %s", strerror(-r));
521 }
522
523 // Call the IPMI responder on the bus so the message can be sent to the CEC
524 r = sd_bus_call(bus, m, 0, &error, &reply);
525 if (r < 0) {
526 fprintf(stderr, "Failed to call the method: %s", strerror(-r));
527 goto final;
528 }
529
530
531 r = sd_bus_message_read(reply, "(sss)", &str1, &str2, &str3);
532 if (r < 0) {
533 fprintf(stderr, "Failed to get a response: %s", strerror(-r));
534 goto final;
535 }
536
537 strncpy(interface->bus, str1, MAX_DBUS_PATH);
538 strncpy(interface->path, str2, MAX_DBUS_PATH);
539 strncpy(interface->interface, str3, MAX_DBUS_PATH);
540
541 interface->sensornumber = num;
542
Chris Austenb071c702015-10-15 00:00:09 -0500543final:
544
545 sd_bus_error_free(&error);
546 sd_bus_message_unref(m);
547
548 return r;
549}
550
551
552/////////////////////////////////////////////////////////////////////
553//
554// Routines used by ipmi commands wanting to interact on the dbus
555//
556/////////////////////////////////////////////////////////////////////
557
558
559// Simple set routine because some methods are standard.
560int set_sensor_dbus_state(uint8_t number, const char *method, const char *value) {
561
562
563 dbus_interface_t a;
564 int r;
565 sd_bus_error error = SD_BUS_ERROR_NULL;
566 sd_bus_message *reply = NULL, *m=NULL;
567
Chris Austen99497312015-10-22 13:00:16 -0500568 fprintf(ipmidbus, "Attempting to set a dbus Sensor 0x%02x via %s with a value of %s\n",
Chris Austenb071c702015-10-15 00:00:09 -0500569 number, method, value);
570
571 r = find_openbmc_path("SENSOR", number, &a);
572
Chris Austenb071c702015-10-15 00:00:09 -0500573 r = sd_bus_message_new_method_call(bus,&m,a.bus,a.path,a.interface,method);
574 if (r < 0) {
575 fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
576 }
577
578 r = sd_bus_message_append(m, "s", value);
579 if (r < 0) {
580 fprintf(stderr, "Failed to create a input parameter: %s", strerror(-r));
581 }
582
Chris Austenb071c702015-10-15 00:00:09 -0500583 r = sd_bus_call(bus, m, 0, &error, &reply);
584 if (r < 0) {
585 fprintf(stderr, "Failed to call the method: %s", strerror(-r));
586 }
587
Chris Austenb071c702015-10-15 00:00:09 -0500588 sd_bus_error_free(&error);
589 sd_bus_message_unref(m);
590
591 return 0;
Chris Austenb071c702015-10-15 00:00:09 -0500592}
Chris Austen0130d6e2015-10-15 22:32:36 -0500593
594int set_sensor_dbus_state_v(uint8_t number, const char *method, char *value) {
595
596
597 dbus_interface_t a;
598 int r;
599 sd_bus_error error = SD_BUS_ERROR_NULL;
600 sd_bus_message *reply = NULL, *m=NULL;
601
Chris Austen99497312015-10-22 13:00:16 -0500602 fprintf(ipmidbus, "Attempting to set a dbus Variant Sensor 0x%02x via %s with a value of %s\n",
Chris Austen0130d6e2015-10-15 22:32:36 -0500603 number, method, value);
604
605 r = find_openbmc_path("SENSOR", number, &a);
606
Chris Austen0130d6e2015-10-15 22:32:36 -0500607 r = sd_bus_message_new_method_call(bus,&m,a.bus,a.path,a.interface,method);
608 if (r < 0) {
609 fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
610 }
611
612 r = sd_bus_message_append(m, "v", "s", value);
613 if (r < 0) {
614 fprintf(stderr, "Failed to create a input parameter: %s", strerror(-r));
615 }
616
617
Chris Austen0130d6e2015-10-15 22:32:36 -0500618 r = sd_bus_call(bus, m, 0, &error, NULL);
619 if (r < 0) {
620 fprintf(stderr, "12 Failed to call the method: %s", strerror(-r));
621 }
622
623
Chris Austen0130d6e2015-10-15 22:32:36 -0500624 sd_bus_error_free(&error);
625 sd_bus_message_unref(m);
626
627 return 0;
628}