1 /*
2 * cmd_domain.c
3 *
4 * A command interpreter for OpenIPMI
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2004 MontaVista Software Inc.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public License
14 * as published by the Free Software Foundation; either version 2 of
15 * the License, or (at your option) any later version.
16 *
17 *
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * You should have received a copy of the GNU Lesser General Public
30 * License along with this program; if not, write to the Free
31 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 */
33
34 #include <errno.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <OpenIPMI/ipmiif.h>
40 #include <OpenIPMI/ipmi_cmdlang.h>
41 #include <OpenIPMI/ipmi_mc.h>
42 #include <OpenIPMI/ipmi_sdr.h>
43 #include <OpenIPMI/ipmi_err.h>
44 #include <OpenIPMI/ipmi_msgbits.h>
45 #include <OpenIPMI/ipmi_auth.h>
46 #include <OpenIPMI/ipmi_user.h>
47
48 /* Internal includes, do not use in your programs */
49 #include <OpenIPMI/internal/ipmi_malloc.h>
50
51 static void
mc_list_handler(ipmi_domain_t * domain,ipmi_mc_t * mc,void * cb_data)52 mc_list_handler(ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
53 {
54 ipmi_cmd_info_t *cmd_info = cb_data;
55 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
56 char mc_name[IPMI_MC_NAME_LEN];
57
58 if (cmdlang->err)
59 return;
60
61 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
62
63 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
64 }
65
66 static void
mc_list(ipmi_domain_t * domain,void * cb_data)67 mc_list(ipmi_domain_t *domain, void *cb_data)
68 {
69 ipmi_cmd_info_t *cmd_info = cb_data;
70 char domain_name[IPMI_DOMAIN_NAME_LEN];
71
72 ipmi_domain_get_name(domain, domain_name, sizeof(domain_name));
73 ipmi_cmdlang_out(cmd_info, "Domain", NULL);
74 ipmi_cmdlang_down(cmd_info);
75 ipmi_cmdlang_out(cmd_info, "Name", domain_name);
76 ipmi_cmdlang_out(cmd_info, "MCs", NULL);
77 ipmi_cmdlang_down(cmd_info);
78 ipmi_domain_iterate_mcs(domain, mc_list_handler, cmd_info);
79 ipmi_cmdlang_up(cmd_info);
80 ipmi_cmdlang_up(cmd_info);
81 }
82
83 static void
mc_dump(ipmi_mc_t * mc,ipmi_cmd_info_t * cmd_info)84 mc_dump(ipmi_mc_t *mc, ipmi_cmd_info_t *cmd_info)
85 {
86 unsigned char vals[4];
87 char str[100];
88 unsigned char guid[16];
89
90 ipmi_cmdlang_out_bool(cmd_info, "Active", ipmi_mc_is_active(mc));
91 if (ipmi_mc_get_guid(mc, guid) == 0)
92 ipmi_cmdlang_out_binary(cmd_info, "GUID", (char *) guid, 16);
93 ipmi_cmdlang_out_int(cmd_info, "SEL Rescan Time",
94 ipmi_mc_get_sel_rescan_time(mc));
95 ipmi_cmdlang_out_bool(cmd_info, "provides_device_sdrs",
96 ipmi_mc_provides_device_sdrs(mc));
97 ipmi_cmdlang_out_bool(cmd_info, "device_available",
98 ipmi_mc_device_available(mc));
99 ipmi_cmdlang_out_bool(cmd_info, "chassis_support",
100 ipmi_mc_chassis_support(mc));
101 ipmi_cmdlang_out_bool(cmd_info, "bridge_support",
102 ipmi_mc_bridge_support(mc));
103 ipmi_cmdlang_out_bool(cmd_info, "ipmb_event_generator",
104 ipmi_mc_ipmb_event_generator_support(mc));
105 ipmi_cmdlang_out_bool(cmd_info, "ipmb_event_receiver",
106 ipmi_mc_ipmb_event_receiver_support(mc));
107 ipmi_cmdlang_out_bool(cmd_info, "fru_inventory_support",
108 ipmi_mc_fru_inventory_support(mc));
109 ipmi_cmdlang_out_bool(cmd_info, "sel_device_support",
110 ipmi_mc_sel_device_support(mc));
111 ipmi_cmdlang_out_bool(cmd_info, "sdr_repository_support",
112 ipmi_mc_sdr_repository_support(mc));
113 ipmi_cmdlang_out_bool(cmd_info, "sensor_device_support",
114 ipmi_mc_sensor_device_support(mc));
115 ipmi_cmdlang_out_hex(cmd_info, "device_id", ipmi_mc_device_id(mc));
116 ipmi_cmdlang_out_int(cmd_info, "device_revision",
117 ipmi_mc_device_revision(mc));
118 snprintf(str, sizeof(str), "%d.%d%d",
119 ipmi_mc_major_fw_revision(mc),
120 ipmi_mc_minor_fw_revision(mc)>>4,
121 ipmi_mc_minor_fw_revision(mc)&0xf);
122 ipmi_cmdlang_out(cmd_info, "fw_revision", str);
123 snprintf(str, sizeof(str), "%d.%d",
124 ipmi_mc_major_version(mc),
125 ipmi_mc_minor_version(mc));
126 ipmi_cmdlang_out(cmd_info, "version", str);
127 ipmi_cmdlang_out_hex(cmd_info, "manufacturer_id",
128 ipmi_mc_manufacturer_id(mc));
129 ipmi_cmdlang_out_hex(cmd_info, "product_id", ipmi_mc_product_id(mc));
130 ipmi_mc_aux_fw_revision(mc, vals);
131 ipmi_cmdlang_out_binary(cmd_info, "aux_fw_revision",
132 (char *) vals, sizeof(vals));
133 }
134
135 static void
mc_info(ipmi_mc_t * mc,void * cb_data)136 mc_info(ipmi_mc_t *mc, void *cb_data)
137 {
138 ipmi_cmd_info_t *cmd_info = cb_data;
139 char mc_name[IPMI_MC_NAME_LEN];
140
141 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
142 ipmi_cmdlang_out(cmd_info, "MC", NULL);
143 ipmi_cmdlang_down(cmd_info);
144 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
145 mc_dump(mc, cmd_info);
146 ipmi_cmdlang_up(cmd_info);
147 }
148
149 static void
mc_reset_done(ipmi_mc_t * mc,int err,void * cb_data)150 mc_reset_done(ipmi_mc_t *mc, int err, void *cb_data)
151 {
152 ipmi_cmd_info_t *cmd_info = cb_data;
153 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
154 char mc_name[IPMI_MC_NAME_LEN];
155
156 ipmi_cmdlang_lock(cmd_info);
157 if (err) {
158 cmdlang->errstr = "Error resetting MC";
159 cmdlang->err = err;
160 ipmi_mc_get_name(mc, cmdlang->objstr,
161 cmdlang->objstr_len);
162 cmdlang->location = "cmd_mc.c(mc_reset_done)";
163 goto out;
164 }
165
166 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
167 ipmi_cmdlang_out(cmd_info, "Reset done", mc_name);
168
169 out:
170 ipmi_cmdlang_unlock(cmd_info);
171 ipmi_cmdlang_cmd_info_put(cmd_info);
172 }
173
174 static void
mc_reset(ipmi_mc_t * mc,void * cb_data)175 mc_reset(ipmi_mc_t *mc, void *cb_data)
176 {
177 ipmi_cmd_info_t *cmd_info = cb_data;
178 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
179 int cmd;
180 int rv;
181 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
182 int argc = ipmi_cmdlang_get_argc(cmd_info);
183 char **argv = ipmi_cmdlang_get_argv(cmd_info);
184
185 if ((argc - curr_arg) < 1) {
186 /* Not enough parameters */
187 cmdlang->errstr = "Not enough parameters";
188 cmdlang->err = EINVAL;
189 goto out_err;
190 }
191
192 if (strcasecmp(argv[curr_arg], "warm") == 0)
193 cmd = IPMI_MC_RESET_WARM;
194 else if (strcasecmp(argv[curr_arg], "cold") == 0)
195 cmd = IPMI_MC_RESET_COLD;
196 else {
197 cmdlang->errstr = "reset type not 'warm' or 'cold'";
198 cmdlang->err = EINVAL;
199 goto out_err;
200 }
201
202 ipmi_cmdlang_cmd_info_get(cmd_info);
203 rv = ipmi_mc_reset(mc, cmd, mc_reset_done, cmd_info);
204 if (rv) {
205 ipmi_cmdlang_cmd_info_put(cmd_info);
206 cmdlang->errstr = "Error from ipmi_mc_reset";
207 cmdlang->err = EINVAL;
208 goto out_err;
209 }
210
211 out_err:
212 if (cmdlang->err) {
213 ipmi_mc_get_name(mc, cmdlang->objstr,
214 cmdlang->objstr_len);
215 cmdlang->location = "cmd_mc.c(mc_reset)";
216 }
217 }
218
219 static void
set_events_enable_done(ipmi_mc_t * mc,int err,void * cb_data)220 set_events_enable_done(ipmi_mc_t *mc, int err, void *cb_data)
221 {
222 ipmi_cmd_info_t *cmd_info = cb_data;
223 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
224 char mc_name[IPMI_MC_NAME_LEN];
225
226 ipmi_cmdlang_lock(cmd_info);
227 if (err) {
228 cmdlang->errstr = "Error setting events enable";
229 cmdlang->err = err;
230 ipmi_mc_get_name(mc, cmdlang->objstr,
231 cmdlang->objstr_len);
232 cmdlang->location = "cmd_mc.c(set_events_enable_done)";
233 goto out;
234 }
235
236 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
237 ipmi_cmdlang_out(cmd_info, "Events enable done", mc_name);
238
239 out:
240 ipmi_cmdlang_unlock(cmd_info);
241 ipmi_cmdlang_cmd_info_put(cmd_info);
242 }
243
244 static void
mc_set_events_enable(ipmi_mc_t * mc,void * cb_data)245 mc_set_events_enable(ipmi_mc_t *mc, void *cb_data)
246 {
247 ipmi_cmd_info_t *cmd_info = cb_data;
248 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
249 int enable;
250 int rv;
251 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
252 int argc = ipmi_cmdlang_get_argc(cmd_info);
253 char **argv = ipmi_cmdlang_get_argv(cmd_info);
254
255 if ((argc - curr_arg) < 1) {
256 /* Not enough parameters */
257 cmdlang->errstr = "Not enough parameters";
258 cmdlang->err = EINVAL;
259 goto out_err;
260 }
261
262 if (strcasecmp(argv[curr_arg], "enable") == 0)
263 enable = 1;
264 else if (strcasecmp(argv[curr_arg], "disable") == 0)
265 enable = 0;
266 else {
267 cmdlang->errstr = "enable type not 'enable' or 'disable'";
268 cmdlang->err = EINVAL;
269 goto out_err;
270 }
271
272 ipmi_cmdlang_cmd_info_get(cmd_info);
273 rv = ipmi_mc_set_events_enable(mc, enable, set_events_enable_done,
274 cmd_info);
275 if (rv) {
276 ipmi_cmdlang_cmd_info_put(cmd_info);
277 cmdlang->errstr = "Error from ipmi_mc_set_events_enable";
278 cmdlang->err = EINVAL;
279 goto out_err;
280 }
281
282 out_err:
283 if (cmdlang->err) {
284 ipmi_mc_get_name(mc, cmdlang->objstr,
285 cmdlang->objstr_len);
286 cmdlang->location = "cmd_mc.c(mc_set_events_enable)";
287 }
288 }
289
290 static void
mc_get_events_enable(ipmi_mc_t * mc,void * cb_data)291 mc_get_events_enable(ipmi_mc_t *mc, void *cb_data)
292 {
293 ipmi_cmd_info_t *cmd_info = cb_data;
294
295 ipmi_cmdlang_out_bool(cmd_info, "Events Enable",
296 ipmi_mc_get_events_enable(mc));
297 }
298
299 static void
mc_sel_info(ipmi_mc_t * mc,void * cb_data)300 mc_sel_info(ipmi_mc_t *mc, void *cb_data)
301 {
302 ipmi_cmd_info_t *cmd_info = cb_data;
303 char str[20];
304 char mc_name[IPMI_MC_NAME_LEN];
305
306 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
307 ipmi_cmdlang_out(cmd_info, "MC", NULL);
308 ipmi_cmdlang_down(cmd_info);
309 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
310 snprintf(str, sizeof(str), "%d.%d",
311 ipmi_mc_sel_get_major_version(mc),
312 ipmi_mc_sel_get_num_entries(mc));
313 ipmi_cmdlang_out(cmd_info, "SEL Version", str);
314 ipmi_cmdlang_out_int(cmd_info, "SEL Count", ipmi_mc_sel_count(mc));
315 ipmi_cmdlang_out_int(cmd_info, "SEL Slots Used",
316 ipmi_mc_sel_entries_used(mc));
317 ipmi_cmdlang_out_int(cmd_info, "SEL Free Bytes",
318 ipmi_mc_sel_get_free_bytes(mc));
319 ipmi_cmdlang_out_int(cmd_info, "SEL Last Addition Timestamp",
320 ipmi_mc_sel_get_last_addition_timestamp(mc));
321 ipmi_cmdlang_out_bool(cmd_info, "SEL overflow",
322 ipmi_mc_sel_get_overflow(mc));
323 ipmi_cmdlang_out_bool(cmd_info, "SEL Supports Delete",
324 ipmi_mc_sel_get_supports_delete_sel(mc));
325 ipmi_cmdlang_out_bool(cmd_info, "SEL Supports Partial Add",
326 ipmi_mc_sel_get_supports_partial_add_sel(mc));
327 ipmi_cmdlang_out_bool(cmd_info, "SEL Supports Reserve",
328 ipmi_mc_sel_get_supports_reserve_sel(mc));
329 ipmi_cmdlang_out_bool(cmd_info, "SEL Supports Get SEL Allocation",
330 ipmi_mc_sel_get_supports_get_sel_allocation(mc));
331 ipmi_cmdlang_up(cmd_info);
332 }
333
334 static void
get_sel_time_handler(ipmi_mc_t * mc,int err,unsigned long time,void * cb_data)335 get_sel_time_handler(ipmi_mc_t *mc, int err, unsigned long time, void *cb_data)
336 {
337 ipmi_cmd_info_t *cmd_info = cb_data;
338 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
339 char mc_name[IPMI_MC_NAME_LEN];
340
341 ipmi_cmdlang_lock(cmd_info);
342 if (err) {
343 cmdlang->errstr = "Error getting SEL time";
344 cmdlang->err = err;
345 ipmi_mc_get_name(mc, cmdlang->objstr,
346 cmdlang->objstr_len);
347 cmdlang->location = "cmd_mc.c(get_sel_time_handler)";
348 } else {
349 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
350 ipmi_cmdlang_out(cmd_info, "MC", NULL);
351 ipmi_cmdlang_down(cmd_info);
352 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
353 ipmi_cmdlang_out_long(cmd_info, "SEL Time", time);
354 ipmi_cmdlang_up(cmd_info);
355 }
356 ipmi_cmdlang_unlock(cmd_info);
357 ipmi_cmdlang_cmd_info_put(cmd_info);
358 }
359
360 static void
mc_get_sel_time(ipmi_mc_t * mc,void * cb_data)361 mc_get_sel_time(ipmi_mc_t *mc, void *cb_data)
362 {
363 ipmi_cmd_info_t *cmd_info = cb_data;
364 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
365 int rv;
366
367 ipmi_cmdlang_cmd_info_get(cmd_info);
368 rv = ipmi_mc_get_current_sel_time(mc, get_sel_time_handler, cmd_info);
369 if (rv) {
370 ipmi_cmdlang_cmd_info_put(cmd_info);
371 cmdlang->errstr = "Error from ipmi_mc_get_current_sel_time";
372 cmdlang->err = EINVAL;
373 ipmi_mc_get_name(mc, cmdlang->objstr,
374 cmdlang->objstr_len);
375 cmdlang->location = "cmd_mc.c(mc_get_sel_time)";
376 }
377 }
378
379 static void
set_sel_time_handler(ipmi_mc_t * mc,int err,void * cb_data)380 set_sel_time_handler(ipmi_mc_t *mc, int err, void *cb_data)
381 {
382 ipmi_cmd_info_t *cmd_info = cb_data;
383 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
384 char mc_name[IPMI_MC_NAME_LEN];
385
386 ipmi_cmdlang_lock(cmd_info);
387 if (err) {
388 cmdlang->errstr = "Error Setting SEL time";
389 cmdlang->err = err;
390 ipmi_mc_get_name(mc, cmdlang->objstr,
391 cmdlang->objstr_len);
392 cmdlang->location = "cmd_mc.c(get_sel_time_handler)";
393 } else {
394 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
395 ipmi_cmdlang_out(cmd_info, "MC SEL time set", NULL);
396 ipmi_cmdlang_down(cmd_info);
397 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
398 ipmi_cmdlang_up(cmd_info);
399 }
400 ipmi_cmdlang_unlock(cmd_info);
401 ipmi_cmdlang_cmd_info_put(cmd_info);
402 }
403
404 static void
mc_set_sel_time(ipmi_mc_t * mc,void * cb_data)405 mc_set_sel_time(ipmi_mc_t *mc, void *cb_data)
406 {
407 ipmi_cmd_info_t *cmd_info = cb_data;
408 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
409 int rv;
410 int time;
411 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
412 int argc = ipmi_cmdlang_get_argc(cmd_info);
413 char **argv = ipmi_cmdlang_get_argv(cmd_info);
414 struct timeval tv;
415
416 if ((argc - curr_arg) < 1) {
417 /* Not enough parameters */
418 cmdlang->errstr = "Not enough parameters";
419 cmdlang->err = EINVAL;
420 goto out_err;
421 }
422
423 ipmi_cmdlang_get_int(argv[curr_arg], &time, cmd_info);
424 if (cmdlang->err) {
425 cmdlang->errstr = "time invalid";
426 goto out_err;
427 }
428 curr_arg++;
429
430 tv.tv_sec = time;
431 tv.tv_usec = 0;
432
433 ipmi_cmdlang_cmd_info_get(cmd_info);
434 rv = ipmi_mc_set_current_sel_time(mc, &tv, set_sel_time_handler, cmd_info);
435 if (rv) {
436 ipmi_cmdlang_cmd_info_put(cmd_info);
437 cmdlang->errstr = "Error from ipmi_mc_get_current_sel_time";
438 cmdlang->err = EINVAL;
439 ipmi_mc_get_name(mc, cmdlang->objstr,
440 cmdlang->objstr_len);
441 cmdlang->location = "cmd_mc.c(mc_get_sel_time)";
442 }
443
444 out_err:
445 if (cmdlang->err) {
446 ipmi_mc_get_name(mc, cmdlang->objstr,
447 cmdlang->objstr_len);
448 cmdlang->location = "cmd_mc.c(mc_set_sel_time)";
449 }
450 }
451
452 static void
mc_rescan_sel_done(ipmi_mc_t * mc,int err,void * cb_data)453 mc_rescan_sel_done(ipmi_mc_t *mc, int err, void *cb_data)
454 {
455 ipmi_cmd_info_t *cmd_info = cb_data;
456 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
457 char mc_name[IPMI_MC_NAME_LEN];
458
459 ipmi_cmdlang_lock(cmd_info);
460 if (err) {
461 if (! cmdlang->err) {
462 cmdlang->err = err;
463 cmdlang->errstr = "Error scanning SELs";
464 ipmi_mc_get_name(mc, cmdlang->objstr,
465 cmdlang->objstr_len);
466 cmdlang->location = "cmd_mc.c(sel_rescan_done)";
467 }
468 goto out;
469 }
470
471 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
472 ipmi_cmdlang_out(cmd_info, "SEL Rescan done", mc_name);
473
474 out:
475 ipmi_cmdlang_unlock(cmd_info);
476 ipmi_cmdlang_cmd_info_put(cmd_info);
477 }
478
479 static void
mc_rescan_sels(ipmi_mc_t * mc,void * cb_data)480 mc_rescan_sels(ipmi_mc_t *mc, void *cb_data)
481 {
482 ipmi_cmd_info_t *cmd_info = cb_data;
483 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
484 int rv;
485
486 ipmi_cmdlang_cmd_info_get(cmd_info);
487 rv = ipmi_mc_reread_sel(mc, mc_rescan_sel_done, cmd_info);
488 if (rv) {
489 ipmi_cmdlang_cmd_info_put(cmd_info);
490 cmdlang->errstr = "Error requesting SEL rescan";
491 cmdlang->err = rv;
492 goto out_err;
493 }
494
495 out_err:
496 if (cmdlang->err) {
497 ipmi_mc_get_name(mc, cmdlang->objstr,
498 cmdlang->objstr_len);
499 cmdlang->location = "cmd_mc.c(mc_rescan_sels)";
500 }
501 }
502
503 static void
mc_sel_rescan_time(ipmi_mc_t * mc,void * cb_data)504 mc_sel_rescan_time(ipmi_mc_t *mc, void *cb_data)
505 {
506 ipmi_cmd_info_t *cmd_info = cb_data;
507 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
508 int time;
509 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
510 int argc = ipmi_cmdlang_get_argc(cmd_info);
511 char **argv = ipmi_cmdlang_get_argv(cmd_info);
512 char mc_name[IPMI_MC_NAME_LEN];
513
514 if ((argc - curr_arg) < 1) {
515 /* Not enough parameters */
516 cmdlang->errstr = "Not enough parameters";
517 cmdlang->err = EINVAL;
518 goto out_err;
519 }
520
521 ipmi_cmdlang_get_int(argv[curr_arg], &time, cmd_info);
522 if (cmdlang->err) {
523 cmdlang->errstr = "time invalid";
524 goto out_err;
525 }
526 curr_arg++;
527
528 ipmi_mc_set_sel_rescan_time(mc, time);
529
530 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
531 ipmi_cmdlang_out(cmd_info, "MC SEL rescan time set", mc_name);
532
533 out_err:
534 if (cmdlang->err) {
535 ipmi_mc_get_name(mc, cmdlang->objstr,
536 cmdlang->objstr_len);
537 cmdlang->location = "cmd_mc.c(mc_sel_rescan_time)";
538 }
539 }
540
541
542 static void
mc_msg_handler(ipmi_mc_t * mc,ipmi_msg_t * msg,void * cb_data)543 mc_msg_handler(ipmi_mc_t *mc, ipmi_msg_t *msg, void *cb_data)
544 {
545 ipmi_cmd_info_t *cmd_info = cb_data;
546 char mc_name[IPMI_MC_NAME_LEN];
547
548 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
549
550 ipmi_cmdlang_lock(cmd_info);
551 ipmi_cmdlang_out(cmd_info, "Response", NULL);
552 ipmi_cmdlang_down(cmd_info);
553 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
554 ipmi_cmdlang_out_int(cmd_info, "NetFN", msg->netfn);
555 ipmi_cmdlang_out_int(cmd_info, "command", msg->cmd);
556 if (msg->data_len)
557 ipmi_cmdlang_out_binary(cmd_info, "Data",
558 (char *) msg->data, msg->data_len);
559 ipmi_cmdlang_up(cmd_info);
560 ipmi_cmdlang_unlock(cmd_info);
561
562 ipmi_cmdlang_cmd_info_put(cmd_info);
563 }
564
565 static void
mc_msg(ipmi_mc_t * mc,void * cb_data)566 mc_msg(ipmi_mc_t *mc, void *cb_data)
567 {
568 ipmi_cmd_info_t *cmd_info = cb_data;
569 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
570 int LUN;
571 int NetFN;
572 int command;
573 unsigned char data[100];
574 int rv;
575 int i;
576 ipmi_msg_t msg;
577 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
578 int argc = ipmi_cmdlang_get_argc(cmd_info);
579 char **argv = ipmi_cmdlang_get_argv(cmd_info);
580
581
582 if ((argc - curr_arg) < 3) {
583 cmdlang->errstr = "Not enough parameters";
584 cmdlang->err = EINVAL;
585 goto out_err;
586 }
587
588 ipmi_cmdlang_get_int(argv[curr_arg],
589 &LUN, cmd_info);
590 if (cmdlang->err) {
591 cmdlang->errstr = "LUN invalid";
592 goto out_err;
593 }
594 curr_arg++;
595
596 ipmi_cmdlang_get_int(argv[curr_arg],
597 &NetFN, cmd_info);
598 if (cmdlang->err) {
599 cmdlang->errstr = "NetFN invalid";
600 goto out_err;
601 }
602 curr_arg++;
603
604 ipmi_cmdlang_get_int(argv[curr_arg],
605 &command, cmd_info);
606 if (cmdlang->err) {
607 cmdlang->errstr = "command invalid";
608 goto out_err;
609 }
610 curr_arg++;
611
612 i = 0;
613 while (curr_arg < argc) {
614 ipmi_cmdlang_get_uchar(argv[curr_arg],
615 &data[i], cmd_info);
616 if (cmdlang->err) {
617 cmdlang->errstr = "data invalid";
618 goto out_err;
619 }
620 curr_arg++;
621 i++;
622 }
623
624 msg.netfn = NetFN;
625 msg.cmd = command;
626 msg.data_len = i;
627 msg.data = data;
628
629 ipmi_cmdlang_cmd_info_get(cmd_info);
630 rv = ipmi_mc_send_command(mc,
631 LUN,
632 &msg,
633 mc_msg_handler,
634 cmd_info);
635 if (rv) {
636 ipmi_cmdlang_cmd_info_put(cmd_info);
637 cmdlang->errstr = "Error sending message";
638 cmdlang->err = rv;
639 goto out_err;
640 }
641
642 return;
643
644 out_err:
645 if (cmdlang->err) {
646 ipmi_mc_get_name(mc, cmdlang->objstr,
647 cmdlang->objstr_len);
648 cmdlang->location = "cmd_mc.c(mc_msg)";
649 }
650 }
651
652 typedef struct sdr_info_s
653 {
654 ipmi_cmd_info_t *cmd_info;
655 char mc_name[IPMI_MC_NAME_LEN];
656 } sdr_info_t;
657
658 void
sdrs_fetched(ipmi_sdr_info_t * sdrs,int err,int changed,unsigned int count,void * cb_data)659 sdrs_fetched(ipmi_sdr_info_t *sdrs,
660 int err,
661 int changed,
662 unsigned int count,
663 void *cb_data)
664 {
665 sdr_info_t *info = cb_data;
666 ipmi_cmd_info_t *cmd_info = info->cmd_info;
667 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
668 unsigned int i;
669 int rv;
670 int total_size = 0;
671
672 if (err) {
673 cmdlang->err = err;
674 cmdlang->errstr = "Error fetching SDRs";
675 goto out_err;
676 }
677
678 if (!sdrs) {
679 cmdlang->err = ECANCELED;
680 cmdlang->errstr = "MC went away during SDR fetch";
681 goto out_err;
682 }
683
684 ipmi_cmdlang_out(cmd_info, "MC", NULL);
685 ipmi_cmdlang_down(cmd_info);
686 ipmi_cmdlang_out(cmd_info, "Name", info->mc_name);
687 for (i=0; i<count; i++) {
688 ipmi_sdr_t sdr;
689 char str[20];
690
691 rv = ipmi_get_sdr_by_index(sdrs, i, &sdr);
692 if (rv)
693 continue;
694
695 ipmi_cmdlang_out(cmd_info, "SDR", NULL);
696 ipmi_cmdlang_down(cmd_info);
697 ipmi_cmdlang_out_int(cmd_info, "Record ID", sdr.record_id);
698 ipmi_cmdlang_out_int(cmd_info, "Type", sdr.type);
699 snprintf(str, sizeof(str), "%d.%d", sdr.major_version,
700 sdr.minor_version);
701 ipmi_cmdlang_out(cmd_info, "Version", str);
702 ipmi_cmdlang_out_binary(cmd_info, "Data",
703 (char *) sdr.data, sdr.length);
704 ipmi_cmdlang_up(cmd_info);
705 total_size += sdr.length+5;
706 }
707 ipmi_cmdlang_out_int(cmd_info, "Total Size", total_size);
708 ipmi_cmdlang_up(cmd_info);
709
710 out_err:
711 if (cmdlang->err) {
712 cmdlang->location = "cmd_mc.c(sdrs_fetched)";
713 }
714 ipmi_cmdlang_cmd_info_put(cmd_info);
715 ipmi_sdr_info_destroy(sdrs, NULL, NULL);
716 ipmi_mem_free(info);
717 }
718
719 static void
mc_sdrs(ipmi_mc_t * mc,void * cb_data)720 mc_sdrs(ipmi_mc_t *mc, void *cb_data)
721 {
722 sdr_info_t *info = NULL;
723 ipmi_cmd_info_t *cmd_info = cb_data;
724 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
725 int do_sensor;
726 ipmi_sdr_info_t *sdrs;
727 int rv;
728 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
729 int argc = ipmi_cmdlang_get_argc(cmd_info);
730 char **argv = ipmi_cmdlang_get_argv(cmd_info);
731
732
733 if ((argc - curr_arg) < 1) {
734 /* Not enough parameters */
735 cmdlang->errstr = "Not enough parameters";
736 cmdlang->err = EINVAL;
737 goto out_err;
738 }
739
740 if (strcmp(argv[curr_arg], "main") == 0) {
741 do_sensor = 0;
742 } else if (strcmp(argv[curr_arg], "sensor") == 0) {
743 do_sensor = 1;
744 } else {
745 cmdlang->err = EINVAL;
746 cmdlang->errstr = "Fetch type was not sensor or main";
747 goto out_err;
748 }
749 curr_arg++;
750
751 rv = ipmi_sdr_info_alloc(ipmi_mc_get_domain(mc),
752 mc, 0, do_sensor, &sdrs);
753 if (rv) {
754 cmdlang->err = rv;
755 cmdlang->errstr = "Could not allocate SDR info";
756 goto out_err;
757 }
758
759 info = ipmi_mem_alloc(sizeof(*info));
760 if (!info) {
761 cmdlang->err = ENOMEM;
762 cmdlang->errstr = "Could not allocate SDR data";
763 goto out_err;
764 }
765 info->cmd_info = cmd_info;
766 ipmi_mc_get_name(mc, info->mc_name, sizeof(info->mc_name));
767
768 ipmi_cmdlang_cmd_info_get(cmd_info);
769 rv = ipmi_sdr_fetch(sdrs, sdrs_fetched, info);
770 if (rv) {
771 ipmi_cmdlang_cmd_info_put(cmd_info);
772 cmdlang->err = rv;
773 cmdlang->errstr = "Could not start SDR fetch";
774 ipmi_sdr_info_destroy(sdrs, NULL, NULL);
775 goto out_err;
776 }
777
778 return;
779
780 out_err:
781 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
782 cmdlang->location = "cmd_mc.c(mc_sdrs)";
783 if (info)
784 ipmi_mem_free(info);
785 }
786
787 typedef struct event_log_s
788 {
789 ipmi_cmd_info_t *cmd_info;
790 } event_log_t;
791
792 static void
mc_got_event_log_enable(ipmi_mc_t * mc,int err,int val,void * cb_data)793 mc_got_event_log_enable(ipmi_mc_t *mc, int err, int val, void *cb_data)
794 {
795 event_log_t *info = cb_data;
796 ipmi_cmd_info_t *cmd_info = info->cmd_info;
797 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
798 char mc_name[IPMI_MC_NAME_LEN];
799
800 if (err) {
801 cmdlang->err = err;
802 cmdlang->errstr = "Error getting event log enable";
803 goto out_err;
804 }
805
806 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
807 ipmi_cmdlang_out(cmd_info, "MC", NULL);
808 ipmi_cmdlang_down(cmd_info);
809 ipmi_cmdlang_out(cmd_info, "Name", mc_name);
810 ipmi_cmdlang_out_bool(cmd_info, "Event Log Enabled", val);
811 ipmi_cmdlang_up(cmd_info);
812
813 out_err:
814 if (cmdlang->err) {
815 cmdlang->location = "cmd_mc.c(mc_got_event_log_enable)";
816 }
817 ipmi_cmdlang_cmd_info_put(cmd_info);
818 ipmi_mem_free(info);
819 }
820
821 static void
mc_get_event_log_enable(ipmi_mc_t * mc,void * cb_data)822 mc_get_event_log_enable(ipmi_mc_t *mc, void *cb_data)
823 {
824 event_log_t *info;
825 ipmi_cmd_info_t *cmd_info = cb_data;
826 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
827 int rv;
828
829
830 info = ipmi_mem_alloc(sizeof(*info));
831 if (!info) {
832 cmdlang->err = ENOMEM;
833 cmdlang->errstr = "Could not allocate SDR data";
834 goto out_err;
835 }
836 info->cmd_info = cmd_info;
837
838 ipmi_cmdlang_cmd_info_get(cmd_info);
839 rv = ipmi_mc_get_event_log_enable(mc, mc_got_event_log_enable, info);
840 if (rv) {
841 ipmi_cmdlang_cmd_info_put(cmd_info);
842 cmdlang->err = rv;
843 cmdlang->errstr = "Could not start event log enable fetch";
844 goto out_err;
845 }
846
847 return;
848
849 out_err:
850 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
851 cmdlang->location = "cmd_mc.c(mc_get_event_log_enable)";
852 if (info)
853 ipmi_mem_free(info);
854 }
855
856 static void
mc_event_log_enable_set(ipmi_mc_t * mc,int err,void * cb_data)857 mc_event_log_enable_set(ipmi_mc_t *mc, int err, void *cb_data)
858 {
859 event_log_t *info = cb_data;
860 ipmi_cmd_info_t *cmd_info = info->cmd_info;
861 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
862 char mc_name[IPMI_MC_NAME_LEN];
863
864 if (err) {
865 cmdlang->err = err;
866 cmdlang->errstr = "Error setting event log enable";
867 goto out_err;
868 }
869
870 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
871 ipmi_cmdlang_out(cmd_info, "Event Log Enable Set", NULL);
872 ipmi_cmdlang_down(cmd_info);
873 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
874 ipmi_cmdlang_up(cmd_info);
875
876 out_err:
877 if (cmdlang->err) {
878 cmdlang->location = "cmd_mc.c(mc_event_log_enable_set)";
879 }
880 ipmi_cmdlang_cmd_info_put(cmd_info);
881 ipmi_mem_free(info);
882 }
883
884 static void
mc_set_event_log_enable(ipmi_mc_t * mc,void * cb_data)885 mc_set_event_log_enable(ipmi_mc_t *mc, void *cb_data)
886 {
887 event_log_t *info = NULL;
888 ipmi_cmd_info_t *cmd_info = cb_data;
889 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
890 int val;
891 int rv;
892 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
893 int argc = ipmi_cmdlang_get_argc(cmd_info);
894 char **argv = ipmi_cmdlang_get_argv(cmd_info);
895
896
897 info = ipmi_mem_alloc(sizeof(*info));
898 if (!info) {
899 cmdlang->err = ENOMEM;
900 cmdlang->errstr = "Could not allocate SDR data";
901 goto out_err;
902 }
903 info->cmd_info = cmd_info;
904
905 if ((argc - curr_arg) < 1) {
906 /* Not enough parameters */
907 cmdlang->errstr = "Not enough parameters";
908 cmdlang->err = EINVAL;
909 goto out_err;
910 }
911
912 ipmi_cmdlang_get_bool(argv[curr_arg], &val, cmd_info);
913 if (cmdlang->err) {
914 cmdlang->errstr = "invalid enable setting";
915 goto out_err;
916 }
917
918 ipmi_cmdlang_cmd_info_get(cmd_info);
919 rv = ipmi_mc_set_event_log_enable(mc, val, mc_event_log_enable_set, info);
920 if (rv) {
921 ipmi_cmdlang_cmd_info_put(cmd_info);
922 cmdlang->err = rv;
923 cmdlang->errstr = "Could not start event log enable set";
924 goto out_err;
925 }
926
927 return;
928
929 out_err:
930 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
931 cmdlang->location = "cmd_mc.c(mc_get_event_log_enable)";
932 if (info)
933 ipmi_mem_free(info);
934
935 }
936
937 static void
dump_chan_info(ipmi_mc_t * mc,ipmi_channel_info_t * info,ipmi_cmd_info_t * cmd_info)938 dump_chan_info(ipmi_mc_t *mc,
939 ipmi_channel_info_t *info,
940 ipmi_cmd_info_t *cmd_info)
941 {
942 char mc_name[IPMI_MC_NAME_LEN];
943 char *str;
944 unsigned int val;
945 int rv;
946 unsigned char data[3];
947
948 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
949
950 ipmi_cmdlang_lock(cmd_info);
951 ipmi_cmdlang_out(cmd_info, "Channel Info", NULL);
952 ipmi_cmdlang_down(cmd_info);
953 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
954 rv = ipmi_channel_info_get_channel(info, &val);
955 if (!rv)
956 ipmi_cmdlang_out_int(cmd_info, "Channel", val);
957 rv = ipmi_channel_info_get_medium(info, &val);
958 if (!rv) {
959 ipmi_cmdlang_out_int(cmd_info, "Medium", val);
960 ipmi_cmdlang_out(cmd_info, "Medium String",
961 ipmi_channel_medium_string(val));
962 }
963 rv = ipmi_channel_info_get_protocol_type(info, &val);
964 if (!rv) {
965 ipmi_cmdlang_out_int(cmd_info, "Protocol Type", val);
966 ipmi_cmdlang_out(cmd_info, "Protocol Type String",
967 ipmi_channel_protocol_string(val));
968 }
969 rv = ipmi_channel_info_get_session_support(info, &val);
970 if (!rv) {
971 switch (val) {
972 case IPMI_CHANNEL_SESSION_LESS: str = "session-less"; break;
973 case IPMI_CHANNEL_SINGLE_SESSION: str = "single-session"; break;
974 case IPMI_CHANNEL_MULTI_SESSION: str = "multi-session"; break;
975 case IPMI_CHANNEL_SESSION_BASED: str = "session-based"; break;
976 default: str = "unknown";
977 }
978 ipmi_cmdlang_out(cmd_info, "Session Support", str);
979 }
980 rv = ipmi_channel_info_get_vendor_id(info, data);
981 if (!rv)
982 ipmi_cmdlang_out_binary(cmd_info, "Vendor ID", (char *) data, 3);
983 rv = ipmi_channel_info_get_aux_info(info, data);
984 if (!rv)
985 ipmi_cmdlang_out_binary(cmd_info, "Aux Info", (char *) data, 2);
986 ipmi_cmdlang_up(cmd_info);
987 ipmi_cmdlang_unlock(cmd_info);
988 }
989
990 static void
got_chan_info(ipmi_mc_t * mc,int err,ipmi_channel_info_t * info,void * cb_data)991 got_chan_info(ipmi_mc_t *mc,
992 int err,
993 ipmi_channel_info_t *info,
994 void *cb_data)
995 {
996 ipmi_cmd_info_t *cmd_info = cb_data;
997 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
998
999 if (err) {
1000 cmdlang->err = err;
1001 cmdlang->errstr = "Error getting channel info";
1002 goto out_err;
1003 }
1004
1005 dump_chan_info(mc, info, cmd_info);
1006
1007 out_err:
1008 if (cmdlang->err) {
1009 cmdlang->location = "cmd_mc.c(got_chan_info)";
1010 }
1011
1012 ipmi_cmdlang_cmd_info_put(cmd_info);
1013 }
1014
1015 static void
got_chan_info_multi(ipmi_mc_t * mc,int err,ipmi_channel_info_t * info,void * cb_data)1016 got_chan_info_multi(ipmi_mc_t *mc,
1017 int err,
1018 ipmi_channel_info_t *info,
1019 void *cb_data)
1020 {
1021 ipmi_cmd_info_t *cmd_info = cb_data;
1022
1023 if (err)
1024 /* Ignore this on multiple fetches, don't print an error */
1025 goto out;
1026
1027 dump_chan_info(mc, info, cmd_info);
1028
1029
1030 out:
1031 ipmi_cmdlang_cmd_info_put(cmd_info);
1032 }
1033
1034 static void
mc_get_chan_info(ipmi_mc_t * mc,void * cb_data)1035 mc_get_chan_info(ipmi_mc_t *mc, void *cb_data)
1036 {
1037 ipmi_cmd_info_t *cmd_info = cb_data;
1038 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1039 int rv;
1040 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1041 int argc = ipmi_cmdlang_get_argc(cmd_info);
1042 char **argv = ipmi_cmdlang_get_argv(cmd_info);
1043 int channel;
1044
1045
1046 if ((argc - curr_arg) < 1) {
1047 int count = 0;
1048 /* List them all */
1049 for (channel=0; channel<8; channel++) {
1050 ipmi_cmdlang_cmd_info_get(cmd_info);
1051 rv = ipmi_mc_channel_get_info(mc, channel, got_chan_info_multi,
1052 cmd_info);
1053 if (rv)
1054 ipmi_cmdlang_cmd_info_put(cmd_info);
1055 else
1056 count++;
1057 }
1058 if (count == 0) {
1059 cmdlang->err = rv;
1060 cmdlang->errstr = "Could not get channel info for any channels";
1061 goto out_err;
1062 }
1063 } else {
1064 ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
1065 if (cmdlang->err) {
1066 cmdlang->errstr = "channel invalid";
1067 goto out_err;
1068 }
1069 curr_arg++;
1070
1071 ipmi_cmdlang_cmd_info_get(cmd_info);
1072 rv = ipmi_mc_channel_get_info(mc, channel, got_chan_info, cmd_info);
1073 if (rv) {
1074 ipmi_cmdlang_cmd_info_put(cmd_info);
1075 cmdlang->err = rv;
1076 cmdlang->errstr = "Could not get channel info";
1077 goto out_err;
1078 }
1079 }
1080
1081 return;
1082
1083 out_err:
1084 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
1085 cmdlang->location = "cmd_mc.c(mc_get_chan_info)";
1086 }
1087
1088 typedef struct get_chan_info_s
1089 {
1090 char *type;
1091 ipmi_cmd_info_t *cmd_info;
1092 } get_chan_info_t;
1093
1094 void
got_chan_access(ipmi_mc_t * mc,int err,ipmi_channel_access_t * info,void * cb_data)1095 got_chan_access(ipmi_mc_t *mc,
1096 int err,
1097 ipmi_channel_access_t *info,
1098 void *cb_data)
1099 {
1100 get_chan_info_t *chan_info = cb_data;
1101 ipmi_cmd_info_t *cmd_info = chan_info->cmd_info;
1102 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1103 char mc_name[IPMI_MC_NAME_LEN];
1104 char *str;
1105 int rv;
1106 unsigned int val;
1107
1108 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
1109
1110 if (err) {
1111 cmdlang->err = err;
1112 cmdlang->errstr = "Error getting channel access info";
1113 goto out_err;
1114 }
1115
1116 ipmi_cmdlang_lock(cmd_info);
1117 ipmi_cmdlang_out(cmd_info, "Channel Access", NULL);
1118 ipmi_cmdlang_down(cmd_info);
1119 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
1120 rv = ipmi_channel_access_get_channel(info, &val);
1121 if (!rv)
1122 ipmi_cmdlang_out_int(cmd_info, "Channel", val);
1123 ipmi_cmdlang_out(cmd_info, "Type", chan_info->type);
1124 rv = ipmi_channel_access_get_alerting_enabled(info, &val);
1125 if (!rv)
1126 ipmi_cmdlang_out_bool(cmd_info, "Alerting Enabled", val);
1127 rv = ipmi_channel_access_get_per_msg_auth(info, &val);
1128 if (!rv)
1129 ipmi_cmdlang_out_bool(cmd_info, "Per-Message Auth", val);
1130 rv = ipmi_channel_access_get_user_auth(info, &val);
1131 if (!rv)
1132 ipmi_cmdlang_out_bool(cmd_info, "User Auth", val);
1133 rv = ipmi_channel_access_get_access_mode(info, &val);
1134 if (!rv) {
1135 switch (val) {
1136 case IPMI_CHANNEL_ACCESS_MODE_DISABLED: str = "disabled"; break;
1137 case IPMI_CHANNEL_ACCESS_MODE_PRE_BOOT: str = "pre-boot"; break;
1138 case IPMI_CHANNEL_ACCESS_MODE_ALWAYS: str = "always"; break;
1139 case IPMI_CHANNEL_ACCESS_MODE_SHARED: str = "shared"; break;
1140 default: str = "unknown";
1141 }
1142 ipmi_cmdlang_out(cmd_info, "Access Mode", str);
1143 }
1144 rv = ipmi_channel_access_get_priv_limit(info, &val);
1145 if (!rv)
1146 ipmi_cmdlang_out(cmd_info, "Privilege Limit",
1147 ipmi_privilege_string(val));
1148 ipmi_cmdlang_up(cmd_info);
1149 ipmi_cmdlang_unlock(cmd_info);
1150
1151 out_err:
1152 if (cmdlang->err) {
1153 cmdlang->location = "cmd_mc.c(got_chan_access)";
1154 }
1155
1156 ipmi_cmdlang_cmd_info_put(cmd_info);
1157 ipmi_mem_free(chan_info);
1158 }
1159
1160 static void
mc_get_chan_access(ipmi_mc_t * mc,void * cb_data)1161 mc_get_chan_access(ipmi_mc_t *mc, void *cb_data)
1162 {
1163 ipmi_cmd_info_t *cmd_info = cb_data;
1164 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1165 int rv;
1166 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1167 int argc = ipmi_cmdlang_get_argc(cmd_info);
1168 char **argv = ipmi_cmdlang_get_argv(cmd_info);
1169 int channel;
1170 get_chan_info_t *present = NULL;
1171 get_chan_info_t *non_volatile = NULL;
1172
1173
1174 if ((argc - curr_arg) < 2) {
1175 /* Not enough parameters */
1176 cmdlang->errstr = "Not enough parameters";
1177 cmdlang->err = EINVAL;
1178 goto out_err;
1179 }
1180
1181 ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
1182 if (cmdlang->err) {
1183 cmdlang->errstr = "channel invalid";
1184 goto out_err;
1185 }
1186 curr_arg++;
1187
1188 if (strcmp(argv[curr_arg], "non-volatile") == 0) {
1189 non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
1190 if (!non_volatile) {
1191 cmdlang->err = ENOMEM;
1192 cmdlang->errstr = "Out of memory";
1193 }
1194 } else if (strcmp(argv[curr_arg], "present") == 0) {
1195 present = ipmi_mem_alloc(sizeof(*present));
1196 if (!present) {
1197 cmdlang->err = ENOMEM;
1198 cmdlang->errstr = "Out of memory";
1199 }
1200 } else if (strcmp(argv[curr_arg], "both") == 0) {
1201 non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
1202 if (!non_volatile) {
1203 cmdlang->err = ENOMEM;
1204 cmdlang->errstr = "Out of memory";
1205 }
1206 present = ipmi_mem_alloc(sizeof(*present));
1207 if (!present) {
1208 ipmi_mem_free(non_volatile);
1209 cmdlang->err = ENOMEM;
1210 cmdlang->errstr = "Out of memory";
1211 }
1212 } else {
1213 cmdlang->err = EINVAL;
1214 cmdlang->errstr = "fetch type invalid";
1215 goto out_err;
1216 }
1217
1218 if (present) {
1219 present->type = "present";
1220 present->cmd_info = cmd_info;
1221
1222 ipmi_cmdlang_cmd_info_get(cmd_info);
1223 rv = ipmi_mc_channel_get_access(mc, channel,
1224 IPMI_SET_DEST_VOLATILE,
1225 got_chan_access,
1226 present);
1227 if (rv) {
1228 ipmi_cmdlang_cmd_info_put(cmd_info);
1229 cmdlang->err = rv;
1230 cmdlang->errstr = "Could not send command to get present value";
1231 ipmi_mem_free(present);
1232 present = NULL;
1233 }
1234 }
1235
1236 if (non_volatile) {
1237 non_volatile->type = "non-volatile";
1238 non_volatile->cmd_info = cmd_info;
1239
1240 ipmi_cmdlang_cmd_info_get(cmd_info);
1241 rv = ipmi_mc_channel_get_access(mc, channel,
1242 IPMI_SET_DEST_NON_VOLATILE,
1243 got_chan_access,
1244 non_volatile);
1245 if (rv) {
1246 ipmi_cmdlang_cmd_info_put(cmd_info);
1247 cmdlang->err = rv;
1248 cmdlang->errstr = "Could not send command to get non-volatile"
1249 " value";
1250 ipmi_mem_free(non_volatile);
1251 non_volatile = NULL;
1252 }
1253 }
1254
1255 if ((present == NULL) && (non_volatile == NULL))
1256 goto out_err;
1257
1258 return;
1259
1260 out_err:
1261 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
1262 cmdlang->location = "cmd_mc.c(mc_get_chan_access)";
1263 }
1264
1265 typedef struct set_chan_parm_s
1266 {
1267 int alert_set;
1268 int alert_val;
1269 int msg_auth_set;
1270 int msg_auth_val;
1271 int user_auth_set;
1272 int user_auth_val;
1273 int access_mode_set;
1274 int access_mode_val;
1275 int privilege_set;
1276 int privilege_val;
1277 } set_chan_parm_t;
1278
1279 typedef struct set_chan_info_s
1280 {
1281 char *type;
1282 enum ipmi_set_dest_e dest;
1283 ipmi_cmd_info_t *cmd_info;
1284 set_chan_parm_t parms;
1285 unsigned int channel;
1286 } set_chan_info_t;
1287
1288 void
set_chan_access2(ipmi_mc_t * mc,int err,void * cb_data)1289 set_chan_access2(ipmi_mc_t *mc, int err, void *cb_data)
1290 {
1291 set_chan_info_t *chan_info = cb_data;
1292 ipmi_cmd_info_t *cmd_info = chan_info->cmd_info;
1293 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1294 char mc_name[IPMI_MC_NAME_LEN];
1295
1296 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
1297
1298 if (err) {
1299 cmdlang->err = err;
1300 cmdlang->errstr = "Error getting channel info";
1301 goto out_err;
1302 }
1303
1304 ipmi_cmdlang_lock(cmd_info);
1305 ipmi_cmdlang_out(cmd_info, "Channel Access Set", NULL);
1306 ipmi_cmdlang_down(cmd_info);
1307 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
1308 ipmi_cmdlang_out_int(cmd_info, "Channel", chan_info->channel);
1309 ipmi_cmdlang_up(cmd_info);
1310 ipmi_cmdlang_unlock(cmd_info);
1311
1312 out_err:
1313 if (cmdlang->err) {
1314 cmdlang->location = "cmd_mc.c(set_chan_access2)";
1315 }
1316
1317 ipmi_cmdlang_cmd_info_put(cmd_info);
1318 ipmi_mem_free(chan_info);
1319 }
1320
1321 void
set_chan_access1(ipmi_mc_t * mc,int err,ipmi_channel_access_t * info,void * cb_data)1322 set_chan_access1(ipmi_mc_t *mc,
1323 int err,
1324 ipmi_channel_access_t *info,
1325 void *cb_data)
1326 {
1327 set_chan_info_t *cinfo = cb_data;
1328 ipmi_cmd_info_t *cmd_info = cinfo->cmd_info;
1329 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1330 char mc_name[IPMI_MC_NAME_LEN];
1331 int rv;
1332 unsigned int channel;
1333
1334 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
1335
1336 if (err) {
1337 cmdlang->err = err;
1338 cmdlang->errstr = "Error getting channel info";
1339 goto out_err;
1340 }
1341 if (cinfo->parms.alert_set)
1342 ipmi_channel_access_set_alerting_enabled(info, cinfo->parms.alert_val);
1343 if (cinfo->parms.msg_auth_set)
1344 ipmi_channel_access_set_per_msg_auth(info, cinfo->parms.msg_auth_val);
1345 if (cinfo->parms.user_auth_set)
1346 ipmi_channel_access_set_user_auth(info, cinfo->parms.user_auth_val);
1347 if (cinfo->parms.access_mode_set)
1348 ipmi_channel_access_set_access_mode(info,
1349 cinfo->parms.access_mode_val);
1350 if (cinfo->parms.privilege_set)
1351 ipmi_channel_access_set_priv_limit(info, cinfo->parms.privilege_val);
1352 ipmi_channel_access_get_channel(info, &channel);
1353
1354 rv = ipmi_mc_channel_set_access(mc, channel, cinfo->dest,
1355 info, set_chan_access2, cinfo);
1356 if (rv) {
1357 cmdlang->err = rv;
1358 cmdlang->errstr = "Could not send command to get present value";
1359 goto out_err;
1360 }
1361
1362 return;
1363
1364 out_err:
1365 if (cmdlang->err) {
1366 cmdlang->location = "cmd_mc.c(set_chan_access1)";
1367 }
1368
1369 ipmi_cmdlang_cmd_info_put(cmd_info);
1370 ipmi_mem_free(cinfo);
1371 }
1372
1373 static void
mc_set_chan_access(ipmi_mc_t * mc,void * cb_data)1374 mc_set_chan_access(ipmi_mc_t *mc, void *cb_data)
1375 {
1376 ipmi_cmd_info_t *cmd_info = cb_data;
1377 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1378 int rv;
1379 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1380 int argc = ipmi_cmdlang_get_argc(cmd_info);
1381 char **argv = ipmi_cmdlang_get_argv(cmd_info);
1382 int channel;
1383 set_chan_info_t *present = NULL;
1384 set_chan_info_t *non_volatile = NULL;
1385 set_chan_parm_t parms;
1386
1387 if ((argc - curr_arg) < 2) {
1388 /* Not enough parameters */
1389 cmdlang->errstr = "Not enough parameters";
1390 cmdlang->err = EINVAL;
1391 goto out_err;
1392 }
1393
1394 ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
1395 if (cmdlang->err) {
1396 cmdlang->errstr = "channel invalid";
1397 goto out_err;
1398 }
1399 curr_arg++;
1400
1401 if (strcmp(argv[curr_arg], "non-volatile") == 0) {
1402 non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
1403 if (!non_volatile) {
1404 cmdlang->err = ENOMEM;
1405 cmdlang->errstr = "Out of memory";
1406 goto out_err;
1407 }
1408 } else if (strcmp(argv[curr_arg], "present") == 0) {
1409 present = ipmi_mem_alloc(sizeof(*present));
1410 if (!present) {
1411 cmdlang->err = ENOMEM;
1412 cmdlang->errstr = "Out of memory";
1413 goto out_err;
1414 }
1415 } else if (strcmp(argv[curr_arg], "both") == 0) {
1416 non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
1417 if (!non_volatile) {
1418 cmdlang->err = ENOMEM;
1419 cmdlang->errstr = "Out of memory";
1420 goto out_err;
1421 }
1422 present = ipmi_mem_alloc(sizeof(*present));
1423 if (!present) {
1424 ipmi_mem_free(non_volatile);
1425 cmdlang->err = ENOMEM;
1426 cmdlang->errstr = "Out of memory";
1427 goto out_err;
1428 }
1429 } else {
1430 cmdlang->err = EINVAL;
1431 cmdlang->errstr = "fetch type invalid";
1432 goto out_err;
1433 }
1434 curr_arg++;
1435
1436 memset(&parms, 0, sizeof(parms));
1437
1438 while (curr_arg < argc) {
1439 if (strcmp(argv[curr_arg], "alert") == 0) {
1440 parms.alert_set = 1;
1441 curr_arg++;
1442 if (curr_arg >= argc) {
1443 cmdlang->err = EINVAL;
1444 cmdlang->errstr = "no alert value";
1445 goto out_err;
1446 }
1447 ipmi_cmdlang_get_bool(argv[curr_arg], &parms.alert_val, cmd_info);
1448 if (cmdlang->err) {
1449 cmdlang->errstr = "invalid alert value";
1450 goto out_err;
1451 }
1452 } else if (strcmp(argv[curr_arg], "msg_auth") == 0) {
1453 parms.msg_auth_set = 1;
1454 curr_arg++;
1455 if (curr_arg >= argc) {
1456 cmdlang->err = EINVAL;
1457 cmdlang->errstr = "no msg_auth value";
1458 goto out_err;
1459 }
1460 ipmi_cmdlang_get_bool(argv[curr_arg], &parms.msg_auth_val,
1461 cmd_info);
1462 if (cmdlang->err) {
1463 cmdlang->errstr = "invalid msg_auth value";
1464 goto out_err;
1465 }
1466 } else if (strcmp(argv[curr_arg], "user_auth") == 0) {
1467 parms.user_auth_set = 1;
1468 curr_arg++;
1469 if (curr_arg >= argc) {
1470 cmdlang->err = EINVAL;
1471 cmdlang->errstr = "no user_auth value";
1472 goto out_err;
1473 }
1474 ipmi_cmdlang_get_bool(argv[curr_arg], &parms.user_auth_val,
1475 cmd_info);
1476 if (cmdlang->err) {
1477 cmdlang->errstr = "invalid user_auth value";
1478 goto out_err;
1479 }
1480 } else if (strcmp(argv[curr_arg], "access_mode") == 0) {
1481 parms.access_mode_set = 1;
1482 curr_arg++;
1483 if (curr_arg >= argc) {
1484 cmdlang->err = EINVAL;
1485 cmdlang->errstr = "no access_mode value";
1486 goto out_err;
1487 }
1488 if (strcmp(argv[curr_arg], "disabled") == 0) {
1489 parms.access_mode_val = IPMI_CHANNEL_ACCESS_MODE_DISABLED;
1490 } else if (strcmp(argv[curr_arg], "pre-boot") == 0) {
1491 parms.access_mode_val = IPMI_CHANNEL_ACCESS_MODE_PRE_BOOT;
1492 } else if (strcmp(argv[curr_arg], "always") == 0) {
1493 parms.access_mode_val = IPMI_CHANNEL_ACCESS_MODE_ALWAYS;
1494 } else if (strcmp(argv[curr_arg], "shared") == 0) {
1495 parms.access_mode_val = IPMI_CHANNEL_ACCESS_MODE_SHARED;
1496 } else {
1497 cmdlang->err = EINVAL;
1498 cmdlang->errstr = "invalid access_mode value";
1499 goto out_err;
1500 }
1501 } else if (strcmp(argv[curr_arg], "privilege_limit") == 0) {
1502 parms.privilege_set = 1;
1503 curr_arg++;
1504 if (curr_arg >= argc) {
1505 cmdlang->err = EINVAL;
1506 cmdlang->errstr = "no privilege_limit value";
1507 goto out_err;
1508 }
1509 if (strcmp(argv[curr_arg], "callback") == 0) {
1510 parms.privilege_val = IPMI_PRIVILEGE_CALLBACK;
1511 } else if (strcmp(argv[curr_arg], "user") == 0) {
1512 parms.privilege_val = IPMI_PRIVILEGE_USER;
1513 } else if (strcmp(argv[curr_arg], "operator") == 0) {
1514 parms.privilege_val = IPMI_PRIVILEGE_OPERATOR;
1515 } else if (strcmp(argv[curr_arg], "admin") == 0) {
1516 parms.privilege_val = IPMI_PRIVILEGE_ADMIN;
1517 } else if (strcmp(argv[curr_arg], "oem") == 0) {
1518 parms.privilege_val = IPMI_PRIVILEGE_OEM;
1519 } else {
1520 cmdlang->err = EINVAL;
1521 cmdlang->errstr = "invalid privilege_limit value";
1522 goto out_err;
1523 }
1524 } else {
1525 cmdlang->err = EINVAL;
1526 cmdlang->errstr = "invalid setting";
1527 goto out_err;
1528 }
1529 curr_arg++;
1530 }
1531
1532 if (present) {
1533 present->type = "present";
1534 present->cmd_info = cmd_info;
1535 present->parms = parms;
1536 present->channel = channel;
1537 present->dest = IPMI_SET_DEST_VOLATILE;
1538
1539 ipmi_cmdlang_cmd_info_get(cmd_info);
1540 rv = ipmi_mc_channel_get_access(mc, channel, present->dest,
1541 set_chan_access1, present);
1542 if (rv) {
1543 ipmi_cmdlang_cmd_info_put(cmd_info);
1544 cmdlang->err = rv;
1545 cmdlang->errstr = "Could not send command to get present value";
1546 ipmi_mem_free(present);
1547 present = NULL;
1548 }
1549 }
1550
1551 if (non_volatile) {
1552 non_volatile->type = "non-volatile";
1553 non_volatile->cmd_info = cmd_info;
1554 non_volatile->parms = parms;
1555 non_volatile->channel = channel;
1556 non_volatile->dest = IPMI_SET_DEST_NON_VOLATILE;
1557
1558 ipmi_cmdlang_cmd_info_get(cmd_info);
1559 rv = ipmi_mc_channel_get_access(mc, channel, non_volatile->dest,
1560 set_chan_access1, non_volatile);
1561 if (rv) {
1562 ipmi_cmdlang_cmd_info_put(cmd_info);
1563 cmdlang->err = rv;
1564 cmdlang->errstr = "Could not send command to get non-volatile"
1565 " value";
1566 ipmi_mem_free(non_volatile);
1567 non_volatile = NULL;
1568 }
1569 }
1570
1571 if ((present == NULL) && (non_volatile == NULL))
1572 goto out_err;
1573
1574 return;
1575
1576 out_err:
1577 if (non_volatile)
1578 ipmi_mem_free(non_volatile);
1579 if (present)
1580 ipmi_mem_free(present);
1581 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
1582 cmdlang->location = "cmd_mc.c(mc_get_chan_access)";
1583 }
1584
1585 static void
got_users(ipmi_mc_t * mc,int err,ipmi_user_list_t * list,void * cb_data)1586 got_users(ipmi_mc_t *mc,
1587 int err,
1588 ipmi_user_list_t *list,
1589 void *cb_data)
1590 {
1591 ipmi_cmd_info_t *cmd_info = cb_data;
1592 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1593 ipmi_user_t *user;
1594 char mc_name[IPMI_MC_NAME_LEN];
1595 int i, j, k;
1596 char str[17];
1597 unsigned int count;
1598 unsigned int channel;
1599 unsigned int val;
1600 int rv;
1601
1602 if (err) {
1603 cmdlang->err = err;
1604 cmdlang->errstr = "Error getting user info";
1605 goto out_err;
1606 }
1607
1608 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
1609
1610 count = ipmi_user_list_get_user_count(list);
1611
1612 rv = ipmi_user_list_get_channel(list, &channel);
1613 if (rv) {
1614 cmdlang->err = rv;
1615 cmdlang->errstr = "Error getting channel";
1616 goto out_err;
1617 }
1618
1619 ipmi_cmdlang_lock(cmd_info);
1620 ipmi_cmdlang_out(cmd_info, "MC", mc_name);
1621 ipmi_cmdlang_out_int(cmd_info, "Channel", channel);
1622 rv = ipmi_user_list_get_max_user(list, &val);
1623 if (!rv)
1624 ipmi_cmdlang_out_int(cmd_info, "Max User", val);
1625 rv = ipmi_user_list_get_enabled_users(list, &val);
1626 if (!rv)
1627 ipmi_cmdlang_out_int(cmd_info, "Enabled Users", val);
1628 rv = ipmi_user_list_get_fixed_users(list, &val);
1629 if (!rv)
1630 ipmi_cmdlang_out_int(cmd_info, "Fixed Users", val);
1631 for (i=0; i<(int)count; i++) {
1632 user = ipmi_user_list_get_user(list, i);
1633 if (!user)
1634 continue;
1635 ipmi_cmdlang_out(cmd_info, "User", NULL);
1636 ipmi_cmdlang_down(cmd_info);
1637 rv = ipmi_user_get_num(user, &val);
1638 if (!rv)
1639 ipmi_cmdlang_out_int(cmd_info, "Number", val);
1640
1641 val = 17;
1642 rv = ipmi_user_get_name(user, str, &val);
1643 if (!rv) {
1644 val = 1;
1645 for (j=15; j>=0; j--) {
1646 if (str[j] != '\0')
1647 break;
1648 }
1649 for (k=0; k<=j; k++) {
1650 if (! isprint(str[k])) {
1651 val = 0;
1652 break;
1653 }
1654 }
1655 if (val)
1656 ipmi_cmdlang_out(cmd_info, "String Name", str);
1657 else
1658 ipmi_cmdlang_out_binary(cmd_info, "Binary Name", str, 16);
1659 }
1660 rv = ipmi_user_get_link_auth_enabled(user, &val);
1661 if (!rv)
1662 ipmi_cmdlang_out_bool(cmd_info, "Link Auth Enabled", val);
1663 rv = ipmi_user_get_msg_auth_enabled(user, &val);
1664 if (!rv)
1665 ipmi_cmdlang_out_bool(cmd_info, "Msg Auth Enabled", val);
1666 rv = ipmi_user_get_access_cb_only(user, &val);
1667 if (!rv)
1668 ipmi_cmdlang_out_bool(cmd_info, "Access CB Only", val);
1669 rv = ipmi_user_get_privilege_limit(user, &val);
1670 if (!rv)
1671 ipmi_cmdlang_out(cmd_info, "Privilege Limit",
1672 ipmi_privilege_string(val));
1673 rv = ipmi_user_get_session_limit(user, &val);
1674 if (!rv)
1675 ipmi_cmdlang_out_bool(cmd_info, "Session Limit", val);
1676 ipmi_cmdlang_up(cmd_info);
1677 ipmi_user_free(user);
1678 }
1679 ipmi_cmdlang_unlock(cmd_info);
1680 ipmi_cmdlang_cmd_info_put(cmd_info);
1681 return;
1682
1683 out_err:
1684 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
1685 cmdlang->location = "cmd_mc.c(got_users)";
1686 ipmi_cmdlang_cmd_info_put(cmd_info);
1687 }
1688
1689 static void
mc_user_list(ipmi_mc_t * mc,void * cb_data)1690 mc_user_list(ipmi_mc_t *mc, void *cb_data)
1691 {
1692 ipmi_cmd_info_t *cmd_info = cb_data;
1693 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1694 int rv;
1695 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1696 int argc = ipmi_cmdlang_get_argc(cmd_info);
1697 char **argv = ipmi_cmdlang_get_argv(cmd_info);
1698 int channel;
1699 int user = IPMI_MC_ALL_USERS;
1700
1701 if ((argc - curr_arg) < 1) {
1702 /* Not enough parameters */
1703 cmdlang->errstr = "Not enough parameters";
1704 cmdlang->err = EINVAL;
1705 goto out_err;
1706 }
1707
1708 ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
1709 if (cmdlang->err) {
1710 cmdlang->errstr = "channel invalid";
1711 goto out_err;
1712 }
1713 curr_arg++;
1714
1715 if (argc > curr_arg) {
1716 ipmi_cmdlang_get_int(argv[curr_arg], &user, cmd_info);
1717 if (cmdlang->err) {
1718 cmdlang->errstr = "user invalid";
1719 goto out_err;
1720 }
1721 curr_arg++;
1722 }
1723
1724 ipmi_cmdlang_cmd_info_get(cmd_info);
1725 rv = ipmi_mc_get_users(mc, channel, user, got_users, cmd_info);
1726 if (rv) {
1727 ipmi_cmdlang_cmd_info_put(cmd_info);
1728 cmdlang->err = rv;
1729 goto out_err;
1730 }
1731 return;
1732
1733 out_err:
1734 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
1735 cmdlang->location = "cmd_mc.c(mc_user_list)";
1736 }
1737
1738 typedef struct user_set_s
1739 {
1740 int channel;
1741 int user;
1742 ipmi_cmd_info_t *cmd_info;
1743 int link_enabled_set;
1744 int link_enabled_val;
1745 int msg_enabled_set;
1746 int msg_enabled_val;
1747 int privilege_limit_set;
1748 int privilege_limit_val;
1749 int cb_only_set;
1750 int cb_only_val;
1751 int session_limit_set;
1752 int session_limit_val;
1753 int enable_set;
1754 int enable_val;
1755 int name_set;
1756 char name[16];
1757 int pw_set;
1758 int pw2_set;
1759 char pw[20];
1760 } user_set_t;
1761
1762 static void
set_user2(ipmi_mc_t * mc,int err,void * cb_data)1763 set_user2(ipmi_mc_t *mc, int err, void *cb_data)
1764 {
1765 user_set_t *info = cb_data;
1766 ipmi_cmd_info_t *cmd_info = info->cmd_info;
1767 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1768 char mc_name[IPMI_MC_NAME_LEN];
1769
1770 if (err) {
1771 cmdlang->err = err;
1772 cmdlang->errstr = "Error setting user info";
1773 goto out_err;
1774 }
1775
1776 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
1777
1778 ipmi_cmdlang_lock(cmd_info);
1779 ipmi_cmdlang_out(cmd_info, "User Info Set", mc_name);
1780 ipmi_cmdlang_unlock(cmd_info);
1781 ipmi_cmdlang_cmd_info_put(cmd_info);
1782 ipmi_mem_free(info);
1783
1784 return;
1785
1786 out_err:
1787 cmdlang->location = "cmd_mc.c(set_user2)";
1788 ipmi_cmdlang_cmd_info_put(cmd_info);
1789 ipmi_mem_free(info);
1790 }
1791
1792 static void
set_user1(ipmi_mc_t * mc,int err,ipmi_user_list_t * list,void * cb_data)1793 set_user1(ipmi_mc_t *mc,
1794 int err,
1795 ipmi_user_list_t *list,
1796 void *cb_data)
1797 {
1798 user_set_t *info = cb_data;
1799 ipmi_cmd_info_t *cmd_info = info->cmd_info;
1800 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1801 ipmi_user_t *user = NULL;
1802 int rv = 0;
1803
1804 if (err) {
1805 cmdlang->err = err;
1806 cmdlang->errstr = "Error getting user info";
1807 goto out_err;
1808 }
1809
1810 user = ipmi_user_list_get_user(list, 0);
1811 if (!user) {
1812 /* Eh? */
1813 cmdlang->err = EINVAL;
1814 cmdlang->errstr = "Error getting user";
1815 goto out_err;
1816 }
1817
1818 if (info->link_enabled_set)
1819 rv |= ipmi_user_set_link_auth_enabled(user, info->link_enabled_val);
1820 if (info->msg_enabled_set)
1821 rv |= ipmi_user_set_msg_auth_enabled(user, info->msg_enabled_val);
1822 if (info->cb_only_set)
1823 rv |= ipmi_user_set_access_cb_only(user, info->cb_only_val);
1824 if (info->privilege_limit_set)
1825 rv |= ipmi_user_set_privilege_limit(user,info->privilege_limit_val);
1826 if (info->session_limit_set)
1827 /* Optional value, afaict there is no way to get this value. */
1828 rv |= ipmi_user_set_session_limit(user, info->session_limit_val);
1829 if (info->pw2_set)
1830 rv |= ipmi_user_set_password2(user, info->pw, 20);
1831 else if (info->pw_set)
1832 rv |= ipmi_user_set_password(user, info->pw, 16);
1833 if (info->name_set)
1834 rv |= ipmi_user_set_name(user, info->name, strlen(info->name));
1835 if (info->enable_set)
1836 /* Optional value, afaict there is no way to get this value. */
1837 rv |= ipmi_user_set_enable(user, info->enable_val);
1838
1839 rv = ipmi_mc_set_user(mc, info->channel, info->user, user,
1840 set_user2, info);
1841 if (rv) {
1842 cmdlang->err = EINVAL;
1843 cmdlang->errstr = "Error sending set user access cmd";
1844 goto out_err;
1845 }
1846 ipmi_user_free(user);
1847 return;
1848
1849 out_err:
1850 if (user)
1851 ipmi_user_free(user);
1852 cmdlang->location = "cmd_mc.c(set_user1)";
1853 ipmi_cmdlang_cmd_info_put(cmd_info);
1854 ipmi_mem_free(info);
1855 }
1856
1857 static void
mc_user_set(ipmi_mc_t * mc,void * cb_data)1858 mc_user_set(ipmi_mc_t *mc, void *cb_data)
1859 {
1860 ipmi_cmd_info_t *cmd_info = cb_data;
1861 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1862 int rv;
1863 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1864 int argc = ipmi_cmdlang_get_argc(cmd_info);
1865 char **argv = ipmi_cmdlang_get_argv(cmd_info);
1866 int channel;
1867 int user;
1868 user_set_t *info = NULL;
1869
1870 if ((argc - curr_arg) < 1) {
1871 /* Not enough parameters */
1872 cmdlang->errstr = "Not enough parameters";
1873 cmdlang->err = EINVAL;
1874 goto out_err;
1875 }
1876
1877 ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
1878 if (cmdlang->err) {
1879 cmdlang->errstr = "channel invalid";
1880 goto out_err;
1881 }
1882 curr_arg++;
1883
1884 ipmi_cmdlang_get_int(argv[curr_arg], &user, cmd_info);
1885 if (cmdlang->err || (user > 0x1f) || (user < 1)) {
1886 cmdlang->errstr = "user invalid";
1887 goto out_err;
1888 }
1889 curr_arg++;
1890
1891 info = ipmi_mem_alloc(sizeof(*info));
1892 if (!info) {
1893 cmdlang->err = ENOMEM;
1894 cmdlang->errstr = "Out of memory";
1895 goto out_err;
1896 }
1897 memset(info, 0, sizeof(*info));
1898 info->channel = channel;
1899 info->cmd_info = cmd_info;
1900 info->user = user;
1901
1902 while (curr_arg < argc) {
1903 if (strcmp(argv[curr_arg], "link_enabled") == 0) {
1904 info->link_enabled_set = 1;
1905 curr_arg++;
1906 if (curr_arg >= argc) {
1907 cmdlang->err = EINVAL;
1908 cmdlang->errstr = "link_enabled value";
1909 goto out_err;
1910 }
1911 ipmi_cmdlang_get_bool(argv[curr_arg], &info->link_enabled_val,
1912 cmd_info);
1913 if (cmdlang->err) {
1914 cmdlang->errstr = "invalid link_enabled value";
1915 goto out_err;
1916 }
1917 } else if (strcmp(argv[curr_arg], "msg_enabled") == 0) {
1918 info->msg_enabled_set = 1;
1919 curr_arg++;
1920 if (curr_arg >= argc) {
1921 cmdlang->err = EINVAL;
1922 cmdlang->errstr = "no msg_enabled value";
1923 goto out_err;
1924 }
1925 ipmi_cmdlang_get_bool(argv[curr_arg], &info->msg_enabled_val,
1926 cmd_info);
1927 if (cmdlang->err) {
1928 cmdlang->errstr = "invalid msg_auth value";
1929 goto out_err;
1930 }
1931 } else if (strcmp(argv[curr_arg], "cb_only") == 0) {
1932 info->cb_only_set = 0x08;
1933 curr_arg++;
1934 if (curr_arg >= argc) {
1935 cmdlang->err = EINVAL;
1936 cmdlang->errstr = "no cb_only value";
1937 goto out_err;
1938 }
1939 ipmi_cmdlang_get_bool(argv[curr_arg], &info->cb_only_val,
1940 cmd_info);
1941 if (cmdlang->err) {
1942 cmdlang->errstr = "invalid cb_only value";
1943 goto out_err;
1944 }
1945 } else if (strcmp(argv[curr_arg], "privilege_limit") == 0) {
1946 info->privilege_limit_set = 1;
1947 curr_arg++;
1948 if (curr_arg >= argc) {
1949 cmdlang->err = EINVAL;
1950 cmdlang->errstr = "no privilege_limit value";
1951 goto out_err;
1952 }
1953 if (strcmp(argv[curr_arg], "callback") == 0) {
1954 info->privilege_limit_val = IPMI_PRIVILEGE_CALLBACK;
1955 } else if (strcmp(argv[curr_arg], "user") == 0) {
1956 info->privilege_limit_val = IPMI_PRIVILEGE_USER;
1957 } else if (strcmp(argv[curr_arg], "operator") == 0) {
1958 info->privilege_limit_val = IPMI_PRIVILEGE_OPERATOR;
1959 } else if (strcmp(argv[curr_arg], "admin") == 0) {
1960 info->privilege_limit_val = IPMI_PRIVILEGE_ADMIN;
1961 } else if (strcmp(argv[curr_arg], "oem") == 0) {
1962 info->privilege_limit_val = IPMI_PRIVILEGE_OEM;
1963 } else if (strcmp(argv[curr_arg], "no_access") == 0) {
1964 info->privilege_limit_val = 0xf;
1965 } else {
1966 cmdlang->err = EINVAL;
1967 cmdlang->errstr = "invalid privilege_limit value";
1968 goto out_err;
1969 }
1970 } else if (strcmp(argv[curr_arg], "session_limit") == 0) {
1971 info->session_limit_set = 1;
1972 curr_arg++;
1973 if (curr_arg >= argc) {
1974 cmdlang->err = EINVAL;
1975 cmdlang->errstr = "no session_limit value";
1976 goto out_err;
1977 }
1978 ipmi_cmdlang_get_int(argv[curr_arg], &info->session_limit_val,
1979 cmd_info);
1980 if ((cmdlang->err) || (info->session_limit_val > 0xf)
1981 || (info->session_limit_val < 0))
1982 {
1983 cmdlang->errstr = "invalid session_limit value";
1984 goto out_err;
1985 }
1986 } else if (strcmp(argv[curr_arg], "enable") == 0) {
1987 info->enable_set = 1;
1988 info->enable_val = 1;
1989 } else if (strcmp(argv[curr_arg], "disable") == 0) {
1990 info->enable_set = 1;
1991 info->enable_val = 0;
1992 } else if (strcmp(argv[curr_arg], "name") == 0) {
1993 info->name_set = 1;
1994 curr_arg++;
1995 if (curr_arg >= argc) {
1996 cmdlang->err = EINVAL;
1997 cmdlang->errstr = "no name value";
1998 goto out_err;
1999 }
2000 strncpy(info->name, argv[curr_arg], 15);
2001 info->name[15] = '\0';
2002 } else if (strcmp(argv[curr_arg], "password") == 0) {
2003 info->pw_set = 1;
2004 curr_arg++;
2005 if (curr_arg >= argc) {
2006 cmdlang->err = EINVAL;
2007 cmdlang->errstr = "no name value";
2008 goto out_err;
2009 }
2010 strncpy(info->pw, argv[curr_arg], 16);
2011 } else if (strcmp(argv[curr_arg], "password2") == 0) {
2012 info->pw2_set = 1;
2013 curr_arg++;
2014 if (curr_arg >= argc) {
2015 cmdlang->err = EINVAL;
2016 cmdlang->errstr = "no name value";
2017 goto out_err;
2018 }
2019 strncpy(info->pw, argv[curr_arg], 19);
2020 info->pw[19] = '\0';
2021 } else {
2022 cmdlang->err = EINVAL;
2023 cmdlang->errstr = "invalid setting";
2024 goto out_err;
2025 }
2026 curr_arg++;
2027 }
2028
2029 ipmi_cmdlang_cmd_info_get(cmd_info);
2030 rv = ipmi_mc_get_users(mc, channel, user, set_user1, info);
2031 if (rv) {
2032 ipmi_cmdlang_cmd_info_put(cmd_info);
2033 cmdlang->err = rv;
2034 cmdlang->errstr = "Error sending get user access cmd";
2035 ipmi_cmdlang_unlock(cmd_info);
2036 goto out_err;
2037 }
2038 return;
2039
2040 out_err:
2041 if (info)
2042 ipmi_mem_free(info);
2043 ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
2044 cmdlang->location = "cmd_mc.c(mc_user_set)";
2045 }
2046
2047 static void
mc_active(ipmi_mc_t * mc,int active,void * cb_data)2048 mc_active(ipmi_mc_t *mc, int active, void *cb_data)
2049 {
2050 char *errstr;
2051 int rv;
2052 ipmi_cmd_info_t *evi;
2053 char mc_name[IPMI_MC_NAME_LEN];
2054
2055 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
2056
2057 evi = ipmi_cmdlang_alloc_event_info();
2058 if (!evi) {
2059 rv = ENOMEM;
2060 errstr = "Out of memory";
2061 goto out_err;
2062 }
2063
2064 ipmi_cmdlang_out(evi, "Object Type", "MC");
2065 ipmi_cmdlang_out(evi, "Name", mc_name);
2066 ipmi_cmdlang_out(evi, "Operation", "Active Changed");
2067 ipmi_cmdlang_out_bool(evi, "Active", active);
2068
2069 ipmi_cmdlang_cmd_info_put(evi);
2070 return;
2071
2072 out_err:
2073 ipmi_cmdlang_global_err(mc_name,
2074 "cmd_mc.c(mc_active)",
2075 errstr, rv);
2076 if (evi)
2077 ipmi_cmdlang_cmd_info_put(evi);
2078 }
2079
2080 static void
mc_fully_up(ipmi_mc_t * mc,void * cb_data)2081 mc_fully_up(ipmi_mc_t *mc, void *cb_data)
2082 {
2083 char *errstr;
2084 int rv;
2085 ipmi_cmd_info_t *evi;
2086 char mc_name[IPMI_MC_NAME_LEN];
2087
2088 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
2089
2090 evi = ipmi_cmdlang_alloc_event_info();
2091 if (!evi) {
2092 rv = ENOMEM;
2093 errstr = "Out of memory";
2094 goto out_err;
2095 }
2096
2097 ipmi_cmdlang_out(evi, "Object Type", "MC");
2098 ipmi_cmdlang_out(evi, "Name", mc_name);
2099 ipmi_cmdlang_out(evi, "Operation", "Fully Up");
2100
2101 ipmi_cmdlang_cmd_info_put(evi);
2102 return;
2103
2104 out_err:
2105 ipmi_cmdlang_global_err(mc_name,
2106 "cmd_mc.c(mc_fully_up)",
2107 errstr, rv);
2108 if (evi)
2109 ipmi_cmdlang_cmd_info_put(evi);
2110 }
2111
2112 void
ipmi_cmdlang_mc_change(enum ipmi_update_e op,ipmi_domain_t * domain,ipmi_mc_t * mc,void * cb_data)2113 ipmi_cmdlang_mc_change(enum ipmi_update_e op,
2114 ipmi_domain_t *domain,
2115 ipmi_mc_t *mc,
2116 void *cb_data)
2117 {
2118 char *errstr;
2119 int rv;
2120 ipmi_cmd_info_t *evi;
2121 char mc_name[IPMI_MC_NAME_LEN];
2122
2123 ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
2124
2125 evi = ipmi_cmdlang_alloc_event_info();
2126 if (!evi) {
2127 errstr = "Out of memory";
2128 rv = ENOMEM;
2129 goto out_err;
2130 }
2131
2132 ipmi_cmdlang_out(evi, "Object Type", "MC");
2133 ipmi_cmdlang_out(evi, "Name", mc_name);
2134
2135 switch (op) {
2136 case IPMI_ADDED:
2137 ipmi_cmdlang_out(evi, "Operation", "Add");
2138 if (ipmi_cmdlang_get_evinfo())
2139 mc_dump(mc, evi);
2140 rv = ipmi_mc_add_active_handler(mc, mc_active, NULL);
2141 if (rv) {
2142 errstr = "ipmi_mc_add_active_handler failed";
2143 goto out_err;
2144 }
2145 rv = ipmi_mc_add_fully_up_handler(mc, mc_fully_up, NULL);
2146 if (rv) {
2147 errstr = "ipmi_mc_add_fully_up_handler failed";
2148 goto out_err;
2149 }
2150 break;
2151
2152 case IPMI_DELETED:
2153 ipmi_cmdlang_out(evi, "Operation", "Delete");
2154 break;
2155
2156 case IPMI_CHANGED:
2157 ipmi_cmdlang_out(evi, "Operation", "Change");
2158 if (ipmi_cmdlang_get_evinfo())
2159 mc_dump(mc, evi);
2160 break;
2161 }
2162
2163 ipmi_cmdlang_cmd_info_put(evi);
2164 return;
2165
2166 out_err:
2167 if (rv) {
2168 ipmi_cmdlang_global_err(mc_name, "cmd_mc.c(ipmi_cmdlang_mc_change)",
2169 errstr, rv);
2170 }
2171 if (evi)
2172 ipmi_cmdlang_cmd_info_put(evi);
2173 }
2174
2175 static ipmi_cmdlang_cmd_t *mc_cmds;
2176 static ipmi_cmdlang_cmd_t *mc_chan_cmds;
2177 static ipmi_cmdlang_cmd_t *mc_user_cmds;
2178
2179 static ipmi_cmdlang_init_t cmds_mc[] =
2180 {
2181 { "mc", NULL,
2182 "- Commands dealing with MCs",
2183 NULL, NULL, &mc_cmds },
2184 { "list", &mc_cmds,
2185 "- List all the entities in the system",
2186 ipmi_cmdlang_domain_handler, mc_list, NULL },
2187 { "info", &mc_cmds,
2188 "<mc> - Dump information about an mc",
2189 ipmi_cmdlang_mc_handler, mc_info, NULL },
2190 { "reset", &mc_cmds,
2191 "<mc> <warm | cold> - Do a warm or cold reset on the given MC. Note"
2192 " that this does *not* reset the main processor, and the effects of"
2193 " this are implementation-defined",
2194 ipmi_cmdlang_mc_handler, mc_reset, NULL },
2195 { "set_events_enable", &mc_cmds,
2196 "<mc> <enable | disable> - Sets if the events are enabled or disabled"
2197 " for an MC",
2198 ipmi_cmdlang_mc_handler, mc_set_events_enable, NULL },
2199 { "get_events_enable", &mc_cmds,
2200 "<mc> - Returns if the events are enabled or disabled"
2201 " for an MC",
2202 ipmi_cmdlang_mc_handler, mc_get_events_enable, NULL },
2203 { "sel_info", &mc_cmds,
2204 "<mc> - Returns information about the SEL on the MC",
2205 ipmi_cmdlang_mc_handler, mc_sel_info, NULL },
2206 { "get_sel_time", &mc_cmds,
2207 "<mc> - Returns SEL time on the MC",
2208 ipmi_cmdlang_mc_handler, mc_get_sel_time, NULL },
2209 { "set_sel_time", &mc_cmds,
2210 "<mc> <time> - Sets SEL time on the MC",
2211 ipmi_cmdlang_mc_handler, mc_set_sel_time, NULL },
2212 { "sel_rescan_time", &mc_cmds,
2213 "<mc> <time in seconds> - Set the time between SEL rescans"
2214 " for the MC. Zero disables scans.",
2215 ipmi_cmdlang_mc_handler, mc_sel_rescan_time, NULL },
2216 { "rescan_sel", &mc_cmds,
2217 "<mc> - Rescan the SEL in the MC",
2218 ipmi_cmdlang_mc_handler, mc_rescan_sels, NULL },
2219 { "msg", &mc_cmds,
2220 "<mc> <LUN> <NetFN> <Cmd> [data...] - Send the given command"
2221 " to the management controller and display the response.",
2222 ipmi_cmdlang_mc_handler, mc_msg, NULL },
2223 { "sdrs", &mc_cmds,
2224 "<mc> <main | sensor> - fetch either the main or sensor"
2225 " SDRs from the given MC.",
2226 ipmi_cmdlang_mc_handler, mc_sdrs, NULL },
2227 { "get_event_log_enable", &mc_cmds,
2228 " <mc> - Get whether the event log is enabled on the MC.",
2229 ipmi_cmdlang_mc_handler, mc_get_event_log_enable, NULL },
2230 { "set_event_log_enable", &mc_cmds,
2231 " <mc> <on|off> - Set whether the event log is enabled on the MC.",
2232 ipmi_cmdlang_mc_handler, mc_set_event_log_enable, NULL },
2233 { "chan", &mc_cmds,
2234 " Control and information for channels",
2235 NULL, NULL, &mc_chan_cmds },
2236 { "info", &mc_chan_cmds,
2237 "<mc> <channel> - Get information about the channel on the MC.",
2238 ipmi_cmdlang_mc_handler, mc_get_chan_info, NULL },
2239 { "get_access", &mc_chan_cmds,
2240 "<mc> <channel> non-volatile|present|both - Get access info about the"
2241 " channel on the MC. Get either the the non-volatile settings,"
2242 " the current (volatile) settings, or both.",
2243 ipmi_cmdlang_mc_handler, mc_get_chan_access, NULL },
2244 { "set_access", &mc_chan_cmds,
2245 "<mc> <channel> non-volatile|present|both parm value [parm value ...]"
2246 " - Set access info about the channel on the MC. This will read"
2247 " the values and modify the values specified in the parm/value"
2248 " pairs. The parms available are:\n"
2249 " alert true|false\n"
2250 " msg_auth true|false\n"
2251 " user_auth true|false\n"
2252 " access_mode disabled|pre-boot|always|shared\n"
2253 " privilege_limit callback|user|operator|admin|oem\n"
2254 " See the spec for details on what this means.",
2255 ipmi_cmdlang_mc_handler, mc_set_chan_access, NULL },
2256 { "user", &mc_chan_cmds,
2257 "Commands to view manipulate users of a channel",
2258 NULL, NULL, &mc_user_cmds },
2259 { "list", &mc_user_cmds,
2260 "<mc> <channel> [<num>]- List users for the given MC's channel."
2261 " If the user number is given, only list that user, otherwise list"
2262 " all the users",
2263 ipmi_cmdlang_mc_handler, mc_user_list, NULL },
2264 { "set", &mc_user_cmds,
2265 "<mc> <channel> <num> <parm> <value> [<parm> <value> ...] - Set info"
2266 " for the given user number. The parameters are:\n"
2267 " link_enabled true|false\n"
2268 " msg_enabled true|false\n"
2269 " cb_only true|false\n"
2270 " privilege_limit callback|user|operator|admin|oem|no_access\n"
2271 " session_limit <integer>\n"
2272 " name <user name string>\n"
2273 " password <password string, <= 16 characters>\n"
2274 " password2 <password string, <= 20 characters>\n"
2275 " enable\n"
2276 " disable\n"
2277 " Note that setting the session limit to zero means there is no"
2278 " session limit. Also note that some systems have a bug where"
2279 " the session limit is not optional (as the spec says it is)."
2280 " If you get C7 errors back from this command, you will have"
2281 " to always specify the session limit. The password2 option"
2282 " is for IPMI 2.0 passwords that may be up to 20 characters.",
2283 ipmi_cmdlang_mc_handler, mc_user_set, NULL },
2284 };
2285 #define CMDS_MC_LEN (sizeof(cmds_mc)/sizeof(ipmi_cmdlang_init_t))
2286
2287 int
ipmi_cmdlang_mc_init(os_handler_t * os_hnd)2288 ipmi_cmdlang_mc_init(os_handler_t *os_hnd)
2289 {
2290 return ipmi_cmdlang_reg_table(cmds_mc, CMDS_MC_LEN);
2291 }
2292