1 /*
2 * Copyright (C) 2007-2015 FreeIPMI Core Team
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 *
17 */
18
19 #if HAVE_CONFIG_H
20 #include "config.h"
21 #endif /* HAVE_CONFIG_H */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #if STDC_HEADERS
26 #include <string.h>
27 #endif /* STDC_HEADERS */
28 #include <assert.h>
29
30 #include "ipmi-config.h"
31 #include "ipmi-config-map.h"
32 #include "ipmi-config-section.h"
33 #include "ipmi-config-utils.h"
34 #include "ipmi-config-validate.h"
35
36 #include "freeipmi-portability.h"
37 #include "pstdout.h"
38
39 #define IPMI_CONFIG_CATEGORY_PEF_MAXIPADDRLEN 16
40 #define IPMI_CONFIG_CATEGORY_PEF_MAXMACADDRLEN 24
41
42 /* convenience structs */
43 struct destination_type {
44 uint8_t alert_destination_type;
45 uint8_t alert_acknowledge;
46 uint8_t alert_acknowledge_timeout;
47 uint8_t alert_retries;
48 };
49
50 struct destination_addresses {
51 uint8_t alert_gateway;
52 char alert_ip[IPMI_CONFIG_CATEGORY_PEF_MAXIPADDRLEN+1];
53 char alert_mac[IPMI_CONFIG_CATEGORY_PEF_MAXMACADDRLEN+1];
54 };
55
56 static ipmi_config_err_t
_get_destination_type(ipmi_config_state_data_t * state_data,const char * section_name,struct destination_type * dt)57 _get_destination_type (ipmi_config_state_data_t *state_data,
58 const char *section_name,
59 struct destination_type *dt)
60 {
61 fiid_obj_t obj_cmd_rs = NULL;
62 uint64_t val;
63 ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
64 ipmi_config_err_t ret;
65 uint8_t channel_number;
66 uint8_t destination_selector;
67
68 assert (state_data);
69 assert (section_name);
70 assert (dt);
71
72 destination_selector = atoi (section_name + strlen ("Lan_Alert_Destination_"));
73
74 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_lan_configuration_parameters_destination_type_rs)))
75 {
76 pstdout_fprintf (state_data->pstate,
77 stderr,
78 "fiid_obj_create: %s\n",
79 strerror (errno));
80 goto cleanup;
81 }
82
83 if ((ret = get_lan_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
84 {
85 rv = ret;
86 goto cleanup;
87 }
88
89 if (ipmi_cmd_get_lan_configuration_parameters_destination_type (state_data->ipmi_ctx,
90 channel_number,
91 IPMI_GET_LAN_PARAMETER,
92 destination_selector,
93 IPMI_PEF_CONFIGURATION_PARAMETERS_NO_BLOCK_SELECTOR,
94 obj_cmd_rs) < 0)
95 {
96 if (ipmi_config_param_errnum_is_non_fatal (state_data,
97 obj_cmd_rs,
98 &ret))
99 rv = ret;
100
101 if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
102 || state_data->prog_data->args->common_args.debug)
103 pstdout_fprintf (state_data->pstate,
104 stderr,
105 "ipmi_cmd_get_lan_configuration_parameters_destination_type: %s\n",
106 ipmi_ctx_errormsg (state_data->ipmi_ctx));
107
108 goto cleanup;
109 }
110
111 if (FIID_OBJ_GET (obj_cmd_rs, "destination_type", &val) < 0)
112 {
113 pstdout_fprintf (state_data->pstate,
114 stderr,
115 "fiid_obj_get: 'destination_type': %s\n",
116 fiid_obj_errormsg (obj_cmd_rs));
117 goto cleanup;
118 }
119 dt->alert_destination_type = val;
120
121 if (FIID_OBJ_GET (obj_cmd_rs, "alert_acknowledge", &val) < 0)
122 {
123 pstdout_fprintf (state_data->pstate,
124 stderr,
125 "fiid_obj_get: 'alert_acknowledge': %s\n",
126 fiid_obj_errormsg (obj_cmd_rs));
127 goto cleanup;
128 }
129 dt->alert_acknowledge = val;
130
131 if (FIID_OBJ_GET (obj_cmd_rs, "alert_acknowledge_timeout", &val) < 0)
132 {
133 pstdout_fprintf (state_data->pstate,
134 stderr,
135 "fiid_obj_get: 'alert_acknowledge_timeout': %s\n",
136 fiid_obj_errormsg (obj_cmd_rs));
137 goto cleanup;
138 }
139 dt->alert_acknowledge_timeout = val;
140
141 if (FIID_OBJ_GET (obj_cmd_rs, "retries", &val) < 0)
142 {
143 pstdout_fprintf (state_data->pstate,
144 stderr,
145 "fiid_obj_get: 'retries': %s\n",
146 fiid_obj_errormsg (obj_cmd_rs));
147 goto cleanup;
148 }
149 dt->alert_retries = val;
150
151 rv = IPMI_CONFIG_ERR_SUCCESS;
152 cleanup:
153 fiid_obj_destroy (obj_cmd_rs);
154 return (rv);
155 }
156
157 static ipmi_config_err_t
_set_destination_type(ipmi_config_state_data_t * state_data,const char * section_name,struct destination_type * dt)158 _set_destination_type (ipmi_config_state_data_t *state_data,
159 const char *section_name,
160 struct destination_type *dt)
161 {
162 fiid_obj_t obj_cmd_rs = NULL;
163 ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
164 ipmi_config_err_t ret;
165 uint8_t channel_number;
166 uint8_t destination_selector;
167
168 assert (state_data);
169 assert (section_name);
170 assert (dt);
171
172 destination_selector = atoi (section_name + strlen ("Lan_Alert_Destination_"));
173
174 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_lan_configuration_parameters_rs)))
175 {
176 pstdout_fprintf (state_data->pstate,
177 stderr,
178 "fiid_obj_create: %s\n",
179 strerror (errno));
180 goto cleanup;
181 }
182
183 if ((ret = get_lan_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
184 {
185 rv = ret;
186 goto cleanup;
187 }
188
189 if (ipmi_cmd_set_lan_configuration_parameters_destination_type(state_data->ipmi_ctx,
190 channel_number,
191 destination_selector,
192 dt->alert_destination_type,
193 dt->alert_acknowledge,
194 dt->alert_acknowledge_timeout,
195 dt->alert_retries,
196 obj_cmd_rs) < 0)
197 {
198 if (ipmi_config_param_errnum_is_non_fatal (state_data,
199 obj_cmd_rs,
200 &ret))
201 rv = ret;
202
203 if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
204 || state_data->prog_data->args->common_args.debug)
205 pstdout_fprintf (state_data->pstate,
206 stderr,
207 "ipmi_cmd_set_lan_configuration_parameters_destination_type: %s\n",
208 ipmi_ctx_errormsg (state_data->ipmi_ctx));
209
210 goto cleanup;
211 }
212
213 rv = IPMI_CONFIG_ERR_SUCCESS;
214 cleanup:
215 fiid_obj_destroy (obj_cmd_rs);
216 return (rv);
217 }
218
219 static ipmi_config_err_t
alert_destination_type_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)220 alert_destination_type_checkout (ipmi_config_state_data_t *state_data,
221 const char *section_name,
222 struct ipmi_config_keyvalue *kv)
223 {
224 struct destination_type dt;
225 ipmi_config_err_t ret;
226
227 assert (state_data);
228 assert (section_name);
229 assert (kv);
230
231 if ((ret = _get_destination_type (state_data,
232 section_name,
233 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
234 return (ret);
235
236 if (ipmi_config_section_update_keyvalue_output (state_data,
237 kv,
238 alert_destination_type_string (dt.alert_destination_type)) < 0)
239 return (IPMI_CONFIG_ERR_FATAL_ERROR);
240
241 return (IPMI_CONFIG_ERR_SUCCESS);
242 }
243
244 static ipmi_config_err_t
alert_destination_type_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)245 alert_destination_type_commit (ipmi_config_state_data_t *state_data,
246 const char *section_name,
247 const struct ipmi_config_keyvalue *kv)
248 {
249 struct destination_type dt;
250 ipmi_config_err_t ret;
251
252 assert (state_data);
253 assert (section_name);
254 assert (kv);
255
256 if ((ret = _get_destination_type (state_data,
257 section_name,
258 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
259 return (ret);
260
261 dt.alert_destination_type = alert_destination_type_number (kv->value_input);
262
263 return (_set_destination_type (state_data,
264 section_name,
265 &dt));
266 }
267
268 static ipmi_config_err_t
alert_acknowledge_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)269 alert_acknowledge_checkout (ipmi_config_state_data_t *state_data,
270 const char *section_name,
271 struct ipmi_config_keyvalue *kv)
272 {
273 struct destination_type dt;
274 ipmi_config_err_t ret;
275
276 assert (state_data);
277 assert (section_name);
278 assert (kv);
279
280 if ((ret = _get_destination_type (state_data,
281 section_name,
282 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
283 return (ret);
284
285 if (ipmi_config_section_update_keyvalue_output (state_data,
286 kv,
287 dt.alert_acknowledge ? "Yes" : "No") < 0)
288 return (IPMI_CONFIG_ERR_FATAL_ERROR);
289
290 return (IPMI_CONFIG_ERR_SUCCESS);
291 }
292
293 static ipmi_config_err_t
alert_acknowledge_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)294 alert_acknowledge_commit (ipmi_config_state_data_t *state_data,
295 const char *section_name,
296 const struct ipmi_config_keyvalue *kv)
297 {
298 struct destination_type dt;
299 ipmi_config_err_t ret;
300
301 assert (state_data);
302 assert (section_name);
303 assert (kv);
304
305 if ((ret = _get_destination_type (state_data,
306 section_name,
307 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
308 return (ret);
309
310 dt.alert_acknowledge = same (kv->value_input, "yes");
311
312 return (_set_destination_type (state_data,
313 section_name,
314 &dt));
315 }
316
317 static ipmi_config_err_t
alert_acknowledge_timeout_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)318 alert_acknowledge_timeout_checkout (ipmi_config_state_data_t *state_data,
319 const char *section_name,
320 struct ipmi_config_keyvalue *kv)
321 {
322 struct destination_type dt;
323 ipmi_config_err_t ret;
324
325 assert (state_data);
326 assert (section_name);
327 assert (kv);
328
329 if ((ret = _get_destination_type (state_data,
330 section_name,
331 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
332 return (ret);
333
334 if (ipmi_config_section_update_keyvalue_output_unsigned_int (state_data,
335 kv,
336 dt.alert_acknowledge_timeout) < 0)
337 return (IPMI_CONFIG_ERR_FATAL_ERROR);
338
339 return (IPMI_CONFIG_ERR_SUCCESS);
340 }
341
342 static ipmi_config_err_t
alert_acknowledge_timeout_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)343 alert_acknowledge_timeout_commit (ipmi_config_state_data_t *state_data,
344 const char *section_name,
345 const struct ipmi_config_keyvalue *kv)
346 {
347 struct destination_type dt;
348 ipmi_config_err_t ret;
349
350 assert (state_data);
351 assert (section_name);
352 assert (kv);
353
354 if ((ret = _get_destination_type (state_data,
355 section_name,
356 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
357 return (ret);
358
359 dt.alert_acknowledge_timeout = atoi (kv->value_input);
360
361 return (_set_destination_type (state_data,
362 section_name,
363 &dt));
364 }
365
366 static ipmi_config_err_t
alert_retries_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)367 alert_retries_checkout (ipmi_config_state_data_t *state_data,
368 const char *section_name,
369 struct ipmi_config_keyvalue *kv)
370 {
371 struct destination_type dt;
372 ipmi_config_err_t ret;
373
374 assert (state_data);
375 assert (section_name);
376 assert (kv);
377
378 if ((ret = _get_destination_type (state_data,
379 section_name,
380 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
381 return (ret);
382
383 if (ipmi_config_section_update_keyvalue_output_unsigned_int (state_data,
384 kv,
385 dt.alert_retries) < 0)
386 return (IPMI_CONFIG_ERR_FATAL_ERROR);
387
388 return (IPMI_CONFIG_ERR_SUCCESS);
389 }
390
391 static ipmi_config_err_t
alert_retries_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)392 alert_retries_commit (ipmi_config_state_data_t *state_data,
393 const char *section_name,
394 const struct ipmi_config_keyvalue *kv)
395 {
396 struct destination_type dt;
397 ipmi_config_err_t ret;
398
399 assert (state_data);
400 assert (section_name);
401 assert (kv);
402
403 if ((ret = _get_destination_type (state_data,
404 section_name,
405 &dt)) != IPMI_CONFIG_ERR_SUCCESS)
406 return (ret);
407
408 dt.alert_retries = atoi (kv->value_input);
409
410 return (_set_destination_type (state_data,
411 section_name,
412 &dt));
413 }
414
415 ipmi_config_validate_t
alert_retries_validate(ipmi_config_state_data_t * state_data,const char * section_name,const char * key_name,const char * value)416 alert_retries_validate (ipmi_config_state_data_t *state_data,
417 const char *section_name,
418 const char *key_name,
419 const char *value)
420 {
421 assert (state_data);
422 assert (section_name);
423 assert (key_name);
424 assert (value);
425
426 return (check_number_range (value, 0, IPMI_ALERT_RETRIES_MAX));
427 }
428
429 static ipmi_config_err_t
_get_destination_addresses(ipmi_config_state_data_t * state_data,const char * section_name,struct destination_addresses * da)430 _get_destination_addresses (ipmi_config_state_data_t *state_data,
431 const char *section_name,
432 struct destination_addresses *da)
433 {
434 fiid_obj_t obj_cmd_rs = NULL;
435 uint64_t val;
436 uint8_t alert_ip_address_bytes[4];
437 uint8_t alert_mac_address_bytes[6];
438 ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
439 ipmi_config_err_t ret;
440 uint8_t channel_number;
441 uint8_t destination_selector;
442
443 assert (state_data);
444 assert (section_name);
445 assert (da);
446
447 destination_selector = atoi (section_name + strlen ("Lan_Alert_Destination_"));
448
449 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_lan_configuration_parameters_destination_addresses_rs)))
450 {
451 pstdout_fprintf (state_data->pstate,
452 stderr,
453 "fiid_obj_create: %s\n",
454 strerror (errno));
455 goto cleanup;
456 }
457
458 if ((ret = get_lan_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
459 {
460 rv = ret;
461 goto cleanup;
462 }
463
464 if (ipmi_cmd_get_lan_configuration_parameters_destination_addresses(state_data->ipmi_ctx,
465 channel_number,
466 IPMI_GET_LAN_PARAMETER,
467 destination_selector,
468 IPMI_PEF_CONFIGURATION_PARAMETERS_NO_BLOCK_SELECTOR,
469 obj_cmd_rs) < 0)
470 {
471 if (ipmi_config_param_errnum_is_non_fatal (state_data,
472 obj_cmd_rs,
473 &ret))
474 rv = ret;
475
476 if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
477 || state_data->prog_data->args->common_args.debug)
478 pstdout_fprintf (state_data->pstate,
479 stderr,
480 "ipmi_cmd_get_lan_configuration_parameters_destination_addresses: %s\n",
481 ipmi_ctx_errormsg (state_data->ipmi_ctx));
482
483 goto cleanup;
484 }
485
486 if (FIID_OBJ_GET (obj_cmd_rs, "gateway_selector", &val) < 0)
487 {
488 pstdout_fprintf (state_data->pstate,
489 stderr,
490 "fiid_obj_get: 'gateway_selector': %s\n",
491 fiid_obj_errormsg (obj_cmd_rs));
492 goto cleanup;
493 }
494 da->alert_gateway = val;
495
496 if (fiid_obj_get_data (obj_cmd_rs,
497 "alerting_ip_address",
498 alert_ip_address_bytes,
499 4) < 0)
500 {
501 pstdout_fprintf (state_data->pstate,
502 stderr,
503 "fiid_obj_get_data: 'alerting_ip_address': %s\n",
504 fiid_obj_errormsg (obj_cmd_rs));
505 goto cleanup;
506 }
507
508 memset (da->alert_ip, '\0', IPMI_CONFIG_CATEGORY_PEF_MAXIPADDRLEN+1);
509 snprintf (da->alert_ip,
510 IPMI_CONFIG_CATEGORY_PEF_MAXIPADDRLEN,
511 "%u.%u.%u.%u",
512 alert_ip_address_bytes[0],
513 alert_ip_address_bytes[1],
514 alert_ip_address_bytes[2],
515 alert_ip_address_bytes[3]);
516
517 if (fiid_obj_get_data (obj_cmd_rs,
518 "alerting_mac_address",
519 alert_mac_address_bytes,
520 6) < 0)
521 {
522 pstdout_fprintf (state_data->pstate,
523 stderr,
524 "fiid_obj_get_data: 'alerting_mac_address': %s\n",
525 fiid_obj_errormsg (obj_cmd_rs));
526 goto cleanup;
527 }
528
529 memset (da->alert_mac, '\0', IPMI_CONFIG_CATEGORY_PEF_MAXMACADDRLEN+1);
530 snprintf (da->alert_mac,
531 IPMI_CONFIG_CATEGORY_PEF_MAXMACADDRLEN,
532 "%02X:%02X:%02X:%02X:%02X:%02X",
533 alert_mac_address_bytes[0],
534 alert_mac_address_bytes[1],
535 alert_mac_address_bytes[2],
536 alert_mac_address_bytes[3],
537 alert_mac_address_bytes[4],
538 alert_mac_address_bytes[5]);
539
540 rv = IPMI_CONFIG_ERR_SUCCESS;
541 cleanup:
542 fiid_obj_destroy (obj_cmd_rs);
543 return (rv);
544 }
545
546 static ipmi_config_err_t
_set_destination_addresses(ipmi_config_state_data_t * state_data,const char * section_name,struct destination_addresses * da)547 _set_destination_addresses (ipmi_config_state_data_t *state_data,
548 const char *section_name,
549 struct destination_addresses *da)
550 {
551 fiid_obj_t obj_cmd_rs = NULL;
552 uint32_t alert_ip_address_val = 0;
553 uint64_t alert_mac_address_val = 0;
554 ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
555 ipmi_config_err_t ret;
556 uint8_t channel_number;
557 uint8_t destination_selector;
558
559 assert (state_data);
560 assert (section_name);
561 assert (da);
562
563 destination_selector = atoi (section_name + strlen ("Lan_Alert_Destination_"));
564
565 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_lan_configuration_parameters_rs)))
566 {
567 pstdout_fprintf (state_data->pstate,
568 stderr,
569 "fiid_obj_create: %s\n",
570 strerror (errno));
571 goto cleanup;
572 }
573
574 if ((ret = get_lan_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
575 {
576 rv = ret;
577 goto cleanup;
578 }
579
580 if (ipv4_address_string2int (state_data,
581 da->alert_ip,
582 &alert_ip_address_val) < 0)
583 goto cleanup;
584
585 if (mac_address_string2int (state_data,
586 da->alert_mac,
587 &alert_mac_address_val) < 0)
588 goto cleanup;
589
590 if (ipmi_cmd_set_lan_configuration_parameters_destination_addresses (state_data->ipmi_ctx,
591 channel_number,
592 destination_selector,
593 da->alert_gateway,
594 alert_ip_address_val,
595 alert_mac_address_val,
596 obj_cmd_rs) < 0)
597 {
598 if (ipmi_config_param_errnum_is_non_fatal (state_data,
599 obj_cmd_rs,
600 &ret))
601 rv = ret;
602
603 if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
604 || state_data->prog_data->args->common_args.debug)
605 pstdout_fprintf (state_data->pstate,
606 stderr,
607 "ipmi_cmd_set_lan_configuration_parameters_destination_addresses: %s\n",
608 ipmi_ctx_errormsg (state_data->ipmi_ctx));
609
610 goto cleanup;
611 }
612
613 rv = IPMI_CONFIG_ERR_SUCCESS;
614 cleanup:
615 fiid_obj_destroy (obj_cmd_rs);
616 return (rv);
617 }
618
619 static ipmi_config_err_t
alert_gateway_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)620 alert_gateway_checkout (ipmi_config_state_data_t *state_data,
621 const char *section_name,
622 struct ipmi_config_keyvalue *kv)
623 {
624 struct destination_addresses da;
625 ipmi_config_err_t ret;
626
627 assert (state_data);
628 assert (section_name);
629 assert (kv);
630
631 if ((ret = _get_destination_addresses (state_data,
632 section_name,
633 &da)) != IPMI_CONFIG_ERR_SUCCESS)
634 return (ret);
635
636 if (ipmi_config_section_update_keyvalue_output (state_data,
637 kv,
638 alert_gateway_string (da.alert_gateway)) < 0)
639 return (IPMI_CONFIG_ERR_FATAL_ERROR);
640
641 return (IPMI_CONFIG_ERR_SUCCESS);
642 }
643
644 static ipmi_config_err_t
alert_gateway_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)645 alert_gateway_commit (ipmi_config_state_data_t *state_data,
646 const char *section_name,
647 const struct ipmi_config_keyvalue *kv)
648 {
649 struct destination_addresses da;
650 ipmi_config_err_t ret;
651
652 assert (state_data);
653 assert (section_name);
654 assert (kv);
655
656 if ((ret = _get_destination_addresses (state_data,
657 section_name,
658 &da)) != IPMI_CONFIG_ERR_SUCCESS)
659 return (ret);
660
661 da.alert_gateway = alert_gateway_number (kv->value_input);
662
663 return (_set_destination_addresses (state_data,
664 section_name,
665 &da));
666 }
667
668 static ipmi_config_err_t
alert_ip_address_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)669 alert_ip_address_checkout (ipmi_config_state_data_t *state_data,
670 const char *section_name,
671 struct ipmi_config_keyvalue *kv)
672 {
673 struct destination_addresses da;
674 ipmi_config_err_t ret;
675
676 assert (state_data);
677 assert (section_name);
678 assert (kv);
679
680 if ((ret = _get_destination_addresses (state_data,
681 section_name,
682 &da)) != IPMI_CONFIG_ERR_SUCCESS)
683 return (ret);
684
685 if (ipmi_config_section_update_keyvalue_output (state_data,
686 kv,
687 da.alert_ip) < 0)
688 return (IPMI_CONFIG_ERR_FATAL_ERROR);
689
690 return (IPMI_CONFIG_ERR_SUCCESS);
691 }
692
693 static ipmi_config_err_t
alert_ip_address_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)694 alert_ip_address_commit (ipmi_config_state_data_t *state_data,
695 const char *section_name,
696 const struct ipmi_config_keyvalue *kv)
697 {
698 struct destination_addresses da;
699 ipmi_config_err_t ret;
700
701 assert (state_data);
702 assert (section_name);
703 assert (kv);
704
705 if ((ret = _get_destination_addresses (state_data,
706 section_name,
707 &da)) != IPMI_CONFIG_ERR_SUCCESS)
708 return (ret);
709
710 /* length checked earlier during validation */
711 strcpy (da.alert_ip, kv->value_input);
712
713 return (_set_destination_addresses (state_data,
714 section_name,
715 &da));
716 }
717
718 static ipmi_config_err_t
alert_mac_address_checkout(ipmi_config_state_data_t * state_data,const char * section_name,struct ipmi_config_keyvalue * kv)719 alert_mac_address_checkout (ipmi_config_state_data_t *state_data,
720 const char *section_name,
721 struct ipmi_config_keyvalue *kv)
722 {
723 struct destination_addresses da;
724 ipmi_config_err_t ret;
725
726 assert (state_data);
727 assert (section_name);
728 assert (kv);
729
730 if ((ret = _get_destination_addresses (state_data,
731 section_name,
732 &da)) != IPMI_CONFIG_ERR_SUCCESS)
733 return (ret);
734
735 if (ipmi_config_section_update_keyvalue_output (state_data,
736 kv,
737 da.alert_mac) < 0)
738 return (IPMI_CONFIG_ERR_FATAL_ERROR);
739
740 return (IPMI_CONFIG_ERR_SUCCESS);
741 }
742
743 static ipmi_config_err_t
alert_mac_address_commit(ipmi_config_state_data_t * state_data,const char * section_name,const struct ipmi_config_keyvalue * kv)744 alert_mac_address_commit (ipmi_config_state_data_t *state_data,
745 const char *section_name,
746 const struct ipmi_config_keyvalue *kv)
747 {
748 struct destination_addresses da;
749 ipmi_config_err_t ret;
750
751 assert (state_data);
752 assert (section_name);
753 assert (kv);
754
755 if ((ret = _get_destination_addresses (state_data,
756 section_name,
757 &da)) != IPMI_CONFIG_ERR_SUCCESS)
758 return (ret);
759
760 /* length checked earlier during validation */
761 strcpy (da.alert_mac, kv->value_input);
762
763 return (_set_destination_addresses (state_data,
764 section_name,
765 &da));
766 }
767
768 struct ipmi_config_section *
ipmi_config_pef_lan_alert_destination_section_get(ipmi_config_state_data_t * state_data,unsigned int num,unsigned int config_flags,int channel_index)769 ipmi_config_pef_lan_alert_destination_section_get (ipmi_config_state_data_t *state_data,
770 unsigned int num,
771 unsigned int config_flags,
772 int channel_index)
773 {
774 struct ipmi_config_section *section = NULL;
775 char section_name_base[IPMI_CONFIG_MAX_SECTION_NAME_LEN];
776
777 assert (state_data);
778
779 snprintf (section_name_base, IPMI_CONFIG_MAX_SECTION_NAME_LEN, "Lan_Alert_Destination_%u", num);
780
781 if (!(section = ipmi_config_section_multi_channel_create (state_data,
782 section_name_base,
783 NULL,
784 NULL,
785 NULL,
786 config_flags,
787 channel_index,
788 state_data->lan_channel_numbers,
789 state_data->lan_channel_numbers_count)))
790 goto cleanup;
791
792 if (ipmi_config_section_add_key (state_data,
793 section,
794 "Alert_Destination_Type",
795 "Possible values: PET_Trap/OEM1/OEM2",
796 0,
797 alert_destination_type_checkout,
798 alert_destination_type_commit,
799 alert_destination_type_validate) < 0)
800 goto cleanup;
801
802 if (ipmi_config_section_add_key (state_data,
803 section,
804 "Alert_Acknowledge",
805 "Possible values: Yes/No",
806 0,
807 alert_acknowledge_checkout,
808 alert_acknowledge_commit,
809 yes_no_validate) < 0)
810 goto cleanup;
811
812 if (ipmi_config_section_add_key (state_data,
813 section,
814 "Alert_Acknowledge_Timeout",
815 "Give valid unsigned number in seconds",
816 0,
817 alert_acknowledge_timeout_checkout,
818 alert_acknowledge_timeout_commit,
819 number_range_one_byte_validate) < 0)
820 goto cleanup;
821
822 if (ipmi_config_section_add_key (state_data,
823 section,
824 "Alert_Retries",
825 "Give valid unsigned number",
826 0,
827 alert_retries_checkout,
828 alert_retries_commit,
829 alert_retries_validate) < 0)
830 goto cleanup;
831
832 if (ipmi_config_section_add_key (state_data,
833 section,
834 "Alert_Gateway",
835 "Possible values: Default/Backup",
836 0,
837 alert_gateway_checkout,
838 alert_gateway_commit,
839 alert_gateway_validate) < 0)
840 goto cleanup;
841
842 if (ipmi_config_section_add_key (state_data,
843 section,
844 "Alert_IP_Address",
845 "Give valid IP address",
846 0,
847 alert_ip_address_checkout,
848 alert_ip_address_commit,
849 ip_address_validate) < 0)
850 goto cleanup;
851
852 if (ipmi_config_section_add_key (state_data,
853 section,
854 "Alert_MAC_Address",
855 "Give valid MAC address",
856 0,
857 alert_mac_address_checkout,
858 alert_mac_address_commit,
859 mac_address_validate) < 0)
860 goto cleanup;
861
862 return (section);
863
864 cleanup:
865 if (section)
866 ipmi_config_section_destroy (section);
867 return (NULL);
868 }
869
870