← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/openipmi/intrepid

« back to all changes in this revision

Viewing changes to cmdlang/cmd_control.c

  • Committer: Bazaar Package Importer
  • Author(s): Noèl Köthe
  • Date: 2005-07-04 21:29:17 UTC
  • Revision ID: james.westby@ubuntu.com-20050704212917-igddk5jawjmhrlay
Tags: upstream-2.0.1
Import upstream version 2.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmdlang/cmd_control.c
 
1
/*
 
2
 * cmd_control.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
 
 
42
/* Internal includes, do not use in your programs */
 
43
#include <OpenIPMI/internal/ipmi_malloc.h>
 
44
 
 
45
static void
 
46
control_list_handler(ipmi_entity_t *entity, ipmi_control_t *control,
 
47
                     void *cb_data)
 
48
{
 
49
    ipmi_cmd_info_t *cmd_info = cb_data;
 
50
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
51
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
52
 
 
53
    if (cmdlang->err)
 
54
        return;
 
55
 
 
56
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
57
 
 
58
    ipmi_cmdlang_out(cmd_info, "Name", control_name);
 
59
}
 
60
 
 
61
static void
 
62
control_list(ipmi_entity_t *entity, void *cb_data)
 
63
{
 
64
    ipmi_cmd_info_t *cmd_info = cb_data;
 
65
    char            entity_name[IPMI_ENTITY_NAME_LEN];
 
66
 
 
67
    ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
 
68
    ipmi_cmdlang_out(cmd_info, "Entity", NULL);
 
69
    ipmi_cmdlang_down(cmd_info);
 
70
    ipmi_cmdlang_out(cmd_info, "Name", entity_name);
 
71
    ipmi_cmdlang_out(cmd_info, "Controls", NULL);
 
72
    ipmi_cmdlang_down(cmd_info);
 
73
    ipmi_entity_iterate_controls(entity, control_list_handler, cmd_info);
 
74
    ipmi_cmdlang_up(cmd_info);
 
75
    ipmi_cmdlang_up(cmd_info);
 
76
}
 
77
 
 
78
static void
 
79
control_dump(ipmi_control_t *control, ipmi_cmd_info_t *cmd_info)
 
80
{
 
81
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
82
    int             num;
 
83
    char            *str;
 
84
    int             len;
 
85
    int             val, val2, val3;
 
86
    int             i, j, k;
 
87
 
 
88
    ipmi_cmdlang_out(cmd_info, "Type", ipmi_control_get_type_string(control));
 
89
    ipmi_cmdlang_out_bool(cmd_info, "Generates events",
 
90
                          ipmi_control_has_events(control));
 
91
    ipmi_cmdlang_out_bool(cmd_info, "Settable",
 
92
                          ipmi_control_is_settable(control));
 
93
    ipmi_cmdlang_out_bool(cmd_info, "Readable",
 
94
                          ipmi_control_is_readable(control));
 
95
    num = ipmi_control_get_num_vals(control);
 
96
    ipmi_cmdlang_out_int(cmd_info, "Num Values", num);
 
97
    len = ipmi_control_get_id_length(control);
 
98
    if (len) {
 
99
        str = ipmi_mem_alloc(len);
 
100
        if (!str) {
 
101
            cmdlang->err = ENOMEM;
 
102
            cmdlang->errstr = "Out of memory";
 
103
            goto out_err;
 
104
        }
 
105
        len = ipmi_control_get_id(control, str, len);
 
106
        ipmi_cmdlang_out_type(cmd_info, "Id",
 
107
                              ipmi_control_get_id_type(control),
 
108
                              str, len);
 
109
        ipmi_mem_free(str);
 
110
    }
 
111
 
 
112
    switch (ipmi_control_get_type(control)) {
 
113
    case IPMI_CONTROL_LIGHT:
 
114
        val = ipmi_control_light_set_with_setting(control);
 
115
        if (val) {
 
116
            ipmi_cmdlang_out(cmd_info, "Set with", "settings");
 
117
            val = ipmi_control_light_has_local_control(control);
 
118
            ipmi_cmdlang_out_bool(cmd_info, "Local Control", val);
 
119
            for (i=IPMI_CONTROL_COLOR_BLACK; i<IPMI_CONTROL_COLOR_ORANGE; i++){
 
120
                val = ipmi_control_light_is_color_supported(control, i);
 
121
                if (val)
 
122
                    ipmi_cmdlang_out(cmd_info, "Color",
 
123
                                     ipmi_get_color_string(i));
 
124
            }
 
125
        } else {
 
126
            ipmi_cmdlang_out(cmd_info, "Set with", "transitions");
 
127
            for (i=0; i<num; i++) {
 
128
                ipmi_cmdlang_out(cmd_info, "Light", NULL);
 
129
                ipmi_cmdlang_down(cmd_info);
 
130
                ipmi_cmdlang_out_int(cmd_info, "Number", i);
 
131
                val = ipmi_control_get_num_light_values(control, i);
 
132
                ipmi_cmdlang_out_int(cmd_info, "Num Values", val);
 
133
                for (j=0; j<val; j++) {
 
134
                    ipmi_cmdlang_out(cmd_info, "Value", NULL);
 
135
                    ipmi_cmdlang_down(cmd_info);
 
136
                    ipmi_cmdlang_out_int(cmd_info, "Number", j);
 
137
                    val2 = ipmi_control_get_num_light_transitions(control,
 
138
                                                                  i, j);
 
139
                    ipmi_cmdlang_out_int(cmd_info, "Num Transitions", val2);
 
140
                    for (k=0; k<val2; k++) {
 
141
                        ipmi_cmdlang_out(cmd_info, "Transition", NULL);
 
142
                        ipmi_cmdlang_down(cmd_info);
 
143
                        ipmi_cmdlang_out_int(cmd_info, "Number", k);
 
144
                        val3 = ipmi_control_get_light_color(control, i, j, k);
 
145
                        ipmi_cmdlang_out(cmd_info, "Color",
 
146
                                         ipmi_get_color_string(val3));
 
147
                        ipmi_cmdlang_out_int(cmd_info, "Time",
 
148
                                             ipmi_control_get_light_color_time
 
149
                                             (control, i, j, k));
 
150
                        ipmi_cmdlang_up(cmd_info);
 
151
                    }
 
152
                    ipmi_cmdlang_up(cmd_info);
 
153
                }
 
154
                ipmi_cmdlang_up(cmd_info);
 
155
            }
 
156
        }
 
157
        break;
 
158
 
 
159
    case IPMI_CONTROL_IDENTIFIER:
 
160
        ipmi_cmdlang_out_int(cmd_info, "Max Length",
 
161
                             ipmi_control_identifier_get_max_length(control));
 
162
        break;
 
163
 
 
164
    case IPMI_CONTROL_DISPLAY:
 
165
        break;
 
166
 
 
167
    case IPMI_CONTROL_RELAY:
 
168
    case IPMI_CONTROL_ALARM:
 
169
    case IPMI_CONTROL_RESET:
 
170
    case IPMI_CONTROL_POWER:
 
171
    case IPMI_CONTROL_FAN_SPEED:
 
172
    case IPMI_CONTROL_ONE_SHOT_RESET:
 
173
    case IPMI_CONTROL_OUTPUT:
 
174
    case IPMI_CONTROL_ONE_SHOT_OUTPUT:
 
175
        break;
 
176
    }
 
177
    return;
 
178
 
 
179
 out_err:
 
180
    ipmi_control_get_name(control, cmdlang->objstr,
 
181
                         cmdlang->objstr_len);
 
182
    cmdlang->location = "cmd_control.c(control_dump)";
 
183
}
 
184
 
 
185
static void
 
186
control_info(ipmi_control_t *control, void *cb_data)
 
187
{
 
188
    ipmi_cmd_info_t *cmd_info = cb_data;
 
189
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
190
 
 
191
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
192
 
 
193
    ipmi_cmdlang_out(cmd_info, "Control", NULL);
 
194
    ipmi_cmdlang_down(cmd_info);
 
195
    ipmi_cmdlang_out(cmd_info, "Name", control_name);
 
196
    control_dump(control, cmd_info);
 
197
    ipmi_cmdlang_up(cmd_info);
 
198
}
 
199
 
 
200
static void
 
201
control_set_done(ipmi_control_t *control,
 
202
                 int            err,
 
203
                 void           *cb_data)
 
204
{
 
205
    ipmi_cmd_info_t *cmd_info = cb_data;
 
206
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
207
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
208
 
 
209
    ipmi_cmdlang_lock(cmd_info);
 
210
    if (err) {
 
211
        cmdlang->errstr = "Error setting control";
 
212
        cmdlang->err = err;
 
213
        ipmi_control_get_name(control, cmdlang->objstr,
 
214
                              cmdlang->objstr_len);
 
215
        cmdlang->location = "cmd_control.c(control_set_done)";
 
216
        goto out;
 
217
    }
 
218
 
 
219
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
220
    ipmi_cmdlang_out(cmd_info, "Set done", control_name);
 
221
 
 
222
 out:
 
223
    ipmi_cmdlang_unlock(cmd_info);
 
224
    ipmi_cmdlang_cmd_info_put(cmd_info);
 
225
}
 
226
 
 
227
static void
 
228
control_set(ipmi_control_t *control, void *cb_data)
 
229
{
 
230
    ipmi_cmd_info_t      *cmd_info = cb_data;
 
231
    ipmi_cmdlang_t       *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
232
    int                  *data = NULL;
 
233
    unsigned char        *ucdata = NULL;
 
234
    int                  num;
 
235
    int                  i;
 
236
    int                  rv;
 
237
    int                  curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
 
238
    int                  argc = ipmi_cmdlang_get_argc(cmd_info);
 
239
    char                 **argv = ipmi_cmdlang_get_argv(cmd_info);
 
240
    ipmi_light_setting_t *s = NULL;
 
241
 
 
242
 
 
243
    num = ipmi_control_get_num_vals(control);
 
244
    if ((argc - curr_arg) < num) {
 
245
        /* Not enough parameters */
 
246
        cmdlang->errstr = "Not enough parameters";
 
247
        cmdlang->err = EINVAL;
 
248
        goto out_err;
 
249
    }
 
250
 
 
251
    switch (ipmi_control_get_type(control)) {
 
252
    case IPMI_CONTROL_LIGHT:
 
253
        if (!ipmi_control_light_set_with_setting(control))
 
254
            goto normal_val_set;
 
255
 
 
256
        s = ipmi_alloc_light_settings(num);
 
257
        if (!s) {
 
258
            cmdlang->errstr = "Out of memory";
 
259
            cmdlang->err = ENOMEM;
 
260
            goto out_err;
 
261
        }
 
262
 
 
263
        for (i=0; i<num; i++) {
 
264
            int val;
 
265
 
 
266
            if (strcmp(argv[curr_arg], "lc") == 0) {
 
267
                ipmi_light_setting_set_local_control(s, i, 1);
 
268
                continue;
 
269
            } else if (strcmp(argv[curr_arg], "nolc") == 0) {
 
270
                ipmi_light_setting_set_local_control(s, i, 0);
 
271
            } else {
 
272
                cmdlang->errstr = "Invalid local control setting";
 
273
                cmdlang->err = EINVAL;
 
274
                goto out_err;
 
275
            }
 
276
            curr_arg++;
 
277
 
 
278
            ipmi_cmdlang_get_color(argv[curr_arg], &val, cmd_info);
 
279
            if (cmdlang->err)
 
280
                goto out_err;
 
281
            rv = ipmi_light_setting_set_color(s, i, val);
 
282
            if (rv) {
 
283
                cmdlang->errstr = "Error setting color";
 
284
                cmdlang->err = rv;
 
285
                goto out_err;
 
286
            }
 
287
            curr_arg++;
 
288
 
 
289
            ipmi_cmdlang_get_int(argv[curr_arg], &val, cmd_info);
 
290
            if (cmdlang->err) {
 
291
                cmdlang->errstr = "Invalid on time";
 
292
                goto out_err;
 
293
            }
 
294
            rv = ipmi_light_setting_set_on_time(s, i, val);
 
295
            if (rv) {
 
296
                cmdlang->errstr = "Error setting on time";
 
297
                cmdlang->err = rv;
 
298
                goto out_err;
 
299
            }
 
300
            curr_arg++;
 
301
 
 
302
            ipmi_cmdlang_get_int(argv[curr_arg], &val, cmd_info);
 
303
            if (cmdlang->err) {
 
304
                cmdlang->errstr = "Invalid off time";
 
305
                goto out_err;
 
306
            }
 
307
            rv = ipmi_light_setting_set_off_time(s, i, val);
 
308
            if (rv) {
 
309
                cmdlang->errstr = "Error setting off time";
 
310
                cmdlang->err = rv;
 
311
                goto out_err;
 
312
            }
 
313
            curr_arg++;
 
314
        }
 
315
 
 
316
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
317
        rv = ipmi_control_set_light(control, s, control_set_done,
 
318
                                    cmd_info);
 
319
        if (rv) {
 
320
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
321
            cmdlang->errstr = "Error setting light control";
 
322
            cmdlang->err = rv;
 
323
            goto out_err;
 
324
        }
 
325
        ipmi_free_light_settings(s);
 
326
        break;
 
327
 
 
328
    case IPMI_CONTROL_IDENTIFIER:
 
329
        num = ipmi_control_identifier_get_max_length(control);
 
330
        ucdata = ipmi_mem_alloc(num);
 
331
        if (!ucdata) {
 
332
            cmdlang->errstr = "Out of memory";
 
333
            cmdlang->err = ENOMEM;
 
334
            goto out_err;
 
335
        }
 
336
        for (i=0; i<num; i++) {
 
337
            ipmi_cmdlang_get_uchar(argv[curr_arg], &ucdata[i], cmd_info);
 
338
            if (cmdlang->err) {
 
339
                cmdlang->errstr = "value invalid";
 
340
                goto out_err;
 
341
            }
 
342
            curr_arg++;
 
343
        }
 
344
        
 
345
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
346
        rv = ipmi_control_identifier_set_val(control, ucdata, i,
 
347
                                             control_set_done, cmd_info);
 
348
        if (rv) {
 
349
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
350
            cmdlang->errstr = "Error setting id control";
 
351
            cmdlang->err = rv;
 
352
            goto out_err;
 
353
        }
 
354
        ipmi_mem_free(ucdata);
 
355
        break;
 
356
 
 
357
    case IPMI_CONTROL_DISPLAY:
 
358
        cmdlang->errstr = "Setting displays not currently supported";
 
359
        cmdlang->err = ENOSYS;
 
360
        goto out_err;
 
361
        break;
 
362
 
 
363
    case IPMI_CONTROL_RELAY:
 
364
    case IPMI_CONTROL_ALARM:
 
365
    case IPMI_CONTROL_RESET:
 
366
    case IPMI_CONTROL_POWER:
 
367
    case IPMI_CONTROL_FAN_SPEED:
 
368
    case IPMI_CONTROL_ONE_SHOT_RESET:
 
369
    case IPMI_CONTROL_OUTPUT:
 
370
    case IPMI_CONTROL_ONE_SHOT_OUTPUT:
 
371
    normal_val_set:
 
372
        data = ipmi_mem_alloc(num * sizeof(int));
 
373
        if (!data) {
 
374
            cmdlang->errstr = "Out of memory";
 
375
            cmdlang->err = ENOMEM;
 
376
            goto out_err;
 
377
        }
 
378
        for (i=0; i<num; i++) {
 
379
            ipmi_cmdlang_get_int(argv[curr_arg], &data[i], cmd_info);
 
380
            if (cmdlang->err) {
 
381
                cmdlang->errstr = "value invalid";
 
382
                goto out_err;
 
383
            }
 
384
            curr_arg++;
 
385
        }
 
386
 
 
387
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
388
        rv = ipmi_control_set_val(control, data, control_set_done, cmd_info);
 
389
        if (rv) {
 
390
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
391
            cmdlang->errstr = "Error setting control";
 
392
            cmdlang->err = rv;
 
393
            goto out_err;
 
394
        }
 
395
        ipmi_mem_free(data);
 
396
        break;
 
397
    }
 
398
    return;
 
399
 
 
400
 out_err:
 
401
    ipmi_control_get_name(control, cmdlang->objstr,
 
402
                         cmdlang->objstr_len);
 
403
    cmdlang->location = "cmd_control.c(control_set)";
 
404
    if (s)
 
405
        ipmi_free_light_settings(s);
 
406
    if (ucdata)
 
407
        ipmi_mem_free(ucdata);
 
408
    if (data)
 
409
        ipmi_mem_free(data);
 
410
}
 
411
 
 
412
static void
 
413
control_get_light_done(ipmi_control_t       *control,
 
414
                       int                  err,
 
415
                       ipmi_light_setting_t *s,
 
416
                       void                 *cb_data)
 
417
{
 
418
    ipmi_cmd_info_t *cmd_info = cb_data;
 
419
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
420
    int             i, num;
 
421
    int             rv;
 
422
 
 
423
    ipmi_cmdlang_lock(cmd_info);
 
424
    if (err) {
 
425
        cmdlang->errstr = "Error setting control";
 
426
        cmdlang->err = err;
 
427
        goto out;
 
428
    }
 
429
 
 
430
    num = ipmi_light_setting_get_count(s);
 
431
    for (i=0; i<num; i++) {
 
432
        int val;
 
433
 
 
434
        ipmi_cmdlang_out(cmd_info, "Light", NULL);
 
435
        ipmi_cmdlang_down(cmd_info);
 
436
        ipmi_cmdlang_out_int(cmd_info, "Num", i);
 
437
        rv = ipmi_light_setting_in_local_control(s, i, &val);
 
438
        if (rv) {
 
439
            cmdlang->errstr = "Error getting if in local control";
 
440
            cmdlang->err = rv;
 
441
            goto out;
 
442
        }
 
443
        ipmi_cmdlang_out_bool(cmd_info, "Local Control", val);
 
444
        if (!val) {
 
445
            rv = ipmi_light_setting_get_color(s, i, &val);
 
446
            if (rv) {
 
447
                cmdlang->errstr = "Error getting color";
 
448
                cmdlang->err = rv;
 
449
                goto out;
 
450
            }
 
451
            ipmi_cmdlang_out(cmd_info, "Color", ipmi_get_color_string(val));
 
452
 
 
453
            rv = ipmi_light_setting_get_on_time(s, i, &val);
 
454
            if (rv) {
 
455
                cmdlang->errstr = "Error getting on time";
 
456
                cmdlang->err = rv;
 
457
                goto out;
 
458
            }
 
459
            ipmi_cmdlang_out_int(cmd_info, "On Time", val);
 
460
 
 
461
            rv = ipmi_light_setting_get_off_time(s, i, &val);
 
462
            if (rv) {
 
463
                cmdlang->errstr = "Error getting off time";
 
464
                cmdlang->err = rv;
 
465
                goto out;
 
466
            }
 
467
            ipmi_cmdlang_out_int(cmd_info, "Off Time", val);
 
468
        }
 
469
        ipmi_cmdlang_up(cmd_info);
 
470
    }
 
471
 
 
472
 out:
 
473
    if (cmdlang->err) {
 
474
        ipmi_control_get_name(control, cmdlang->objstr,
 
475
                              cmdlang->objstr_len);
 
476
        cmdlang->location = "cmd_control.c(control_get_light_done)";
 
477
    }
 
478
    ipmi_cmdlang_unlock(cmd_info);
 
479
    ipmi_cmdlang_cmd_info_put(cmd_info);
 
480
}
 
481
 
 
482
static void
 
483
control_get_id_done(ipmi_control_t *control,
 
484
                    int            err,
 
485
                    unsigned char  *val,
 
486
                    int            length,
 
487
                    void           *cb_data)
 
488
{
 
489
    ipmi_cmd_info_t *cmd_info = cb_data;
 
490
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
491
 
 
492
    ipmi_cmdlang_lock(cmd_info);
 
493
    if (err) {
 
494
        cmdlang->errstr = "Error setting control";
 
495
        cmdlang->err = err;
 
496
        goto out;
 
497
    }
 
498
 
 
499
    ipmi_cmdlang_out_binary(cmd_info, "Data", val, length);
 
500
 
 
501
 out:
 
502
    if (cmdlang->err) {
 
503
        ipmi_control_get_name(control, cmdlang->objstr,
 
504
                              cmdlang->objstr_len);
 
505
        cmdlang->location = "cmd_control.c(control_get_light_done)";
 
506
    }
 
507
    ipmi_cmdlang_unlock(cmd_info);
 
508
    ipmi_cmdlang_cmd_info_put(cmd_info);
 
509
}
 
510
 
 
511
static void
 
512
control_get_done(ipmi_control_t *control,
 
513
                 int            err,
 
514
                 int            *val,
 
515
                 void           *cb_data)
 
516
{
 
517
    ipmi_cmd_info_t *cmd_info = cb_data;
 
518
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
519
    int             i, num;
 
520
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
521
 
 
522
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
523
 
 
524
    ipmi_cmdlang_lock(cmd_info);
 
525
    if (err) {
 
526
        cmdlang->errstr = "Error setting control";
 
527
        cmdlang->err = err;
 
528
        goto out;
 
529
    }
 
530
 
 
531
    ipmi_cmdlang_out(cmd_info, "Control", NULL);
 
532
    ipmi_cmdlang_down(cmd_info);
 
533
    ipmi_cmdlang_out(cmd_info, "Name", control_name);
 
534
    num = ipmi_control_get_num_vals(control);
 
535
    for (i=0; i<num; i++) {
 
536
        ipmi_cmdlang_out(cmd_info, "Value", NULL);
 
537
        ipmi_cmdlang_down(cmd_info);
 
538
        ipmi_cmdlang_out_int(cmd_info, "Num", i);
 
539
        ipmi_cmdlang_out_int(cmd_info, "Value", val[i]);
 
540
        ipmi_cmdlang_up(cmd_info);
 
541
    }
 
542
    ipmi_cmdlang_up(cmd_info);
 
543
 
 
544
 out:
 
545
    if (cmdlang->err) {
 
546
        ipmi_control_get_name(control, cmdlang->objstr,
 
547
                              cmdlang->objstr_len);
 
548
        cmdlang->location = "cmd_control.c(control_get_light_done)";
 
549
    }
 
550
    ipmi_cmdlang_unlock(cmd_info);
 
551
    ipmi_cmdlang_cmd_info_put(cmd_info);
 
552
}
 
553
 
 
554
static void
 
555
control_get(ipmi_control_t *control, void *cb_data)
 
556
{
 
557
    ipmi_cmd_info_t      *cmd_info = cb_data;
 
558
    ipmi_cmdlang_t       *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
 
559
    int                  rv;
 
560
 
 
561
 
 
562
    switch (ipmi_control_get_type(control)) {
 
563
    case IPMI_CONTROL_LIGHT:
 
564
        if (!ipmi_control_light_set_with_setting(control))
 
565
            goto normal_val_get;
 
566
 
 
567
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
568
        rv = ipmi_control_get_light(control, control_get_light_done, cmd_info);
 
569
        if (rv) {
 
570
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
571
            cmdlang->errstr = "Error getting light control";
 
572
            cmdlang->err = rv;
 
573
            goto out_err;
 
574
        }
 
575
        break;
 
576
 
 
577
    case IPMI_CONTROL_IDENTIFIER:
 
578
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
579
        rv = ipmi_control_identifier_get_val(control, 
 
580
                                             control_get_id_done, cmd_info);
 
581
        if (rv) {
 
582
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
583
            cmdlang->errstr = "Error getting id control";
 
584
            cmdlang->err = rv;
 
585
            goto out_err;
 
586
        }
 
587
        break;
 
588
 
 
589
    case IPMI_CONTROL_DISPLAY:
 
590
        cmdlang->errstr = "Getting displays not currently supported";
 
591
        cmdlang->err = ENOSYS;
 
592
        goto out_err;
 
593
        break;
 
594
 
 
595
    case IPMI_CONTROL_RELAY:
 
596
    case IPMI_CONTROL_ALARM:
 
597
    case IPMI_CONTROL_RESET:
 
598
    case IPMI_CONTROL_POWER:
 
599
    case IPMI_CONTROL_FAN_SPEED:
 
600
    case IPMI_CONTROL_ONE_SHOT_RESET:
 
601
    case IPMI_CONTROL_OUTPUT:
 
602
    case IPMI_CONTROL_ONE_SHOT_OUTPUT:
 
603
    normal_val_get:
 
604
        ipmi_cmdlang_cmd_info_get(cmd_info);
 
605
        rv = ipmi_control_get_val(control, control_get_done, cmd_info);
 
606
        if (rv) {
 
607
            ipmi_cmdlang_cmd_info_put(cmd_info);
 
608
            cmdlang->errstr = "Error getting control";
 
609
            cmdlang->err = rv;
 
610
            goto out_err;
 
611
        }
 
612
        break;
 
613
    }
 
614
    return;
 
615
 
 
616
 out_err:
 
617
    ipmi_control_get_name(control, cmdlang->objstr,
 
618
                         cmdlang->objstr_len);
 
619
    cmdlang->location = "cmd_control.c(control_get)";
 
620
}
 
621
 
 
622
static int
 
623
control_event_handler(ipmi_control_t *control,
 
624
                      int            *valid_vals,
 
625
                      int            *vals,
 
626
                      void           *cb_data,
 
627
                      ipmi_event_t   *event)
 
628
{
 
629
    ipmi_cmd_info_t *evi;
 
630
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
631
    int             rv;
 
632
    char            *errstr;
 
633
    int             i;
 
634
    int             num;
 
635
 
 
636
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
637
 
 
638
    evi = ipmi_cmdlang_alloc_event_info();
 
639
    if (!evi) {
 
640
        rv = ENOMEM;
 
641
        errstr = "Out of memory";
 
642
        goto out_err;
 
643
    }
 
644
 
 
645
    ipmi_cmdlang_out(evi, "Object Type", "Control");
 
646
    ipmi_cmdlang_out(evi, "Name", control_name);
 
647
    ipmi_cmdlang_out(evi, "Operation", "Event");
 
648
    num = ipmi_control_get_num_vals(control);
 
649
    for (i=0; i<num; i++) {
 
650
        if (!valid_vals[i])
 
651
            continue;
 
652
        ipmi_cmdlang_out(evi, "Value", NULL);
 
653
        ipmi_cmdlang_down(evi);
 
654
        ipmi_cmdlang_out_int(evi, "Number", i);
 
655
        ipmi_cmdlang_out_int(evi, "Value", vals[i]);
 
656
        ipmi_cmdlang_up(evi);
 
657
    }
 
658
    if (event) {
 
659
        ipmi_cmdlang_out(evi, "Event", NULL);
 
660
        ipmi_cmdlang_down(evi);
 
661
        ipmi_cmdlang_event_out(event, evi);
 
662
        ipmi_cmdlang_up(evi);
 
663
    }
 
664
    ipmi_cmdlang_cmd_info_put(evi);
 
665
    return IPMI_EVENT_HANDLED;
 
666
 
 
667
 out_err:
 
668
    ipmi_cmdlang_global_err(control_name,
 
669
                            "cmd_control.c(ipmi_cmdlang_control_change)",
 
670
                            errstr, rv);
 
671
    if (evi)
 
672
        ipmi_cmdlang_cmd_info_put(evi);
 
673
    return IPMI_EVENT_NOT_HANDLED;
 
674
}
 
675
 
 
676
void
 
677
ipmi_cmdlang_control_change(enum ipmi_update_e op,
 
678
                            ipmi_entity_t      *entity,
 
679
                            ipmi_control_t      *control,
 
680
                            void               *cb_data)
 
681
{
 
682
    char            *errstr;
 
683
    int             rv;
 
684
    ipmi_cmd_info_t *evi;
 
685
    char            control_name[IPMI_CONTROL_NAME_LEN];
 
686
 
 
687
    ipmi_control_get_name(control, control_name, sizeof(control_name));
 
688
 
 
689
    evi = ipmi_cmdlang_alloc_event_info();
 
690
    if (!evi) {
 
691
        rv = ENOMEM;
 
692
        errstr = "Out of memory";
 
693
        goto out_err;
 
694
    }
 
695
 
 
696
    ipmi_cmdlang_out(evi, "Object Type", "Control");
 
697
    ipmi_cmdlang_out(evi, "Name", control_name);
 
698
 
 
699
    switch (op) {
 
700
    case IPMI_ADDED:
 
701
        ipmi_cmdlang_out(evi, "Operation", "Add");
 
702
        if (ipmi_cmdlang_get_evinfo())
 
703
            control_dump(control, evi);
 
704
 
 
705
        if (ipmi_control_has_events(control)) {
 
706
            rv = ipmi_control_add_val_event_handler(control,
 
707
                                                    control_event_handler,
 
708
                                                    NULL);
 
709
            if (rv) {
 
710
                ipmi_cmdlang_global_err
 
711
                    (control_name,
 
712
                     "cmd_control.c(ipmi_cmdlang_control_change)",
 
713
                     "Unable to set event handler for control",
 
714
                     rv);
 
715
            }
 
716
        }
 
717
        break;
 
718
 
 
719
        case IPMI_DELETED:
 
720
            ipmi_cmdlang_out(evi, "Operation", "Delete");
 
721
            break;
 
722
 
 
723
        case IPMI_CHANGED:
 
724
            ipmi_cmdlang_out(evi, "Operation", "Change");
 
725
            if (ipmi_cmdlang_get_evinfo())
 
726
                control_dump(control, evi);
 
727
            break;
 
728
    }
 
729
 
 
730
    ipmi_cmdlang_cmd_info_put(evi);
 
731
    return;
 
732
 
 
733
 out_err:
 
734
    ipmi_cmdlang_global_err(control_name,
 
735
                            "cmd_control.c(ipmi_cmdlang_control_change)",
 
736
                            errstr, rv);
 
737
    if (evi)
 
738
        ipmi_cmdlang_cmd_info_put(evi);
 
739
}
 
740
 
 
741
static ipmi_cmdlang_cmd_t *control_cmds;
 
742
 
 
743
static ipmi_cmdlang_init_t cmds_control[] =
 
744
{
 
745
    { "control", NULL,
 
746
      "- Commands dealing with controls",
 
747
      NULL, NULL, &control_cmds },
 
748
    { "list", &control_cmds,
 
749
      "- List all the entities in the system",
 
750
      ipmi_cmdlang_entity_handler, control_list, NULL },
 
751
    { "info", &control_cmds,
 
752
      "<control> - Dump information about an control",
 
753
      ipmi_cmdlang_control_handler, control_info, NULL },
 
754
    { "set", &control_cmds,
 
755
      "<control> <values> - Set the value of a control.  The settings"
 
756
      " depend on control type, most take one or more integer values. "
 
757
      " An identifier type takes one or more unsigned characters.  A"
 
758
      " light set with settings take the form 'lc|nolc <color> <on time>"
 
759
      " <off time>.  lc and nolc turn on or of local control, the over"
 
760
      " values should be obvious.",
 
761
      ipmi_cmdlang_control_handler, control_set, NULL },
 
762
    { "get", &control_cmds,
 
763
      "<control> - Get the value of a control",
 
764
      ipmi_cmdlang_control_handler, control_get, NULL },
 
765
};
 
766
#define CMDS_CONTROL_LEN (sizeof(cmds_control)/sizeof(ipmi_cmdlang_init_t))
 
767
 
 
768
int
 
769
ipmi_cmdlang_control_init(os_handler_t *os_hnd)
 
770
{
 
771
    return ipmi_cmdlang_reg_table(cmds_control, CMDS_CONTROL_LEN);
 
772
}