summaryrefslogtreecommitdiff
path: root/util
diff options
context:
space:
mode:
Diffstat (limited to 'util')
-rw-r--r--util/AnsiTerm.cpp1892
-rw-r--r--util/AnsiTerm.h316
-rw-r--r--util/Makefile.am200
-rw-r--r--util/Makefile.am-so241
-rw-r--r--util/Makefile.in766
-rw-r--r--util/Makefile.sample28
-rw-r--r--util/ialarms.c689
-rw-r--r--util/icmd.c366
-rw-r--r--util/iconfig.c2680
-rw-r--r--util/idcmi.c976
-rw-r--r--util/idcmi.h69
-rw-r--r--util/idiscover.c1055
-rw-r--r--util/iekanalyzer.c4131
-rw-r--r--util/iekanalyzer.h521
-rw-r--r--util/ievents.c2505
-rw-r--r--util/ievents.h64
-rw-r--r--util/ifirewall.c1154
-rw-r--r--util/ifirewall.h111
-rwxr-xr-xutil/ifru.c2123
-rw-r--r--util/ifru.h13
-rw-r--r--util/ifru_picmg.c486
-rw-r--r--util/ifruset.c1658
-rw-r--r--util/ifwum.c1697
-rw-r--r--util/ifwum.h76
-rw-r--r--util/igetevent.c1439
-rw-r--r--util/ihealth.c1153
-rw-r--r--util/ihpm.c4003
-rw-r--r--util/ihpm.h117
-rw-r--r--util/ilan.c5149
-rw-r--r--util/imb_api.h708
-rw-r--r--util/imbapi.c2594
-rw-r--r--util/ipicmg.c1911
-rw-r--r--util/ipicmg.h313
-rw-r--r--util/ipmi_port.c146
-rw-r--r--util/ipmi_sample.c312
-rw-r--r--util/ipmi_sample.mak57
-rw-r--r--util/ipmi_sample_evt.c445
-rw-r--r--util/ipmibmc.c231
-rw-r--r--util/ipmicmd.c1429
-rw-r--r--util/ipmicmd.h543
-rw-r--r--util/ipmidir.c1513
-rw-r--r--util/ipmidir.h301
-rw-r--r--util/ipmilan.c2430
-rw-r--r--util/ipmilan.h83
-rw-r--r--util/ipmilan2.c68
-rw-r--r--util/ipmilan2.h62
-rw-r--r--util/ipmilanplus.c790
-rw-r--r--util/ipmilanplus.h64
-rw-r--r--util/ipmild.c250
-rw-r--r--util/ipmilipmi.c182
-rw-r--r--util/ipmims.cpp638
-rw-r--r--util/ipmimv.c784
-rw-r--r--util/ipmiutil.c229
-rw-r--r--util/ipmiutil.h66
-rw-r--r--util/ipmiutil.mak424
-rw-r--r--util/ipmiutil2-64.mak425
-rw-r--r--util/ipmiutil2.mak425
-rw-r--r--util/ipmiutil64.mak423
-rw-r--r--util/ipmiutillib.def31
-rw-r--r--util/ireset.c751
-rw-r--r--util/isel.c884
-rw-r--r--util/iseltime.c260
-rw-r--r--util/isensor.c3680
-rw-r--r--util/isensor.h176
-rw-r--r--util/iserial.c1592
-rw-r--r--util/isol.c1347
-rw-r--r--util/isolwin.c293
-rw-r--r--util/itsol.c725
-rw-r--r--util/itsol.h66
-rw-r--r--util/iwdt.c415
-rw-r--r--util/md2.c99
-rw-r--r--util/md2.h269
-rw-r--r--util/md5.c413
-rw-r--r--util/mem_if.c900
-rw-r--r--util/mem_if_cpp.cpp5
-rw-r--r--util/oem_dell.c6095
-rw-r--r--util/oem_dell.h629
-rw-r--r--util/oem_fujitsu.c773
-rw-r--r--util/oem_fujitsu.h130
-rw-r--r--util/oem_hp.c149
-rw-r--r--util/oem_intel.c1842
-rw-r--r--util/oem_intel.h79
-rw-r--r--util/oem_kontron.c1107
-rw-r--r--util/oem_kontron.h80
-rw-r--r--util/oem_newisys.c129
-rw-r--r--util/oem_quanta.c142
-rw-r--r--util/oem_sun.c1058
-rw-r--r--util/oem_sun.h137
-rw-r--r--util/oem_supermicro.c595
-rw-r--r--util/oem_supermicro.h56
-rw-r--r--util/subs.c848
91 files changed, 79279 insertions, 0 deletions
diff --git a/util/AnsiTerm.cpp b/util/AnsiTerm.cpp
new file mode 100644
index 0000000..be94465
--- /dev/null
+++ b/util/AnsiTerm.cpp
@@ -0,0 +1,1892 @@
+/*
+ * AnsiTerm.cpp
+ * Windows ANSI Terminal Emulation
+ *
+ * Author: Robert Nelson robertnelson at users.sourceforge.net
+ * Copyright (c) 2009 Robert Nelson
+ *
+ * 10/07/09 Robert Nelson - Created
+ * 10/08/09 Robert Nelson
+ * - Fixed bug with resetting attribute to Black on Black on exit
+ * - Fixed setting of attribute when erasing
+ * - Added automatic handling of buffer resize events
+ * - Added display of unrecognized escape sequences
+ * 10/15/09 Robert Nelson
+ * - Fixed display problems caused by custom ColorTable used by cmd.exe
+ * - Fixed cursor positioning problems with OriginMode.
+ * - Changed to use block cursor because I think its more terminal like :-)
+ * - Added Reset handling
+ * - Added Cursor Show / Hide
+ * 10/16/09 Robert Nelson
+ * - Better handling of ColorTable.
+ * 10/17/09 Robert Nelson
+ * - Use GetProcAddress for (Get/Set)ConsoleScreenBufferInfoEx since they
+ * are only available on Vista and beyond.
+ *
+ * Todo:
+ * - Implement soft tabs
+ */
+
+/*
+Copyright (c) 2009, Robert Nelson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#include <windows.h>
+#include <stdio.h>
+#include <assert.h>
+#include "AnsiTerm.h"
+
+extern "C" unsigned char fCRLF;
+extern "C" void dbglog( char *pattn, ... );
+
+CAnsiTerm::CSICode CAnsiTerm::s_CSITable[] =
+{
+ { '[', DS_CSIParam },
+ { '#', DS_DECPrivate },
+ { '(', DS_SelectG0 },
+ { ')', DS_SelectG1 },
+ { '=', DS_None, &ProcessDECKPAM }, // Keypad Application Mode
+ { '>', DS_None, &ProcessDECKPNM }, // Keypad Numeric Mode
+ { '7', DS_None, &ProcessDECSC }, // Save Cursor
+ { '8', DS_None, &ProcessDECRC }, // Restore Cursor
+ { 'D', DS_None, &ProcessIND }, // Index
+ { 'E', DS_None, &ProcessNEL }, // Next Line
+ { 'H', DS_None, &ProcessHTS }, // Horizontal Tab Set
+ { 'M', DS_None, &ProcessRI }, // Reverse Index
+ { 'Z', DS_None, &ProcessDECID }, // Identify Terminal
+ { 'c', DS_None, &ProcessRIS }, // Reset to Initial State
+ { 's', DS_None, &ProcessSCP }, // Save Cursor Position
+ { 'u', DS_None, &ProcessRCP }, // Restore Cursor Position
+ { '\0' }
+};
+
+CAnsiTerm::CSIFunction CAnsiTerm::s_DECFunction[] =
+{
+ { '3', &ProcessDECDHLT }, // Double Height Line Top
+ { '4', &ProcessDECDHLB }, // Double Height Line Bottom
+ { '5', &ProcessDECSWL }, // Single Width Line
+ { '6', &ProcessDECDWL }, // Double Width Line
+ { '8', &ProcessDECALN }, // Screen Alignment Display
+ { '\0' }
+};
+
+CAnsiTerm::CSIFunction CAnsiTerm::s_CSIFunction[] =
+{
+ { 'A', &ProcessCUU }, // Cursor Up
+ { 'B', &ProcessCUD }, // Cursor Down
+ { 'C', &ProcessCUF }, // Cursor Forward
+ { 'D', &ProcessCUB }, // Cursor Backward
+ { 'H', &ProcessCUP }, // Cursor Position
+ { 'J', &ProcessED }, // Erase in Display
+ { 'K', &ProcessEL }, // Erase in Line
+ { 'c', &ProcessDA }, // Device Attributes
+ { 'f', &ProcessHVP }, // Horizontal and Vertical Position
+ { 'g', &ProcessTBC }, // Tabulation Clear
+ { 'h', &ProcessSM }, // Set Mode
+ { 'l', &ProcessRM }, // Reset Mode
+ { 'm', &ProcessSGR }, // Select Graphics Rendition
+ { 'n', &ProcessDSR }, // Device Status Report
+ { 'q', &ProcessDECLL }, // DEC Load LEDs
+ { 'r', &ProcessDECSTBM }, // DEC Set Top and Bottom Margins
+ { 'x', &ProcessDECREQTPARM }, // Request Terminal Parameters
+ { 'y', &ProcessDECTST }, // Invoke Confidence Test
+ { '\0' }
+};
+
+wchar_t CAnsiTerm::s_GraphicChars[kMaxGraphicsChar - kMinGraphicsChar + 1] =
+{
+ 0x0020, // 0137 5F 95 _ Blank
+ 0x2666, // 0140 60 96 ` Diamond
+ 0x2592, // 0141 61 97 a Checkerboard
+ 0x2409, // 0142 62 98 b Horizontal Tab
+ 0x240C, // 0143 63 99 c Form Feed
+ 0x240D, // 0144 64 100 d Carriage Return
+ 0x240A, // 0145 65 101 e Line Feed
+ 0x00B0, // 0146 66 102 f Degree Symbol
+ 0x00B1, // 0147 67 103 g Plus/Minus
+ 0x2424, // 0150 68 104 h New Line
+ 0x240B, // 0151 69 105 i Vertical Tab
+ 0x2518, // 0152 6A 106 j Lower-right corner
+ 0x2510, // 0153 6B 107 k Upper-right corner
+ 0x250C, // 0154 6C 108 l Upper-left corner
+ 0x2514, // 0155 6D 109 m Lower-left corner
+ 0x253C, // 0156 6E 110 n Crossing Lines
+ 0x00AF, // 0157 6F 111 o Horizontal Line - Scan 1
+ 0x0070, // 0160 70 112 p Horizontal Line - Scan 3 (No translation)
+ 0x2500, // 0161 71 113 q Horizontal Line - Scan 5
+ 0x0072, // 0162 72 114 r Horizontal Line - Scan 7 (No translation)
+ 0x005F, // 0163 73 115 s Horizontal Line - Scan 9
+ 0x251C, // 0164 74 116 t Left "T"
+ 0x2524, // 0165 75 117 u Right "T"
+ 0x2534, // 0166 76 118 v Bottom "T"
+ 0x252C, // 0167 77 119 w Top "T"
+ 0x2502, // 0170 78 120 x | Vertical bar
+ 0x2264, // 0171 79 121 y Less than or equal to
+ 0x2265, // 0172 7A 122 z Greater than or equal to
+ 0x03C0, // 0173 7B 123 { Pi
+ 0x2260, // 0174 7C 124 | Not equal to
+ 0x00A3, // 0175 7D 125 } UK Pound Sign
+ 0x00B7 // 0176 7E 126 ~ Centered dot
+};
+
+wchar_t CAnsiTerm::s_OemToUnicode[256] =
+{
+ 0x2007, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, // 00-07
+ 0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C, // 08-0F
+ 0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8, // 10-17
+ 0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC, // 18-1F
+ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, // 20-27
+ 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, // 28-2F
+ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, // 30-37
+ 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, // 38-3F
+ 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, // 40-47
+ 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, // 48-4F
+ 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, // 50-57
+ 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, // 58-5F
+ 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, // 60-67
+ 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, // 68-6F
+ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, // 70-77
+ 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, // 78-7F
+ 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, // 80-87
+ 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5, // 88-8F
+ 0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, // 90-97
+ 0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192, // 98-9F
+ 0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, // A0-A7
+ 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB, // A8-AF
+ 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, // B0-B7
+ 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510, // B8-BF
+ 0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, // C0-C7
+ 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567, // C8-CF
+ 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, // D0-D7
+ 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580, // D8-DF
+ 0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, // E0-E7
+ 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229, // E8-EF
+ 0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, // F0-F7
+ 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0 // F8-FF
+};
+
+COLORREF CAnsiTerm::s_ColorTable[kColorTableSize] =
+{
+ RGB(0, 0, 0),
+ RGB(0, 0, 128),
+ RGB(0, 128, 0),
+ RGB(0, 128, 128),
+ RGB(128, 0, 0),
+ RGB(128, 0, 128),
+ RGB(128, 128, 0),
+ RGB(192, 192, 192),
+ RGB(128, 128, 128),
+ RGB(0, 0, 255),
+ RGB(0, 255, 0),
+ RGB(0, 255, 255),
+ RGB(255, 0, 0),
+ RGB(255, 0, 255),
+ RGB(255, 255, 0),
+ RGB(255, 255, 255)
+};
+
+CAnsiTerm::PFN_GetConsoleScreenBufferInfoEx CAnsiTerm::s_pfnGetConsoleScreenBufferInfoEx;
+CAnsiTerm::PFN_SetConsoleScreenBufferInfoEx CAnsiTerm::s_pfnSetConsoleScreenBufferInfoEx;
+
+CAnsiTerm::CAnsiTerm(void)
+{
+ m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+
+ GetConsoleMode(m_hConsole, &m_dwOrigConsoleMode);
+
+ SetConsoleMode(m_hConsole, ENABLE_PROCESSED_OUTPUT);
+
+ CONSOLE_CURSOR_INFO cursorInfo;
+
+ GetConsoleCursorInfo(m_hConsole, &cursorInfo);
+
+ m_dwOrigCursorSize = cursorInfo.dwSize;
+
+ WindowSizeChanged(true);
+}
+
+CAnsiTerm::~CAnsiTerm(void)
+{
+ CONSOLE_CURSOR_INFO cursorInfo = { m_dwOrigCursorSize, TRUE };
+
+ SetConsoleCursorInfo(m_hConsole, &cursorInfo);
+
+ SetConsoleMode(m_hConsole, m_dwOrigConsoleMode);
+
+ SetConsoleTextAttribute(m_hConsole, m_wOrigConsoleAttribute);
+
+ if (m_bResetColorTable)
+ {
+ CONSOLE_SCREEN_BUFFER_INFOEX consoleInfo = { sizeof(consoleInfo) };
+
+ s_pfnGetConsoleScreenBufferInfoEx(m_hConsole, &consoleInfo);
+
+ memcpy(consoleInfo.ColorTable, m_OrigColorTable, kColorTableSize * sizeof(consoleInfo.ColorTable[0]));
+
+ // There is a bug between GetConsoleScreenBufferInfoEx and SetConsoleScreenBufferInfoEx.
+ // The first treats srWindow.Right and srWindow.Bottom as inclusive and the latter as exclusive.
+ consoleInfo.srWindow.Right++;
+ consoleInfo.srWindow.Bottom++;
+
+ s_pfnSetConsoleScreenBufferInfoEx(m_hConsole, &consoleInfo);
+
+ // Reset the attributes on existing lines so that at least white on black looks
+ // correct.
+ COORD coordStart = { 0, 0 };
+ DWORD dwWritten;
+
+ FillConsoleOutputAttribute(m_hConsole, m_wOrigConsoleAttribute, m_BufferSize.X * m_BufferSize.Y, coordStart, &dwWritten);
+ }
+
+ CloseHandle(m_hConsole);
+}
+
+void
+CAnsiTerm::WindowSizeChanged(bool bInitial)
+{
+ WORD wCurrentAttribute;
+ COORD dwCurrentCursorPosition;
+
+ if (bInitial)
+ {
+ HMODULE hKernel32 = GetModuleHandle("kernel32");
+
+ if (hKernel32 != NULL)
+ {
+ s_pfnGetConsoleScreenBufferInfoEx = (PFN_GetConsoleScreenBufferInfoEx)GetProcAddress(hKernel32, "GetConsoleScreenBufferInfoEx");
+ s_pfnSetConsoleScreenBufferInfoEx = (PFN_SetConsoleScreenBufferInfoEx)GetProcAddress(hKernel32, "SetConsoleScreenBufferInfoEx");
+
+ if (s_pfnGetConsoleScreenBufferInfoEx == NULL || s_pfnSetConsoleScreenBufferInfoEx == NULL)
+ {
+ s_pfnGetConsoleScreenBufferInfoEx = NULL;
+ s_pfnSetConsoleScreenBufferInfoEx = NULL;
+ }
+ }
+
+ m_bResetColorTable = false;
+ }
+
+ if (s_pfnGetConsoleScreenBufferInfoEx != NULL)
+ {
+ CONSOLE_SCREEN_BUFFER_INFOEX consoleInfo = { sizeof(consoleInfo) };
+
+ s_pfnGetConsoleScreenBufferInfoEx(m_hConsole, &consoleInfo);
+
+ m_BufferSize = consoleInfo.dwSize;
+
+ m_WindowSize.X = consoleInfo.srWindow.Right - consoleInfo.srWindow.Left + 1;
+ m_WindowSize.Y = consoleInfo.srWindow.Bottom - consoleInfo.srWindow.Top + 1;
+
+ wCurrentAttribute = consoleInfo.wAttributes;
+ dwCurrentCursorPosition = consoleInfo.dwCursorPosition;
+
+ if (bInitial)
+ {
+ m_bResetColorTable = memcmp(consoleInfo.ColorTable, s_ColorTable, sizeof(s_ColorTable)) != 0;
+
+ if (m_bResetColorTable)
+ {
+ // The command prompt (cmd.exe) uses a nonstandard color table
+ // So we save it away and reset it to match the Console API documentation
+ size_t colorCopyLen = kColorTableSize * sizeof(consoleInfo.ColorTable[0]);
+
+ memcpy(m_OrigColorTable, consoleInfo.ColorTable, colorCopyLen);
+
+ memcpy(consoleInfo.ColorTable, s_ColorTable, colorCopyLen);
+
+ // There is a bug between GetConsoleScreenBufferInfoEx and SetConsoleScreenBufferInfoEx.
+ // The first treats srWindow.Right and srWindow.Bottom as inclusive and the latter as exclusive.
+ consoleInfo.srWindow.Right++;
+ consoleInfo.srWindow.Bottom++;
+
+ s_pfnSetConsoleScreenBufferInfoEx(m_hConsole, &consoleInfo);
+
+ // Reset the attributes on existing lines so that at least white on black looks
+ // correct.
+ COORD coordStart = { 0, 0 };
+ DWORD dwWritten;
+
+ FillConsoleOutputAttribute(m_hConsole, kDefaultAttribute, m_BufferSize.X * m_BufferSize.Y, coordStart, &dwWritten);
+ }
+ }
+ }
+ else
+ {
+ CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
+
+ GetConsoleScreenBufferInfo(m_hConsole, &consoleInfo);
+
+ m_BufferSize = consoleInfo.dwSize;
+
+ m_WindowSize.X = consoleInfo.srWindow.Right - consoleInfo.srWindow.Left + 1;
+ m_WindowSize.Y = consoleInfo.srWindow.Bottom - consoleInfo.srWindow.Top + 1;
+
+ wCurrentAttribute = consoleInfo.wAttributes;
+ dwCurrentCursorPosition = consoleInfo.dwCursorPosition;
+ }
+
+ m_WindowOrigin.X = 0;
+ m_WindowOrigin.Y = m_BufferSize.Y - m_WindowSize.Y;
+
+ if (bInitial)
+ {
+ m_wOrigConsoleAttribute = wCurrentAttribute;
+
+ SHORT nLines = dwCurrentCursorPosition.Y - m_WindowOrigin.Y;
+
+ if (nLines != 0)
+ {
+ SMALL_RECT rectSource = { 0, 0, m_BufferSize.X - 1, m_BufferSize.Y - 1 };
+ COORD coordDest = { 0, 0 };
+ CHAR_INFO charInfo = { ' ', kDefaultAttribute };
+
+ if (nLines > 0)
+ {
+ rectSource.Top = nLines;
+ }
+ else
+ {
+ coordDest.Y -= nLines;
+ rectSource.Bottom += nLines;
+ }
+
+ ScrollConsoleScreenBuffer(m_hConsole, &rectSource, NULL, coordDest, &charInfo);
+ }
+ }
+
+ ResetTerm();
+}
+
+int
+CAnsiTerm::ProcessInput(CAnsiTerm::KeyCode keyCode, unsigned char *pOutput, int iOutputSize)
+{
+ int iOutputLength = 0;
+
+ if (pOutput == NULL || iOutputSize < 1)
+ {
+ return 0;
+ }
+
+ if (!keyCode.bKeyDown)
+ {
+ return 0;
+ }
+
+ if (VK_F1 <= keyCode.VirtualKeyCode && keyCode.VirtualKeyCode <= VK_F12)
+ {
+ pOutput[iOutputLength++] = CH_ESC;
+ pOutput[iOutputLength++] = 'O';
+ pOutput[iOutputLength++] = 'P' + keyCode.VirtualKeyCode - VK_F1;
+ }
+ else
+ if (keyCode.VirtualKeyCode == VK_UP ||
+ keyCode.VirtualKeyCode == VK_DOWN ||
+ keyCode.VirtualKeyCode == VK_RIGHT ||
+ keyCode.VirtualKeyCode == VK_LEFT)
+ {
+ pOutput[iOutputLength++] = CH_ESC;
+
+ if ((m_bCursorKeyMode && !keyCode.bControl) ||
+ (!m_bCursorKeyMode && keyCode.bControl))
+ {
+ pOutput[iOutputLength++] = 'O';
+ }
+ else
+ {
+ pOutput[iOutputLength++] = '[';
+ }
+
+ switch (keyCode.VirtualKeyCode)
+ {
+ case VK_UP:
+ pOutput[iOutputLength++] = 'A';
+ break;
+
+ case VK_DOWN:
+ pOutput[iOutputLength++] = 'B';
+ break;
+
+ case VK_RIGHT:
+ pOutput[iOutputLength++] = 'C';
+ break;
+
+ case VK_LEFT:
+ pOutput[iOutputLength++] = 'D';
+ break;
+ }
+ }
+ else
+ if (keyCode.VirtualKeyCode == VK_HOME ||
+ keyCode.VirtualKeyCode == VK_INSERT ||
+ keyCode.VirtualKeyCode == VK_DELETE ||
+ keyCode.VirtualKeyCode == VK_END ||
+ keyCode.VirtualKeyCode == VK_PRIOR ||
+ keyCode.VirtualKeyCode == VK_NEXT)
+ {
+ pOutput[iOutputLength++] = CH_ESC;
+ pOutput[iOutputLength++] = '[';
+
+ switch (keyCode.VirtualKeyCode)
+ {
+ case VK_HOME:
+ pOutput[iOutputLength++] = '1';
+ break;
+
+ case VK_INSERT:
+ pOutput[iOutputLength++] = '2';
+ break;
+
+ case VK_DELETE:
+ pOutput[iOutputLength++] = '3';
+ break;
+
+ case VK_END:
+ pOutput[iOutputLength++] = '4';
+ break;
+
+ case VK_PRIOR:
+ pOutput[iOutputLength++] = '5';
+ break;
+
+ case VK_NEXT:
+ pOutput[iOutputLength++] = '6';
+ break;
+ }
+
+ pOutput[iOutputLength++] = '~';
+ }
+ else
+ if (keyCode.VirtualKeyCode == VK_RETURN)
+ {
+ pOutput[iOutputLength++] = CH_CR;
+ if (fCRLF == 1)
+ {
+ pOutput[iOutputLength++] = CH_LF;
+ }
+ }
+ else
+ if (keyCode.AsciiChar != '\0')
+ {
+ pOutput[iOutputLength++] = keyCode.AsciiChar;
+ }
+
+ return iOutputLength;
+}
+
+bool
+CAnsiTerm::ProcessOutput(const unsigned char *szData, int iLength)
+{
+ const unsigned char *pEnd = &szData[iLength];
+
+ for (const unsigned char *pCurrent = szData; pCurrent < pEnd; pCurrent++)
+ {
+ if (*pCurrent < 0x20 || *pCurrent == 0x7F)
+ {
+ dbglog("ProcessOutput: control_ch = %02x\n",*pCurrent);
+ OutputText();
+
+ switch (*pCurrent)
+ {
+ case CH_NUL:
+ case CH_ENQ:
+ case CH_DEL:
+ // These are ignored
+ break;
+
+ case CH_BEL:
+ MessageBeep(MB_ICONASTERISK);
+ break;
+
+ case CH_BS:
+ ProcessBackspace();
+ break;
+
+ case CH_HT:
+ ProcessTab();
+ break;
+
+ case CH_LF:
+ case CH_VT:
+ case CH_FF:
+ ProcessLinefeed(m_bLineFeedNewLineMode);
+ break;
+
+ case CH_CR:
+ ProcessReturn();
+ break;
+
+ case CH_SO:
+ m_SelectedCharset = CharsetG1;
+ break;
+
+ case CH_SI:
+ m_SelectedCharset = CharsetG0;
+ break;
+
+ case CH_XON:
+ // Not yet implemented
+ break;
+
+ case CH_XOF:
+ // Not yet implemented
+ break;
+
+#if 0
+ case CH_CAN:
+ case CH_SUB:
+ // Output error character
+ break;
+#endif
+
+ case CH_ESC:
+ m_State = DS_Escape;
+ break;
+
+ default:
+ AddOutputData(s_OemToUnicode[*pCurrent]);
+ break;
+ }
+ }
+ else
+ {
+ /* db b3 or b0 b3 */
+ if (*pCurrent & 0x80)
+ dbglog("ProcessOutput: state=%d ch=%02x\n",m_State,*pCurrent);
+ switch (m_State)
+ {
+ case DS_Normal:
+ if (*pCurrent & 0x80)
+ {
+ // Could be start of a UTF-8 sequence or an ANSI extended character
+
+ if ((*pCurrent & 0xE0) == 0xC0)
+ {
+ m_UTF8Size = 2;
+ }
+ else if ((*pCurrent & 0xF0) == 0xE0)
+ {
+ m_UTF8Size = 3;
+ }
+ else
+ {
+ // Not a UTF-8 lead character
+ AddOutputData(s_OemToUnicode[*pCurrent]);
+ break;
+ }
+ m_UTF8Count = 1;
+ m_UTF8Buffer[0] = *pCurrent;
+ m_State = DS_UTF8;
+ break;
+ }
+
+ if ((m_SelectedCharset == CharsetG0 && m_G0Charset == SpecialGraphicsCharset) ||
+ (m_SelectedCharset == CharsetG1 && m_G1Charset == SpecialGraphicsCharset))
+ {
+ if (kMinGraphicsChar <= *pCurrent && *pCurrent <= kMaxGraphicsChar)
+ {
+ AddOutputData(s_GraphicChars[*pCurrent - kMinGraphicsChar]);
+ }
+ else
+ {
+ AddOutputData(*pCurrent);
+ }
+ }
+ else
+ {
+ AddOutputData(*pCurrent);
+ }
+ break;
+
+ case DS_UTF8:
+ if ((*pCurrent & 0xC0) != 0x80)
+ {
+ for (int index = 0; index < m_UTF8Count; index++)
+ {
+ AddOutputData(s_OemToUnicode[m_UTF8Buffer[index]]);
+ }
+
+ if (*pCurrent & 0x80)
+ {
+ AddOutputData(s_OemToUnicode[*pCurrent]);
+ }
+ else
+ {
+ AddOutputData(*pCurrent);
+ }
+ m_State = DS_Normal;
+ }
+ else
+ {
+ m_UTF8Buffer[m_UTF8Count++] = *pCurrent;
+
+ if (m_UTF8Count == m_UTF8Size)
+ {
+ wchar_t wchUTF16;
+ if (m_UTF8Size == 2)
+ {
+ wchUTF16 = ((m_UTF8Buffer[0] & 0x1F) << 6) | (m_UTF8Buffer[1] & 0x3F);
+ }
+ else
+ {
+ wchUTF16 = ((m_UTF8Buffer[0] & 0x0F) << 12) | ((m_UTF8Buffer[1] & 0x3F) << 6) | (m_UTF8Buffer[2] & 0x3F);
+ }
+
+ AddOutputData(wchUTF16);
+ m_State = DS_Normal;
+ }
+ }
+ break;
+
+ case DS_Escape:
+ for (int index = 0; s_CSITable[index].chCode != '\0'; index++)
+ {
+ if (*pCurrent == s_CSITable[index].chCode)
+ {
+ if (s_CSITable[index].dsNextState != DS_None)
+ {
+ m_State = s_CSITable[index].dsNextState;
+ m_Parameters[0] = 0;
+ m_ParameterCount = 0;
+ m_bParametersStart = true;
+ }
+ else
+ {
+ (this->*s_CSITable[index].pfnProcess)();
+ m_State = DS_Normal;
+ }
+ break;
+ }
+ }
+
+ if (m_State == DS_Escape)
+ {
+ AddOutputData(L'^');
+ AddOutputData(L'[');
+ AddOutputData(*pCurrent);
+ m_State = DS_Normal;
+ }
+ break;
+
+ case DS_CSIParam:
+ if (m_bParametersStart)
+ {
+ m_bParametersStart = false;
+
+ if (*pCurrent == '?')
+ {
+ m_bPrivateParameters = true;
+ break;
+ }
+ else
+ {
+ m_bPrivateParameters = false;
+ }
+ }
+ if ('0' <= *pCurrent && *pCurrent <= '9')
+ {
+ if (m_ParameterCount < kMaxParameterCount)
+ {
+ m_Parameters[m_ParameterCount] *= 10;
+ m_Parameters[m_ParameterCount] += *pCurrent - '0';
+ }
+ }
+ else if (*pCurrent == ';')
+ {
+ if (m_ParameterCount < kMaxParameterCount)
+ {
+ m_ParameterCount++;
+ }
+
+ if (m_ParameterCount < kMaxParameterCount)
+ {
+ m_Parameters[m_ParameterCount] = 0;
+ }
+ }
+ else
+ {
+ if (m_ParameterCount < kMaxParameterCount)
+ {
+ m_ParameterCount++;
+ }
+
+ for (int index = 0; s_CSIFunction[index].chCode != '\0'; index++)
+ {
+ if (*pCurrent == s_CSIFunction[index].chCode)
+ {
+ (this->*s_CSIFunction[index].pfnProcess)();
+ m_State = DS_Normal;
+ break;
+ }
+ }
+ if (m_State != DS_Normal)
+ {
+ DisplayCSI(*pCurrent);
+ m_State = DS_Normal;
+ }
+ }
+ break;
+
+ case DS_DECPrivate:
+ for (int index = 0; s_DECFunction[index].chCode != '\0'; index++)
+ {
+ if (*pCurrent == s_DECFunction[index].chCode)
+ {
+ (this->*s_DECFunction[index].pfnProcess)();
+ m_State = DS_Normal;
+ break;
+ }
+ }
+
+ if (m_State != DS_Normal)
+ {
+ AddOutputData(L'^');
+ AddOutputData(L'[');
+ AddOutputData(L'#');
+ AddOutputData(*pCurrent);
+ }
+ break;
+
+ case DS_SelectG0:
+ ProcessSCSG0(*pCurrent);
+ m_State = DS_Normal;
+ break;
+
+ case DS_SelectG1:
+ ProcessSCSG1(*pCurrent);
+ m_State = DS_Normal;
+ break;
+
+ default:
+ dbglog("ProcessOutput: illegal m_State=%d\n",m_State);
+ assert(false);
+ break;
+ }
+ }
+ }
+
+ OutputText();
+
+ return true;
+}
+
+void
+CAnsiTerm::DisplayCSI(char ch)
+{
+ char szParam[15];
+
+ AddOutputData(L'^');
+ AddOutputData(L'[');
+ AddOutputData(L'[');
+ for (int idxParam = 0; idxParam < m_ParameterCount; idxParam++)
+ {
+ if (idxParam > 0)
+ {
+ AddOutputData(L';');
+ }
+
+ int iLenParam = sprintf(szParam, "%d", m_Parameters[idxParam]);
+
+ for (int idxChar = 0; idxChar < iLenParam; idxChar++)
+ {
+ AddOutputData(szParam[idxChar]);
+ }
+ }
+ AddOutputData(ch);
+}
+
+bool
+CAnsiTerm::ResetTerm(void)
+{
+ m_State = DS_Normal;
+
+ m_SelectedCharset = CharsetG0;
+ m_G0Charset = AsciiCharset;
+ m_G1Charset = SpecialGraphicsCharset;
+
+ m_Cursor.X = 0;
+ m_Cursor.Y = 0;
+
+ m_SavedCursor = m_Cursor;
+
+ m_sTopMargin = 0;
+ m_sBottomMargin = m_WindowSize.Y - 1;
+
+ m_Attribute = kDefaultAttribute;
+
+ UpdateTextAttribute();
+
+ m_dwOutputCount = 0;
+
+ // if (fCRLF == 1)
+ m_bLineFeedNewLineMode = true; /*was false*/
+ m_bCursorKeyMode = false;
+ m_bAnsiMode = true;
+ m_bColumnMode = true;
+ m_bScrollingMode = false;
+ m_bScreenMode = false;
+ m_bOriginMode = false;
+ m_bAutoRepeatingMode = true;
+ m_bInterlaceMode = false;
+ m_bDisplayCursor = true;
+ m_bAutoWrapMode = true; /*default to wrap*/
+
+ EraseDisplay(EraseAll);
+
+ SetCursorPosition();
+
+ DisplayCursor();
+
+ return true;
+}
+
+bool
+CAnsiTerm::DisplayCursor(void)
+{
+ CONSOLE_CURSOR_INFO cursorInfo = { 100, m_bDisplayCursor };
+
+ return SetConsoleCursorInfo(m_hConsole, &cursorInfo) != FALSE;
+}
+
+bool
+CAnsiTerm::UpdateTextAttribute(void)
+{
+ return SetConsoleTextAttribute(m_hConsole, m_Attribute) != FALSE;
+}
+
+bool
+CAnsiTerm::GetCursorPosition(void)
+{
+ CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
+
+ if (GetConsoleScreenBufferInfo(m_hConsole, &bufferInfo))
+ {
+ m_Cursor = bufferInfo.dwCursorPosition;
+ m_Cursor.Y -= m_WindowOrigin.Y + (m_bOriginMode ? m_sTopMargin : 0);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool
+CAnsiTerm::SetCursorPosition(void)
+{
+ COORD cursor = m_Cursor;
+
+ cursor.Y += m_WindowOrigin.Y + (m_bOriginMode ? m_sTopMargin : 0);
+
+ return SetConsoleCursorPosition(m_hConsole, cursor) != FALSE;
+}
+
+bool
+CAnsiTerm::ScrollDisplay(int n, bool bWindowOnly)
+{
+ SHORT nLines = (SHORT)n;
+ if (nLines == 0)
+ {
+ return true;
+ }
+
+ SMALL_RECT rectSource = { 0, 0, m_BufferSize.X - 1, m_BufferSize.Y - 1 };
+ COORD coordDest = { 0, 0 };
+ CHAR_INFO charInfo = { ' ', m_Attribute };
+
+ if (nLines > 0)
+ {
+ if (bWindowOnly || m_sTopMargin > 0)
+ {
+ coordDest.Y = m_WindowOrigin.Y + m_sTopMargin;
+ rectSource.Top = m_WindowOrigin.Y + m_sTopMargin + nLines;
+ rectSource.Bottom = m_WindowOrigin.Y + m_sBottomMargin;
+ }
+ else
+ {
+ rectSource.Top = nLines;
+ rectSource.Bottom = m_WindowOrigin.Y + m_sBottomMargin;
+ }
+ }
+ else
+ {
+ if (bWindowOnly)
+ {
+ coordDest.Y = m_WindowOrigin.Y + m_sTopMargin - nLines;
+ rectSource.Top = m_WindowOrigin.Y + m_sTopMargin;
+ rectSource.Bottom = m_WindowOrigin.Y + m_sBottomMargin + 1 + nLines;
+ }
+ else
+ {
+ coordDest.Y -= nLines;
+ }
+
+ rectSource.Bottom += nLines;
+ }
+
+ return ScrollConsoleScreenBuffer(m_hConsole, &rectSource, NULL, coordDest, &charInfo) != FALSE;
+}
+
+bool
+CAnsiTerm::EraseLine(EraseType eType)
+{
+ DWORD dwLength;
+
+ COORD coordStart = m_WindowOrigin;
+
+ coordStart.Y += m_Cursor.Y + (m_bOriginMode ? m_sTopMargin : 0);
+
+ switch (eType)
+ {
+ case EraseCursorToEnd:
+ if (m_Cursor.X < m_WindowSize.X)
+ {
+ coordStart.X += m_Cursor.X;
+ dwLength = m_BufferSize.X - m_Cursor.X;
+ }
+ else
+ {
+ dwLength = 0;
+ }
+ break;
+
+ case EraseBeginningToCursor:
+ if (m_Cursor.X < m_WindowSize.X)
+ {
+ dwLength = m_Cursor.X + 1;
+ }
+ else
+ {
+ dwLength = m_BufferSize.X;
+ }
+ break;
+
+ case EraseAll:
+ dwLength = m_BufferSize.X;
+ break;
+
+ default:
+ return false;
+ }
+
+ if (dwLength > 0)
+ {
+ DWORD dwWritten;
+
+ FillConsoleOutputAttribute(m_hConsole, m_Attribute, dwLength, coordStart, &dwWritten);
+ return FillConsoleOutputCharacter(m_hConsole, ' ', dwLength, coordStart, &dwWritten) != FALSE;
+ }
+ else
+ {
+ return true;
+ }
+}
+
+bool
+CAnsiTerm::EraseDisplay(EraseType eType)
+{
+ COORD coordStart = m_WindowOrigin;
+ DWORD dwLength;
+
+ switch (eType)
+ {
+ case EraseCursorToEnd:
+ if (m_Cursor.X < m_WindowSize.X)
+ {
+ coordStart.X += m_Cursor.X;
+ coordStart.Y += m_Cursor.Y + (m_bOriginMode ? m_sTopMargin : 0);
+ dwLength = (m_WindowSize.Y - m_Cursor.Y - (m_bOriginMode ? m_sTopMargin : 0)) * m_BufferSize.X - m_Cursor.X;
+ }
+ else if (m_Cursor.Y < (m_WindowSize.Y - 1))
+ {
+ coordStart.X = 0;
+ coordStart.Y += m_Cursor.Y + 1;
+ dwLength = (m_WindowSize.Y - m_Cursor.Y - (m_bOriginMode ? m_sTopMargin : 0) - 1) * m_BufferSize.X;
+ }
+ else
+ {
+ dwLength = 0;
+ }
+ break;
+
+ case EraseBeginningToCursor:
+ if (m_Cursor.X < m_WindowSize.X)
+ {
+ dwLength = (m_Cursor.Y + (m_bOriginMode ? m_sTopMargin : 0)) * m_BufferSize.X + m_Cursor.X;
+ }
+ else
+ {
+ dwLength = (m_Cursor.Y + (m_bOriginMode ? m_sTopMargin : 0) + 1) * m_BufferSize.X;
+ }
+ break;
+
+ case EraseAll:
+ dwLength = m_BufferSize.X * m_WindowSize.Y;
+ break;
+
+ default:
+ return false;
+ }
+
+ if (dwLength > 0)
+ {
+ DWORD dwWritten;
+
+ FillConsoleOutputAttribute(m_hConsole, m_Attribute, dwLength, coordStart, &dwWritten);
+ return FillConsoleOutputCharacter(m_hConsole, ' ', dwLength, coordStart, &dwWritten) != FALSE;
+ }
+ else
+ {
+ return true;
+ }
+}
+
+DWORD
+CAnsiTerm::OutputText(void)
+{
+ if (m_dwOutputCount == 0)
+ {
+ return 0;
+ }
+
+ DWORD dwTotalWritten = 0;
+ wchar_t * pwszCurrent = m_OutputBuffer;
+ DWORD dwLeftToWrite = m_dwOutputCount;
+
+ while (dwLeftToWrite > 0)
+ {
+ DWORD dwWritten;
+
+ if (m_Cursor.X >= m_WindowSize.X)
+ {
+ if (m_bAutoWrapMode)
+ {
+ ProcessLinefeed(true);
+ }
+ else
+ {
+ m_Cursor.X = m_WindowSize.X - 1;
+
+ SetCursorPosition();
+
+ if (WriteConsoleW(m_hConsole, &m_OutputBuffer[m_dwOutputCount - 1], 1, &dwWritten, NULL))
+ {
+ assert(dwWritten == 1);
+ }
+
+ m_Cursor.X++;
+ dwTotalWritten += dwLeftToWrite;
+ break;
+ }
+ }
+
+ DWORD dwPartialCount = min(dwLeftToWrite, (DWORD)(m_WindowSize.X - m_Cursor.X));
+
+ if (WriteConsoleW(m_hConsole, pwszCurrent, dwPartialCount, &dwWritten, NULL))
+ {
+ assert(dwWritten == dwPartialCount);
+ }
+ else
+ {
+ DWORD dwError = GetLastError();
+ }
+
+ m_Cursor.X += (SHORT)dwPartialCount;
+ pwszCurrent += dwPartialCount;
+ dwTotalWritten += dwPartialCount;
+ dwLeftToWrite -= dwPartialCount;
+ }
+
+ m_dwOutputCount = 0;
+
+ return dwTotalWritten;
+}
+
+bool
+CAnsiTerm::ProcessBackspace(void)
+{
+ if (m_Cursor.X > 0)
+ {
+ if (m_Cursor.X < m_WindowSize.X)
+ {
+ m_Cursor.X--;
+ }
+ else
+ {
+ m_Cursor.X = m_WindowSize.X - 1;
+ }
+
+ return SetCursorPosition();
+ }
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessTab(void)
+{
+ if (m_Cursor.X >= m_WindowSize.X)
+ {
+ if (m_bAutoWrapMode)
+ {
+ ProcessLinefeed(true);
+ }
+ else
+ {
+ return true;
+ }
+ }
+
+ int newX = m_Cursor.X + 8;
+
+ newX &= ~7;
+
+ if (newX >= m_WindowSize.X)
+ {
+ newX = m_WindowSize.X - 1;
+ }
+
+ int cntSpaces = newX - m_Cursor.X;
+
+ for (int index = 0; index < cntSpaces; index++)
+ {
+ AddOutputData(L' ');
+ }
+
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessReverseLinefeed(void)
+{
+ if (m_Cursor.Y == 0)
+ {
+ ScrollDisplay(-1, true);
+ }
+ else
+ {
+ m_Cursor.Y--;
+ }
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessLinefeed(bool bNewLine)
+{
+ if (bNewLine)
+ {
+ m_Cursor.X = 0;
+ }
+
+ if (m_bOriginMode || (m_Cursor.Y >= m_sTopMargin && m_Cursor.Y <= m_sBottomMargin))
+ {
+ if (m_Cursor.Y >= (m_sBottomMargin - m_sTopMargin))
+ {
+ ScrollDisplay(1, false);
+ m_Cursor.Y = m_sBottomMargin;
+ }
+ else
+ {
+ m_Cursor.Y++;
+ }
+ }
+ else if (m_Cursor.Y < m_sBottomMargin)
+ {
+ m_Cursor.Y++;
+ }
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessReturn(void)
+{
+ m_Cursor.X = 0;
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessDECALN(void)
+{
+ // Fill the display with 'E' for adjusting the CRT on a VT100 - Ignore it
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECDHLB(void)
+{
+ // Double Height Line Bottom - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECDHLT(void)
+{
+ // Double Height Line Top - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECDWL(void)
+{
+ // Double Width Line - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECID(void)
+{
+ return ProcessDA();
+}
+
+bool
+CAnsiTerm::ProcessDECKPAM(void)
+{
+ // Keypad Application Mode - Not yet implemented
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECKPNM(void)
+{
+ // Keypad Numeric Mode - Not yet implemented
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECLL(void)
+{
+ // Load LEDs - Not Supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECRC(void)
+{
+ return ProcessRCP();
+}
+
+bool
+CAnsiTerm::ProcessDECREQTPARM(void)
+{
+ // Request Terminal Parameters (Baud Rate, Parity, etc) - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECSC(void)
+{
+ return ProcessSCP();
+}
+
+bool
+CAnsiTerm::ProcessDECSTBM(void)
+{
+ assert(m_ParameterCount >= 1);
+
+ if (m_Parameters[0] > 0)
+ {
+ m_Parameters[0]--;
+ }
+
+ if (m_ParameterCount < 2)
+ {
+ m_Parameters[1] = m_WindowSize.Y - 1;
+ }
+ else
+ {
+ if (m_Parameters[1] > 0)
+ {
+ m_Parameters[1]--;
+ }
+ else
+ {
+ m_Parameters[1] = m_WindowSize.Y - 1;
+ }
+ }
+
+ if (m_Parameters[0] >= m_WindowSize.Y ||
+ m_Parameters[1] >= m_WindowSize.Y ||
+ m_Parameters[0] >= m_Parameters[1])
+ {
+ return false;
+ }
+
+ m_sTopMargin = (SHORT)m_Parameters[0];
+ m_sBottomMargin = (SHORT)m_Parameters[1];
+
+ m_Cursor.X = 0;
+ m_Cursor.Y = 0;
+
+ SetCursorPosition();
+
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECSWL(void)
+{
+ // Single Width Line - Since Double Width Line isn't supported, this isn't necessary
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDECTST(void)
+{
+ // Perform Self Test - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessCUB(void)
+{
+ if (m_Parameters[0] == 0)
+ {
+ m_Parameters[0]++;
+ }
+
+ m_Cursor.X -= min(m_Cursor.X, m_Parameters[0]);
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessCUD(void)
+{
+ if (m_Parameters[0] == 0)
+ {
+ m_Parameters[0]++;
+ }
+
+ m_Cursor.Y += min((m_bOriginMode ? m_sBottomMargin : m_WindowSize.Y - 1) - m_Cursor.Y, m_Parameters[0]);
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessCUF(void)
+{
+ if (m_Parameters[0] == 0)
+ {
+ m_Parameters[0]++;
+ }
+
+ m_Cursor.X += min(m_WindowSize.X - m_Cursor.X - 1, m_Parameters[0]);
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessCUP(void)
+{
+ return ProcessHVP();
+}
+
+bool
+CAnsiTerm::ProcessCUU(void)
+{
+ if (m_Parameters[0] == 0)
+ {
+ m_Parameters[0]++;
+ }
+
+ m_Cursor.Y -= min(m_Cursor.Y, m_Parameters[0]);
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessDA(void)
+{
+ // Send Device Attributes - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessDSR(void)
+{
+ // Send Device Status Request - Not supported
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessED(void)
+{
+ return EraseDisplay((EraseType)m_Parameters[0]);
+}
+
+bool
+CAnsiTerm::ProcessEL(void)
+{
+ return EraseLine((EraseType)m_Parameters[0]);
+}
+
+bool
+CAnsiTerm::ProcessHTS(void)
+{
+ // Soft Tab Set - Not implemented yet
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessHVP(void)
+{
+ assert(m_ParameterCount >= 1);
+
+ if (m_Parameters[0] > 0)
+ {
+ m_Parameters[0]--;
+ }
+
+ if (m_ParameterCount < 2)
+ {
+ m_Parameters[1] = 0;
+ }
+ else
+ {
+ if (m_Parameters[1] > 0)
+ {
+ m_Parameters[1]--;
+ }
+ }
+
+ if (m_bOriginMode)
+ {
+ if (m_Parameters[0] >= (m_sBottomMargin - m_sTopMargin + 1))
+ {
+ m_Parameters[0] = m_sBottomMargin - m_sTopMargin;
+ }
+ }
+ else
+ {
+ if (m_Parameters[0] >= m_WindowSize.Y)
+ {
+ m_Parameters[0] = m_WindowSize.Y - 1;
+ }
+ }
+
+ if (m_Parameters[1] >= m_WindowSize.X)
+ {
+ m_Parameters[1] = m_WindowSize.X - 1;
+ }
+
+ m_Cursor.Y = (SHORT)m_Parameters[0];
+ m_Cursor.X = (SHORT)m_Parameters[1];
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessIND(void)
+{
+ return ProcessLinefeed(false);
+}
+
+bool
+CAnsiTerm::ProcessNEL(void)
+{
+ return ProcessLinefeed(true);
+}
+
+bool
+CAnsiTerm::ProcessRCP(void)
+{
+ m_Cursor = m_SavedCursor;
+
+ return SetCursorPosition();
+}
+
+bool
+CAnsiTerm::ProcessRI(void)
+{
+ return ProcessReverseLinefeed();
+}
+
+bool
+CAnsiTerm::ProcessRIS(void)
+{
+ return ResetTerm();
+}
+
+bool
+CAnsiTerm::ProcessRM(void)
+{
+ if (m_bPrivateParameters)
+ {
+ for (int index = 0; index < m_ParameterCount; index++)
+ {
+ switch (m_Parameters[index])
+ {
+ case 0:
+ default:
+ assert(false);
+ break;
+ case DECCKM:
+ m_bCursorKeyMode = false;
+ break;
+ case DECANM:
+ m_bAnsiMode = false;
+ break;
+ case DECCOLM:
+ m_bColumnMode = false;
+ break;
+ case DECSCLM:
+ m_bScrollingMode = false;
+ break;
+ case DECSCNM:
+ m_bScreenMode = false;
+ break;
+ case DECOM:
+ m_bOriginMode = false;
+ m_Cursor.X = 0;
+ m_Cursor.Y = 0;
+ SetCursorPosition();
+ break;
+ case DECAWM:
+ m_bAutoWrapMode = false;
+ break;
+ case DECARM:
+ m_bAutoRepeatingMode = false;
+ break;
+ case DECINLM:
+ m_bInterlaceMode = false;
+ break;
+ case DECTCEM:
+ m_bDisplayCursor = false;
+ DisplayCursor();
+ break;
+ }
+ }
+ }
+ else
+ {
+ for (int index = 0; index < m_ParameterCount; index++)
+ {
+ switch (m_Parameters[index])
+ {
+ case 20: m_bLineFeedNewLineMode = false; break; // LNM
+ default: assert(false); break;
+ }
+ }
+ }
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessSCP(void)
+{
+ m_SavedCursor = m_Cursor;
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessSCSG0(char ch)
+{
+ switch (ch)
+ {
+ case 'B': // ASCII Charset
+ m_G0Charset = AsciiCharset;
+ break;
+
+ case '0': // Special Graphics Charset
+ m_G0Charset = SpecialGraphicsCharset;
+ break;
+
+ case 'A': // UK Charset
+ case '1': // Alternate Character ROM Standard Charset
+ case '2': // Alternate Character ROM Special Graphics Charset
+ default: // Unsupported
+ return false;
+
+ }
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessSCSG1(char ch)
+{
+ switch (ch)
+ {
+ case 'B': // ASCII Charset
+ m_G1Charset = AsciiCharset;
+ break;
+
+ case '0': // Special Graphics Charset
+ m_G1Charset = SpecialGraphicsCharset;
+ break;
+
+ case 'A': // UK Charset
+ case '1': // Alternate Character ROM Standard Charset
+ case '2': // Alternate Character ROM Special Graphics Charset
+ default: // Unsupported
+ return false;
+
+ }
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessSGR(void)
+{
+ for (int index = 0; index < m_ParameterCount; index++)
+ {
+ switch (m_Parameters[index])
+ {
+ case 0:
+ m_Attribute = kDefaultAttribute;
+ break;
+
+ case 1:
+ m_Attribute |= FOREGROUND_INTENSITY;
+ break;
+
+ case 4:
+ m_Attribute |= COMMON_LVB_UNDERSCORE;
+ break;
+
+ case 5:
+ // Blinking isn't supported
+ break;
+
+ case 7:
+ m_Attribute |= COMMON_LVB_REVERSE_VIDEO;
+ break;
+
+ case 22:
+ m_Attribute &= ~FOREGROUND_INTENSITY;
+ break;
+
+ case 24:
+ m_Attribute &= ~COMMON_LVB_UNDERSCORE;
+ break;
+
+ case 25:
+ // Blinking isn't supported
+ break;
+
+ case 27:
+ m_Attribute &= ~COMMON_LVB_REVERSE_VIDEO;
+ break;
+
+ case 30: // Black text
+ m_Attribute &= ~(FOREGROUND_INTENSITY | COMMON_LVB_UNDERSCORE |
+ FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ break;
+
+ case 31: // Red text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_RED;
+ break;
+
+ case 32: // Green text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_GREEN;
+ break;
+
+ case 33: // Yellow text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_RED | FOREGROUND_GREEN;
+ break;
+
+ case 34: // Blue text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_BLUE;
+ break;
+
+ case 35: // Magenta text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_RED | FOREGROUND_BLUE;
+ break;
+
+ case 36: // Cyan text
+ m_Attribute &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ m_Attribute |= FOREGROUND_GREEN | FOREGROUND_BLUE;
+ break;
+
+ case 37: // White text
+ m_Attribute |= FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+ break;
+
+ case 40: // Black background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ break;
+
+ case 41: // Red background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_RED;
+ break;
+
+ case 42: // Green background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_GREEN;
+ break;
+
+ case 43: // Yellow background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_RED | BACKGROUND_GREEN;
+ break;
+
+ case 44: // Blue background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_BLUE;
+ break;
+
+ case 45: // Magenta background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_RED | BACKGROUND_BLUE;
+ break;
+
+ case 46: // Cyan background
+ m_Attribute &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
+ m_Attribute |= BACKGROUND_GREEN | BACKGROUND_BLUE;
+ break;
+
+ case 47: // White background
+ m_Attribute |= BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
+ break;
+
+ default:
+ assert(false);
+ break;
+ }
+ }
+
+ UpdateTextAttribute();
+
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessSM(void)
+{
+
+ dbglog("ProcessSM: start, priv=%d param0=%d cnt=%d\n",
+ m_bPrivateParameters,m_Parameters[0],m_ParameterCount);
+ if (m_bPrivateParameters)
+ {
+ for (int index = 0; index < m_ParameterCount; index++)
+ {
+ switch (m_Parameters[0])
+ {
+ case 0:
+ default:
+ assert(false);
+ break;
+ case DECCKM:
+ m_bCursorKeyMode = true;
+ break;
+ case DECANM:
+ m_bAnsiMode = true;
+ break;
+ case DECCOLM:
+ m_bColumnMode = true;
+ break;
+ case DECSCLM:
+ m_bScrollingMode = true;
+ break;
+ case DECSCNM:
+ m_bScreenMode = true;
+ break;
+ case DECOM:
+ m_bOriginMode = true;
+ m_Cursor.X = 0;
+ m_Cursor.Y = 0;
+ m_SavedCursor = m_Cursor;
+ SetCursorPosition();
+ break;
+ case DECAWM:
+ m_bAutoWrapMode = true;
+ break;
+ case DECARM:
+ m_bAutoRepeatingMode = true;
+ break;
+ case DECINLM:
+ m_bInterlaceMode = true;
+ break;
+ case DECTCEM:
+ m_bDisplayCursor = true;
+ DisplayCursor();
+ break;
+ }
+ }
+ }
+ else
+ {
+ for (int index = 0; index < m_ParameterCount; index++)
+ {
+ switch (m_Parameters[0])
+ {
+ case 20: m_bLineFeedNewLineMode = true; break; // LNM
+ default:
+ dbglog("ProcessSM: param %d != 20\n",m_Parameters[0]);
+ assert(false); break;
+ }
+ }
+ }
+ return true;
+}
+
+bool
+CAnsiTerm::ProcessTBC(void)
+{
+ // Soft Tab Clear - Not implemented yet
+ return true;
+}
+
+static CAnsiTerm *g_pDisplay;
+
+typedef unsigned char uchar;
+
+extern "C"
+{
+
+void console_open(char fdebugcmd)
+{
+ g_pDisplay = new CAnsiTerm();
+}
+
+void console_close(void)
+{
+ delete g_pDisplay;
+ g_pDisplay = NULL;
+}
+
+int console_in(DWORD keydata, uchar *pdata, int len)
+{
+ if (keydata == ~0)
+ {
+ g_pDisplay->WindowSizeChanged(false);
+ return 0;
+ }
+
+ return g_pDisplay->ProcessInput(*(CAnsiTerm::KeyCode *)&keydata, pdata, len);
+}
+
+void console_out(uchar *pdata, int len)
+{
+ if (len > 0)
+ {
+ g_pDisplay->ProcessOutput(pdata, len);
+ }
+}
+
+}
diff --git a/util/AnsiTerm.h b/util/AnsiTerm.h
new file mode 100644
index 0000000..13d10f2
--- /dev/null
+++ b/util/AnsiTerm.h
@@ -0,0 +1,316 @@
+/*
+ * AnsiTerm.h
+ * Windows ANSI Terminal Emulation
+ *
+ * Author: Robert Nelson robertnelson at users.sourceforge.net
+ * Copyright (c) 2009 Robert Nelson
+ *
+ * 10/07/09 Robert Nelson - Created
+ * See ChangeLog for further changes
+ */
+
+/*
+Copyright (c) 2009, Robert Nelson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#pragma once
+
+class CAnsiTerm
+{
+public:
+ struct KeyCode
+ {
+ unsigned char bKeyDown:1;
+ unsigned char bEnhanced:1;
+ unsigned char bCapsLock:1;
+ unsigned char bScrollLock:1;
+ unsigned char bNumLock:1;
+ unsigned char bShift:1;
+ unsigned char bControl:1;
+ unsigned char bAlt:1;
+ unsigned char RepeatCount;
+ unsigned char VirtualKeyCode;
+ unsigned char AsciiChar;
+ };
+
+private:
+ enum ControlCharacters
+ {
+ CH_NUL = 0x00, // Ignored on input
+ CH_ENQ = 0x05, // Transmit answerback
+ CH_BEL = 0x07, // Ring Bell
+ CH_BS = 0x08, // Move left one character, no effect in column 0
+ CH_HT = 0x09, // Tab
+ CH_LF = 0x0A, // Line feed or new line depending on line mode
+ CH_VT = 0x0B, // Vertical tab, same as line feed
+ CH_FF = 0x0C, // Form feed, same as line feed
+ CH_CR = 0x0D, // Carriage return, return to column 0
+ CH_SO = 0x0E, // Shift Out, Invoke G1 charset
+ CH_SI = 0x0F, // Shift In, Invoke G0 charset
+ CH_XON = 0x11, // Resume transmission
+ CH_XOF = 0x13, // Suspend transmission
+ CH_CAN = 0x18, // Cancel, aborts the current control sequence
+ CH_SUB = 0x1A, // Same as Cancel
+ CH_ESC = 0x1B, // Escape, start of control sequence
+ CH_DEL = 0x7F // Delete, ignored
+ };
+
+ enum DECModes
+ {
+ DECCKM = 1, // Cursor Key Mode (set = application codes)
+ DECANM = 2, // Ansi Mode (set = ansi)
+ DECCOLM = 3, // 80/132 Column Mode (set = 132)
+ DECSCLM = 4, // Scroll Mode (set = smooth)
+ DECSCNM = 5, // Screen Mode (set = black on white)
+ DECOM = 6, // Origin Mode (set = origin relative to top margin)
+ DECAWM = 7, // Autowrap Mode (set = wrap)
+ DECARM = 8, // Autorepeat Mode (set = repeat)
+ DECINLM = 9, // Interlace Mode (set = interlace)
+ DECTCEM = 25 // Text Cursor Enable Mode
+
+ };
+
+ enum DisplayState
+ {
+ DS_None,
+ DS_Normal,
+ DS_UTF8,
+ DS_Escape,
+ DS_CSIParam,
+ DS_DECPrivate,
+ DS_SelectG0,
+ DS_SelectG1
+ };
+
+ enum SelectedCharset
+ {
+ CharsetG0,
+ CharsetG1
+ };
+
+ enum CharacterSet
+ {
+ AsciiCharset = 0,
+ SpecialGraphicsCharset = 1,
+ UKCharset = 2
+ };
+
+ enum EraseType
+ {
+ EraseCursorToEnd = 0,
+ EraseBeginningToCursor = 1,
+ EraseAll = 2
+ };
+
+ static const int kMaxParameterCount = 16;
+
+ static const int kOutputBufferSize = 256;
+
+ static const int kMinGraphicsChar = 0x5F;
+ static const int kMaxGraphicsChar = 0x7E;
+
+ static const int kColorTableSize = 16;
+
+ static const WORD kDefaultAttribute = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+
+ struct CSICode
+ {
+ char chCode;
+ DisplayState dsNextState;
+ bool (CAnsiTerm::*pfnProcess)(void);
+ };
+
+ struct CSIFunction
+ {
+ char chCode;
+ bool (CAnsiTerm::*pfnProcess)(void);
+ };
+
+protected:
+ typedef struct _CONSOLE_SCREEN_BUFFER_INFOEX {
+ ULONG cbSize;
+ COORD dwSize;
+ COORD dwCursorPosition;
+ WORD wAttributes;
+ SMALL_RECT srWindow;
+ COORD dwMaximumWindowSize;
+ WORD wPopupAttributes;
+ BOOL bFullscreenSupported;
+ COLORREF ColorTable[16];
+ } CONSOLE_SCREEN_BUFFER_INFOEX, *PCONSOLE_SCREEN_BUFFER_INFOEX;
+
+ typedef BOOL (WINAPI *PFN_GetConsoleScreenBufferInfoEx)(
+ HANDLE hConsoleOutput,
+ PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
+
+ typedef BOOL (WINAPI *PFN_SetConsoleScreenBufferInfoEx)(
+ HANDLE hConsoleOutput,
+ PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
+
+ static PFN_GetConsoleScreenBufferInfoEx s_pfnGetConsoleScreenBufferInfoEx;
+ static PFN_SetConsoleScreenBufferInfoEx s_pfnSetConsoleScreenBufferInfoEx;
+
+private:
+ static CSICode s_CSITable[];
+ static CSIFunction s_DECFunction[];
+ static CSIFunction s_CSIFunction[];
+ static wchar_t s_GraphicChars[kMaxGraphicsChar - kMinGraphicsChar + 1];
+ static wchar_t s_OemToUnicode[256];
+ static COLORREF s_ColorTable[kColorTableSize];
+
+
+public:
+ CAnsiTerm(void);
+ virtual ~CAnsiTerm(void);
+
+ void WindowSizeChanged(bool bInitial);
+
+ int ProcessInput(KeyCode keyCode, unsigned char *pOutput, int iOutputLen);
+
+ bool ProcessOutput(const unsigned char *szData, int iLength);
+
+protected:
+ virtual bool ResetTerm(void);
+ virtual bool GetCursorPosition(void);
+ virtual bool SetCursorPosition(void);
+ virtual bool DisplayCursor(void);
+
+ virtual bool ScrollDisplay(int nLines, bool bWindowOnly);
+ virtual bool EraseLine(EraseType eType);
+ virtual bool EraseDisplay(EraseType eType);
+ virtual bool UpdateTextAttribute(void);
+
+ virtual DWORD OutputText(void);
+
+private:
+ bool ProcessBackspace(void);
+ bool ProcessTab(void);
+ bool ProcessLinefeed(bool bNewLine);
+ bool ProcessReverseLinefeed(void);
+ bool ProcessReturn(void);
+
+ void AddOutputData(wchar_t wchData)
+ {
+ m_OutputBuffer[m_dwOutputCount++] = wchData;
+
+ if (m_dwOutputCount >= kOutputBufferSize)
+ {
+ OutputText();
+ }
+ }
+
+ void DisplayCSI(char ch);
+
+ bool ProcessSCSG0(char ch);
+ bool ProcessSCSG1(char ch);
+
+ bool ProcessDECALN(void);
+ bool ProcessDECDHLB(void);
+ bool ProcessDECDHLT(void);
+ bool ProcessDECDWL(void);
+ bool ProcessDECID(void);
+ bool ProcessDECKPAM(void);
+ bool ProcessDECKPNM(void);
+ bool ProcessDECLL(void);
+ bool ProcessDECRC(void);
+ bool ProcessDECREQTPARM(void);
+ bool ProcessDECSC(void);
+ bool ProcessDECSTBM(void);
+ bool ProcessDECSWL(void);
+ bool ProcessDECTST(void);
+
+ bool ProcessCUB(void);
+ bool ProcessCUD(void);
+ bool ProcessCUF(void);
+ bool ProcessCUP(void);
+ bool ProcessCUU(void);
+ bool ProcessDA(void);
+ bool ProcessDSR(void);
+ bool ProcessED(void);
+ bool ProcessEL(void);
+ bool ProcessHTS(void);
+ bool ProcessHVP(void);
+ bool ProcessIND(void);
+ bool ProcessNEL(void);
+ bool ProcessRCP(void);
+ bool ProcessRI(void);
+ bool ProcessRIS(void);
+ bool ProcessRM(void);
+ bool ProcessSCP(void);
+ bool ProcessSGR(void);
+ bool ProcessSM(void);
+ bool ProcessTBC(void);
+
+private:
+ HANDLE m_hConsole;
+ DWORD m_dwOrigConsoleMode;
+ WORD m_wOrigConsoleAttribute;
+ DWORD m_dwOrigCursorSize;
+ COLORREF m_OrigColorTable[kColorTableSize];
+ bool m_bResetColorTable;
+ DisplayState m_State;
+
+ SelectedCharset m_SelectedCharset;
+ CharacterSet m_G0Charset;
+ CharacterSet m_G1Charset;
+
+ COORD m_BufferSize;
+ COORD m_WindowSize;
+ COORD m_WindowOrigin;
+ COORD m_Cursor;
+ COORD m_SavedCursor;
+ SHORT m_sTopMargin;
+ SHORT m_sBottomMargin;
+ WORD m_Attribute;
+ wchar_t m_OutputBuffer[kOutputBufferSize];
+ DWORD m_dwOutputCount;
+
+ unsigned char m_UTF8Buffer[3];
+ int m_UTF8Count;
+ int m_UTF8Size;
+
+ int m_Parameters[kMaxParameterCount];
+ int m_ParameterCount;
+ bool m_bParametersStart;
+ bool m_bPrivateParameters;
+
+ // Modes
+ bool m_bLineFeedNewLineMode; // LNM
+ bool m_bCursorKeyMode; // DECCKM
+// Always set - VT52 not supported
+ bool m_bAnsiMode; // DECANM
+// Not used - column width is based on width of console window
+ bool m_bColumnMode; // DECCOLM
+// Not used - always reset
+ bool m_bScrollingMode; // DECSCLM
+// Not implemented - always reset
+ bool m_bScreenMode; // DECSCNM
+ bool m_bOriginMode; // DECOM
+ bool m_bAutoWrapMode; // DECAWM
+// Not implemented - always set
+ bool m_bAutoRepeatingMode; // DECARM
+// Not implemented - always reset
+ bool m_bInterlaceMode; // DECINLM
+ bool m_bDisplayCursor; // DECTCEM
+};
diff --git a/util/Makefile.am b/util/Makefile.am
new file mode 100644
index 0000000..3726107
--- /dev/null
+++ b/util/Makefile.am
@@ -0,0 +1,200 @@
+
+localedir = $(datadir)/locale
+INCLUDES = -I..
+OS_CF = @OS_CFLAGS@ @CROSS_CFLAGS@
+OS_LF = @OS_LFLAGS@ @CROSS_LFLAGS@
+AM_CPPFLAGS = $(OS_CF) -DLOCALEDIR=\"$(localedir)\"
+AM_CPPFLAGS += @IA64_CFLAGS@ @GPL_CFLAGS@
+LDADD = $(OS_LF)
+LDSAM = $(OS_LF) @LD_SAMX@
+CFLAGS_SAMX = -O2 -g -I. -I.. $(OS_CF) @LANPLUS_CFLAGS@
+CFLAGS_SAM = -O2 -g -I. -I.. $(OS_CF)
+# May be /usr/bin/install or /bin/install
+INSTALLBIN = install -c
+extradir = $(datadir)/ipmiutil
+inc_dir = $(includedir)
+tmpobj = obj
+tmpwin = tmp
+LIBDIR = @LIB_DIR@
+
+CMDMOD = ipmicmd.c mem_if.c ipmidir.c imbapi.c ipmimv.c ipmild.c ipmibmc.c ipmilipmi.c subs.c
+CMDMOD += md5.c md2.c ipmilan.c
+CMDMOD += ipmilanplus.c
+# CMDMOD = ipmicmd.c mem_if.c @OS_DRIVERS@
+# am: configure substitutions are not allowed in _SOURCES variables
+LIBOBJ = ipmicmd.o mem_if.o ipmidir.o imbapi.o ipmimv.o ipmild.o ipmibmc.o ipmilipmi.o subs.o md5.o md2.o $(tmpobj)/ipmilan.o $(tmpobj)/ipmilanplus.o
+OEMMOD = oem_kontron.c oem_fujitsu.c oem_intel.c oem_sun.c oem_supermicro.c oem_dell.c oem_quanta.c oem_hp.c oem_newisys.c iekanalyzer.c
+
+
+AM_CPPFLAGS += -I. -I.. -DMETACOMMAND
+METASOURCE = ipmiutil.c ialarms.c ihealth.c ievents.c ifru.c ifru_picmg.c igetevent.c ireset.c icmd.c ilan.c isensor.c isel.c iserial.c iwdt.c isol.c idiscover.c iconfig.c ipicmg.c ifirewall.c ifwum.c ihpm.c itsol.c idcmi.c $(OEMMOD) $(CMDMOD)
+LDADD += -lpthread
+
+# The LanDesk library is proprietary, so it is incompatible with ALLOW_GPL.
+# To build with LanDesk support:
+# First copy the library to ../lib/libipmiapi.a
+# Then ./configure --enable-landesk
+# Result:
+# AM_CPPFLAGS += -DLINK_LANDESK
+# LDADD += -lipmiapi -L../lib
+AM_CPPFLAGS += @LANDESK_CFLAGS@
+LDADD += @LANDESK_LDADD@
+
+# For lanplus plugin support (IPMI LAN 2.0 RMCP+) used by SOL:
+# If ./configure --disable-lanplus
+# AM_CPPFLAGS +=
+# LDADD +=
+# Otherwise default result is lanplus enabled:
+# AM_CPPFLAGS += -DHAVE_LANPLUS
+# LDADD += -L../lib -lipmi_lanplus -L/usr/local/lib -lcrypto
+# LDADD += -L../lib -lintf_lanplus -L/usr/local/lib -lcrypto (older)
+# Could also use CMDMOD += ipmilan2.c instead, if completed.
+AM_CPPFLAGS += @LANPLUS_CFLAGS@
+LDADD += @LANPLUS_LIB@ @LANPLUS_CRYPTO@
+LANPLUS_OBJ = $(shell ar t @LANPLUS_LIB@ 2>/dev/null)
+
+# sbin_PROGRAMS are built by default and copied to /usr/sbin at install time
+# EXTRA_PROGRAMS are built by default but not included in the install package
+# TESTPROGS are not built by default. To build, do 'make ifruset', for example.
+bin_PROGRAMS = ipmiutil ievents idiscover
+sbin_PROGRAMS = ipmi_port iseltime
+DEV_LIB = libipmiutil.a
+SHR_LIB = libipmiutil.so
+SHRLINK = @SHR_LINK@
+EXTRA_PROGRAMS = ipmi_sample ipmi_sample_evt
+TESTPROGS = libimbapi.a iconfig ipmimv ifruset ipmi_sample2 ialarms_enc
+# OLDPROGS are old/previous binaries that may exist and need to be deleted.
+OLDPROGS = alarms bmchealth fruconfig getevent hwreset icmd isolconsole pefconfig sensor showsel tmconfig wdt
+
+# To build an imb api library (libimbapi.a):
+libimbapi.a: imbapi.c
+ mkdir -p $(tmpobj)
+ $(CC) -I. -I.. $(OS_CF) -fPIC $(CFLAGS) -o $(tmpobj)/imbapi.o -c imbapi.c
+ $(AR) cru libimbapi.a $(tmpobj)/imbapi.o
+ $(RANLIB) libimbapi.a
+ rm -f $(tmpobj)/imbapi.o
+
+# Build a lib to support all of the IPMI drivers (libipmiutil.a)
+# If LANPLUS_SAM = yes, include LANPLUS_OBJ, else do not.
+# See configure --enable-liblanplus to change this
+$(DEV_LIB): $(CMDMOD:.c=.o) @LANPLUS_LIB@
+ mkdir -p $(tmpobj)
+ if [ "x@LANPLUS_SAM@" = "xyes" ]; then \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ ar x @LANPLUS_LIB@ ; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) $(LANPLUS_OBJ); \
+ $(RANLIB) $(DEV_LIB); \
+ else \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) ; \
+ $(RANLIB) $(DEV_LIB) ; \
+ fi
+
+$(SHR_LIB): $(CMDMOD:.c=.o) @LANPLUS_LIB@
+ mkdir -p $(tmpobj)
+ if [ "x@LANPLUS_SAM@" = "xyes" ]; then \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ ar x @LANPLUS_LIB@ ; \
+ $(CC) $(LDFLAGS) -shared -o $(SHR_LIB) $(LIBOBJ) $(LANPLUS_OBJ); \
+ else \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ $(CC) $(LDFLAGS) -shared -o $(SHR_LIB) $(LIBOBJ) ; \
+ fi
+
+# To build ipmiutil, need to use METACFLAGS for each .c/.o
+
+idiscover$(EXEEXT): idiscover.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) $(OS_LF) -o idiscover idiscover.c
+
+ipmimv: ipmimv.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -DTEST_BIN -o ipmimv ipmimv.c
+
+ievents$(EXEEXT): ievents.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -DALONE -o ievents ievents.c
+
+ipmi_sample: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -c ipmi_sample.c
+ $(CC) -g -O2 -o ipmi_sample ipmi_sample.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ialarms_enc: $(DEV_LIB) ialarms.c oem_intel.c
+ $(CC) $(CFLAGS_SAM) -DTEST_ENC -o ialarms2.o -c ialarms.c
+ $(CC) $(CFLAGS_SAM) -DNO_EVENTS -o oem_intel2.o -c oem_intel.c
+ $(CC) -g -O2 -o ialarms_enc ialarms2.o oem_intel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifru_picmg2.o: ifru_picmg.c
+ $(CC) $(CFLAGS_SAM) -o ifru_picmg2.o -c ifru_picmg.c
+
+# To build ipmi_sample with GET_SENSORS enabled, need isensors.o, ievents.o
+# Note that this does not include oem_intel, etc. for OEM SEL decoding.
+ipmi_sample2: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c ifru.c isel.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -D GET_SENSORS -D GET_FRU -o ipmi_sample2.o -c ipmi_sample.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -o ievents2.o -c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ifru2.o -c ifru.c
+ $(CC) $(CFLAGS_SAM) -o isel2.o -c isel.c
+ $(CC) -g -O2 -o ipmi_sample2 ipmi_sample2.o isensor2.o ievents2.o ifru2.o ifru_picmg2.o isel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ipmi_sample_evt: $(DEV_LIB) ipmi_sample_evt.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ipmi_sample_evt.o -c ipmi_sample_evt.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -DSENSORS_OK -o ievents2.o -c ievents.c
+ $(CC) -g -O2 -o ipmi_sample_evt ipmi_sample_evt.o isensor2.o ievents2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifruset: $(DEV_LIB) ifruset.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -c ifruset.c
+ $(CC) -g -O2 -o ifruset ifruset.o ifru_picmg2.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+iseltime: $(DEV_LIB) iseltime.c
+ $(CC) $(CFLAGS_SAM) -c iseltime.c
+ $(CC) -g -O2 -o iseltime iseltime.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+ipmi_port$(EXEEXT): ipmi_port.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -o ipmi_port ipmi_port.c
+
+iconfig: iconfig.c $(DEV_LIB)
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -o iconfig iconfig.c $(DEV_LIB) @LANPLUS_CRYPTO@
+
+# @LANPLUS_LIB@ is ../lib/libipmi_lanplus.a
+../lib/libipmi_lanplus.a:
+ cd ../lib; make
+
+ipmiutil_SOURCES = $(METASOURCE)
+
+ipmiutil$(EXEEXT): $(METASOURCE:.c=.o) @LANPLUS_LIB@
+ $(CC) $(CFLAGS) $(LDFLAGS) -o ipmiutil $(METASOURCE:.c=.o) $(LDADD)
+
+ievents_SOURCES = ievents.c
+
+idiscover_SOURCES = idiscover.c
+
+ipmi_port_SOURCES = ipmi_port.c
+
+
+EXTRA_DIST = imb_api.h ipmicmd.h ipmidir.h ipmilan.h ipmilanplus.h AnsiTerm.h ifirewall.h ifwum.h ihpm.h ipicmg.h ipmiutil.h md2.h oem_dell.h oem_fujitsu.h oem_intel.h oem_kontron.h oem_sun.h idcmi.h isensor.h iekanalyzer.h
+
+all-am: Makefile $(bin_PROGRAMS) $(sbin_PROGRAMS) $(EXTRA_PROGRAMS) $(DEV_LIB) $(SHRLINK)
+
+install-data-am: $(EXTRA_PROGRAMS) $(DEV_LIB) $(SHRLINK)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(extradir)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(LIBDIR)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f ipmi_sample.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmi_sample_evt.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmicmd.h $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f isensor.c ievents.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f isensor.h ievents.h $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f Makefile.sample $(DESTDIR)$(extradir)/Makefile
+ @INS_LIB@ cp -f $(DEV_LIB) $(DESTDIR)$(LIBDIR)
+ if [ "x$(SHRLINK)" != "x" ]; then \
+ @INS_LIB@ cp -f $(SHR_LIB) $(DESTDIR)$(LIBDIR) ; \
+ fi
+
+clean-generic:
+ rm -f $(DEV_LIB) $(EXTRA_PROGRAMS) $(OLDPROGS) $(TESTPROGS) $(SHRLINK)
+ if [ -d $(tmpobj) ]; then rm -rf $(tmpobj) ; fi
+ if [ -d $(tmpwin) ]; then rm -rf $(tmpwin) ; fi
+ rm -f *.log *.tmp debug*.list *.o *.pdb *.lo *.la *.so
diff --git a/util/Makefile.am-so b/util/Makefile.am-so
new file mode 100644
index 0000000..97d9c34
--- /dev/null
+++ b/util/Makefile.am-so
@@ -0,0 +1,241 @@
+
+localedir = $(datadir)/locale
+INCLUDES = -I. -I..
+OS_CF = @OS_CFLAGS@ @CROSS_CFLAGS@
+OS_LF = @OS_LFLAGS@ @CROSS_LFLAGS@
+AM_CPPFLAGS = $(OS_CF) -DLOCALEDIR=\"$(localedir)\"
+AM_CPPFLAGS += @IA64_CFLAGS@ @GPL_CFLAGS@
+LDADD = $(OS_LF)
+LDSAM = $(OS_LF) @LD_SAMX@
+CFLAGS_SAMX = -O2 -g -I. -I.. $(OS_CF) @LANPLUS_CFLAGS@
+CFLAGS_SAM = -O2 -g -I. -I.. $(OS_CF)
+# May be /usr/bin/install or /bin/install
+INSTALLBIN = install -c
+extradir = $(datadir)/ipmiutil
+inc_dir = $(includedir)
+tmpobj = obj
+tmpwin = tmp
+LIBDIR = @LIB_DIR@
+
+CMDSRC = ipmicmd.c mem_if.c ipmidir.c imbapi.c ipmimv.c ipmild.c ipmibmc.c ipmilipmi.c subs.c
+CMDSRC += md5.c md2.c ipmilan.c
+CMDSRC += ipmilanplus.c
+# CMDSRC = ipmicmd.c mem_if.c @OS_DRIVERS@
+# am: configure substitutions are not allowed in _SOURCES variables
+CMDOBJ = $(tmpobj)/ipmicmd.o $(tmpobj)/mem_if.o $(tmpobj)/ipmidir.o $(tmpobj)/imbapi.o $(tmpobj)/ipmimv.o $(tmpobj)/ipmild.o $(tmpobj)/ipmibmc.o $(tmpobj)/ipmilipmi.o $(tmpobj)/subs.o $(tmpobj)/md5.o $(tmpobj)/md2.o $(tmpobj)/ipmilan.o $(tmpobj)/ipmilanplus.o
+LIBOBJ = $(CMDOBJ)
+OEMMOD = oem_kontron.c oem_fujitsu.c oem_intel.c oem_sun.c iekanalyzer.c oem_supermicro.c oem_dell.c oem_quanta.c oem_hp.c oem_newisys.c
+
+
+AM_CPPFLAGS += -I. -I.. -DMETACOMMAND
+METASOURCE = ipmiutil.c ialarms.c ihealth.c ievents.c ifru.c ifru_picmg.c igetevent.c ireset.c icmd.c ilan.c isensor.c isel.c iserial.c iwdt.c isol.c idiscover.c iconfig.c ipicmg.c ifirewall.c ifwum.c ihpm.c itsol.c idcmi.c $(OEMMOD)
+LDADD += -lpthread
+
+# The LanDesk library is proprietary, so it is incompatible with ALLOW_GPL.
+# To build with LanDesk support:
+# First copy the library to ../lib/libipmiapi.a
+# Then ./configure --enable-landesk
+# Result:
+# AM_CPPFLAGS += -DLINK_LANDESK
+# LDADD += -lipmiapi -L../lib
+AM_CPPFLAGS += @LANDESK_CFLAGS@
+LDADD += @LANDESK_LDADD@
+
+# For lanplus plugin support (IPMI LAN 2.0 RMCP+) required by SOL:
+# If ./configure --disable-lanplus
+# AM_CPPFLAGS +=
+# LDADD +=
+# LANPLUS_SRC =
+# Otherwise default result is lanplus enabled:
+# AM_CPPFLAGS += -DHAVE_LANPLUS
+# LDADD += -L../lib -lipmi_lanplus -L/usr/local/lib -lcrypto
+# LDADD += -L../lib -lintf_lanplus -L/usr/local/lib -lcrypto (older)
+# LANPLUS_SRC = $(LANPLUS_DIR)/lanplus.c ...
+AM_CPPFLAGS += @LANPLUS_CFLAGS@ -I../lib/lanplus -I../lib/lanplus/inc
+LDADD += @LANPLUS_LIB@ @LANPLUS_CRYPTO@
+LANPLUS_OBJ = $(shell ar t @LANPLUS_LIB@ 2>/dev/null)
+LANPLUS_DIR = ../lib/lanplus
+LANPLUS_SRC = $(LANPLUS_DIR)/lanplus.c $(LANPLUS_DIR)/lanplus_dump.c \
+ $(LANPLUS_DIR)/lanplus_strings.c $(LANPLUS_DIR)/lanplus_crypt.c \
+ $(LANPLUS_DIR)/lanplus_crypt_impl.c $(LANPLUS_DIR)/helper.c \
+ $(LANPLUS_DIR)/ipmi_strings.c
+
+# sbin_PROGRAMS are built by default and copied to /usr/sbin at install time
+# EXTRA_PROGRAMS are built by default but not included in the install package
+# TESTPROGS are not built by default. To build, do 'make ifruset', for example.
+bin_PROGRAMS = ipmiutil ievents idiscover
+sbin_PROGRAMS = ipmi_port
+DEV_LIB = libipmiutil.a
+EXTRA_PROGRAMS = ipmi_sample ipmi_sample_evt
+TESTPROGS = libimbapi.a iconfig ipmimv ifruset ipmi_sample2 ialarms_enc iseltime
+# OLDPROGS are old/previous binaries that may exist and need to be deleted.
+OLDPROGS = alarms bmchealth fruconfig getevent hwreset icmd isolconsole pefconfig sensor showsel tmconfig wdt
+
+lib_LTLIBRARIES = libipmiutil.la
+libipmiutil_la_SOURCES = $(CMDSRC) $(LANPLUS_SRC)
+libipmiutil_la_LDFLAGS = -export-dynamic
+
+# To build an imb api library (libimbapi.a):
+libimbapi.a: imbapi.c
+ mkdir -p $(tmpobj)
+ $(CC) -I. -I.. $(OS_CF) -fPIC $(CFLAGS) -o $(tmpobj)/imbapi.o -c imbapi.c
+ $(AR) cru libimbapi.a $(tmpobj)/imbapi.o
+ $(RANLIB) libimbapi.a
+ rm -f $(tmpobj)/imbapi.o
+
+# Build a lib to support all of the IPMI drivers (libipmiutil.a)
+# If LANPLUS_SAM = yes, include LANPLUS_OBJ, else do not.
+# See configure --enable-liblanplus to change this
+$(DEV_LIB): $(CMDOBJ) @LANPLUS_LIB@
+ mkdir -p $(tmpobj)
+ if [ "x@LANPLUS_SAM@" = "xyes" ]; then \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ ar x @LANPLUS_LIB@ ; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) $(LANPLUS_OBJ); \
+ $(RANLIB) $(DEV_LIB); \
+ else \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) ; \
+ $(RANLIB) $(DEV_LIB) ; \
+ fi
+ rm -f $(tmpobj)/ipmilan.o $(tmpobj)/ipmilanplus.o
+
+# To build ipmiutil, need to use METACFLAGS for each .c/.o
+
+idiscover: idiscover.c
+ $(CC) $(OS_CF) $(CFLAGS) $(LDFLAGS) $(OS_LF) -o idiscover idiscover.c
+
+ipmimv: ipmimv.c
+ $(CC) $(OS_CF) $(CFLAGS) $(LDFLAGS) -DTEST_BIN -o ipmimv ipmimv.c
+
+ievents: ievents.c
+ $(CC) $(OS_CF)$(CFLAGS) $(LDFLAGS) -DALONE -o ievents ievents.c
+
+ipmi_sample: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -c ipmi_sample.c
+ $(CC) -g -O2 -o ipmi_sample ipmi_sample.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ialarms_enc: $(DEV_LIB) ialarms.c oem_intel.c
+ $(CC) $(CFLAGS_SAM) -DTEST_ENC -o ialarms2.o -c ialarms.c
+ $(CC) $(CFLAGS_SAM) -DNO_EVENTS -o oem_intel2.o -c oem_intel.c
+ $(CC) -g -O2 -o ialarms_enc ialarms2.o oem_intel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifru_picmg2.o: ifru_picmg.c
+ $(CC) $(CFLAGS_SAM) -o ifru_picmg2.o -c ifru_picmg.c
+
+# To build ipmi_sample with GET_SENSORS enabled, need isensors.o, ievents.o
+# Note that this does not include oem_intel, etc. for OEM SEL decoding.
+ipmi_sample2: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c ifru.c isel.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -D GET_SENSORS -D GET_FRU -o ipmi_sample2.o -c ipmi_sample.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -o ievents2.o -c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ifru2.o -c ifru.c
+ $(CC) $(CFLAGS_SAM) -o isel2.o -c isel.c
+ $(CC) -g -O2 -o ipmi_sample2 ipmi_sample2.o isensor2.o ievents2.o ifru2.o ifru_picmg2.o isel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ipmi_sample_evt: $(DEV_LIB) ipmi_sample_evt.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ipmi_sample_evt.o -c ipmi_sample_evt.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -DSENSORS_OK -o ievents2.o -c ievents.c
+ $(CC) -g -O2 -o ipmi_sample_evt ipmi_sample_evt.o isensor2.o ievents2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifruset: $(DEV_LIB) ifruset.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -c ifruset.c
+ $(CC) -g -O2 -o ifruset ifruset.o ifru_picmg2.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+iseltime: $(DEV_LIB) iseltime.c
+ $(CC) $(CFLAGS_SAM) -c iseltime.c
+ $(CC) -g -O2 -o iseltime iseltime.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+ipmi_port: ipmi_port.c
+ $(CC) $(CFLAGS) $(LDFLAGS) -o ipmi_port ipmi_port.c
+
+#xmlconfig: xmlconfig.c $(DEV_LIB)
+# $(CC) $(CFLAGS) $(LDFLAGS) -o xmlconfig xmlconfig.c libipmiutil.a @LANPLUS_CRYPTO@
+
+iconfig: iconfig.c $(DEV_LIB)
+ $(CC) $(CFLAGS) $(LDFLAGS) -o iconfig iconfig.c $(DEV_LIB) @LANPLUS_CRYPTO@
+
+# @LANPLUS_LIB@ is ../lib/libipmi_lanplus.a
+../lib/libipmi_lanplus.a:
+ cd ../lib; make
+
+ipmiutil_SOURCES = $(METASOURCE)
+
+ipmiutil: $(METASOURCE:.c=.o) $(CMDOBJ) @LANPLUS_LIB@
+ $(CC) $(CFLAGS) $(LDFLAGS) -o ipmiutil $(METASOURCE:.c=.o) $(CMDOBJ) $(LDADD)
+
+$(tmpobj)/ipmicmd.o: ipmicmd.c
+ mkdir -p $(tmpobj)
+ @$(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmicmd.o -c ipmicmd.c
+
+$(tmpobj)/subs.o: subs.c
+ @$(CC) $(CFLAGS_SAMX) -o $(tmpobj)/subs.o -c subs.c
+
+$(tmpobj)/mem_if.o: mem_if.c
+ @$(CC) $(CFLAGS_SAMX) -o $(tmpobj)/mem_if.o -c mem_if.c
+
+$(tmpobj)/ipmidir.o: ipmidir.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmidir.c
+
+$(tmpobj)/imbapi.o: imbapi.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c imbapi.c
+
+$(tmpobj)/ipmimv.o: ipmimv.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmimv.c
+
+$(tmpobj)/ipmild.o: ipmild.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmild.c
+
+$(tmpobj)/ipmibmc.o: ipmibmc.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmibmc.c
+
+$(tmpobj)/ipmilipmi.o: ipmilipmi.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmilipmi.c
+
+$(tmpobj)/ipmilan.o: ipmilan.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmilan.c
+
+$(tmpobj)/ipmilanplus.o: ipmilanplus.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c ipmilanplus.c
+
+$(tmpobj)/md5.o: md5.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c md5.c
+
+$(tmpobj)/md2.o: md2.c
+ @$(CC) $(CFLAGS_SAMX) -o $@ -c md2.c
+
+#%.o: %.c
+# $(CC) -c $(OS_CF) $(CFLAGS) $(AM_CPPFLAGS) -o $@ $<
+
+ievents_SOURCES = ievents.c
+
+idiscover_SOURCES = idiscover.c
+
+ipmi_port_SOURCES = ipmi_port.c
+
+# xmlconfig_SOURCES = xmlconfig.c $(CMDSRC)
+
+EXTRA_DIST = imb_api.h ipmicmd.h ipmidir.h ipmilan.h ipmilanplus.h AnsiTerm.h iekanalyzer.h ifirewall.h ifwum.h ihpm.h ipicmg.h ipmiutil.h md2.h oem_dell.h oem_fujitsu.h oem_intel.h oem_kontron.h oem_sun.h idcmi.h isensor.h
+
+all-am: Makefile $(DEV_LIB) $(bin_PROGRAMS) $(sbin_PROGRAMS) $(EXTRA_PROGRAMS)
+
+install-data-am: $(EXTRA_PROGRAMS) $(DEV_LIB)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(extradir)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(LIBDIR)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f ipmi_sample.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmi_sample_evt.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmicmd.h $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f isensor.c ievents.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f isensor.h ievents.h $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f Makefile.sample $(DESTDIR)$(extradir)/Makefile
+ @INS_LIB@ cp -f $(DEV_LIB) $(DESTDIR)$(LIBDIR)
+
+clean-generic:
+ rm -f $(DEV_LIB) $(EXTRA_PROGRAMS) $(OLDPROGS) $(TESTPROGS)
+ if [ -d $(tmpobj) ]; then rm -rf $(tmpobj) ; fi
+ if [ -d $(tmpwin) ]; then rm -rf $(tmpwin) ; fi
+ rm -f *.log *.tmp debug*.list *.o *.pdb *.lo *.so *.la
diff --git a/util/Makefile.in b/util/Makefile.in
new file mode 100644
index 0000000..a8eb9b9
--- /dev/null
+++ b/util/Makefile.in
@@ -0,0 +1,766 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005 Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+bin_PROGRAMS = ipmiutil$(EXEEXT) ievents$(EXEEXT) idiscover$(EXEEXT)
+sbin_PROGRAMS = ipmi_port$(EXEEXT) iseltime$(EXEEXT)
+EXTRA_PROGRAMS = ipmi_sample$(EXEEXT) ipmi_sample_evt$(EXEEXT)
+subdir = util
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(sbindir)"
+binPROGRAMS_INSTALL = $(INSTALL_PROGRAM)
+sbinPROGRAMS_INSTALL = $(INSTALL_PROGRAM)
+PROGRAMS = $(bin_PROGRAMS) $(sbin_PROGRAMS)
+am_idiscover_OBJECTS = idiscover.$(OBJEXT)
+idiscover_OBJECTS = $(am_idiscover_OBJECTS)
+idiscover_LDADD = $(LDADD)
+am__DEPENDENCIES_1 =
+idiscover_DEPENDENCIES = $(am__DEPENDENCIES_1)
+am_ievents_OBJECTS = ievents.$(OBJEXT)
+ievents_OBJECTS = $(am_ievents_OBJECTS)
+ievents_LDADD = $(LDADD)
+ievents_DEPENDENCIES = $(am__DEPENDENCIES_1)
+am_ipmi_port_OBJECTS = ipmi_port.$(OBJEXT)
+ipmi_port_OBJECTS = $(am_ipmi_port_OBJECTS)
+ipmi_port_LDADD = $(LDADD)
+ipmi_port_DEPENDENCIES = $(am__DEPENDENCIES_1)
+ipmi_sample_SOURCES = ipmi_sample.c
+ipmi_sample_OBJECTS = ipmi_sample.$(OBJEXT)
+ipmi_sample_LDADD = $(LDADD)
+ipmi_sample_DEPENDENCIES = $(am__DEPENDENCIES_1)
+ipmi_sample_evt_SOURCES = ipmi_sample_evt.c
+ipmi_sample_evt_OBJECTS = ipmi_sample_evt.$(OBJEXT)
+ipmi_sample_evt_LDADD = $(LDADD)
+ipmi_sample_evt_DEPENDENCIES = $(am__DEPENDENCIES_1)
+am__objects_1 = oem_kontron.$(OBJEXT) oem_fujitsu.$(OBJEXT) \
+ oem_intel.$(OBJEXT) oem_sun.$(OBJEXT) oem_supermicro.$(OBJEXT) \
+ oem_dell.$(OBJEXT) oem_quanta.$(OBJEXT) oem_hp.$(OBJEXT) \
+ oem_newisys.$(OBJEXT) iekanalyzer.$(OBJEXT)
+am__objects_2 = ipmicmd.$(OBJEXT) mem_if.$(OBJEXT) ipmidir.$(OBJEXT) \
+ imbapi.$(OBJEXT) ipmimv.$(OBJEXT) ipmild.$(OBJEXT) \
+ ipmibmc.$(OBJEXT) ipmilipmi.$(OBJEXT) subs.$(OBJEXT) \
+ md5.$(OBJEXT) md2.$(OBJEXT) ipmilan.$(OBJEXT) \
+ ipmilanplus.$(OBJEXT)
+am__objects_3 = ipmiutil.$(OBJEXT) ialarms.$(OBJEXT) ihealth.$(OBJEXT) \
+ ievents.$(OBJEXT) ifru.$(OBJEXT) ifru_picmg.$(OBJEXT) \
+ igetevent.$(OBJEXT) ireset.$(OBJEXT) icmd.$(OBJEXT) \
+ ilan.$(OBJEXT) isensor.$(OBJEXT) isel.$(OBJEXT) \
+ iserial.$(OBJEXT) iwdt.$(OBJEXT) isol.$(OBJEXT) \
+ idiscover.$(OBJEXT) iconfig.$(OBJEXT) ipicmg.$(OBJEXT) \
+ ifirewall.$(OBJEXT) ifwum.$(OBJEXT) ihpm.$(OBJEXT) \
+ itsol.$(OBJEXT) idcmi.$(OBJEXT) $(am__objects_1) \
+ $(am__objects_2)
+am_ipmiutil_OBJECTS = $(am__objects_3)
+ipmiutil_OBJECTS = $(am_ipmiutil_OBJECTS)
+ipmiutil_LDADD = $(LDADD)
+ipmiutil_DEPENDENCIES = $(am__DEPENDENCIES_1)
+iseltime_SOURCES = iseltime.c
+iseltime_OBJECTS = iseltime.$(OBJEXT)
+iseltime_LDADD = $(LDADD)
+iseltime_DEPENDENCIES = $(am__DEPENDENCIES_1)
+DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+ $(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(idiscover_SOURCES) $(ievents_SOURCES) $(ipmi_port_SOURCES) \
+ ipmi_sample.c ipmi_sample_evt.c $(ipmiutil_SOURCES) iseltime.c
+DIST_SOURCES = $(idiscover_SOURCES) $(ievents_SOURCES) \
+ $(ipmi_port_SOURCES) ipmi_sample.c ipmi_sample_evt.c \
+ $(ipmiutil_SOURCES) iseltime.c
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CROSS_CFLAGS = @CROSS_CFLAGS@
+CROSS_LFLAGS = @CROSS_LFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+GPL_CFLAGS = @GPL_CFLAGS@
+IA64_CFLAGS = @IA64_CFLAGS@
+INIT_DIR = @INIT_DIR@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INS_LIB = @INS_LIB@
+LANDESK_CFLAGS = @LANDESK_CFLAGS@
+LANDESK_LDADD = @LANDESK_LDADD@
+LANPLUS_CFLAGS = @LANPLUS_CFLAGS@
+LANPLUS_CRYPTO = @LANPLUS_CRYPTO@
+LANPLUS_LDADD = @LANPLUS_LDADD@
+LANPLUS_LIB = @LANPLUS_LIB@
+LANPLUS_SAM = @LANPLUS_SAM@
+LDFLAGS = @LDFLAGS@
+LD_SAMX = @LD_SAMX@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIB_DIR = @LIB_DIR@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+OBJEXT = @OBJEXT@
+OS_CFLAGS = @OS_CFLAGS@
+OS_DRIVERS = @OS_DRIVERS@
+OS_LFLAGS = @OS_LFLAGS@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_DIR = @PKG_DIR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SHR_LINK = @SHR_LINK@
+STRIP = @STRIP@
+SUBDIR_S = @SUBDIR_S@
+SYSTEMD_DIR = @SYSTEMD_DIR@
+VERSION = @VERSION@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+localedir = $(datadir)/locale
+INCLUDES = -I..
+OS_CF = @OS_CFLAGS@ @CROSS_CFLAGS@
+OS_LF = @OS_LFLAGS@ @CROSS_LFLAGS@
+
+# The LanDesk library is proprietary, so it is incompatible with ALLOW_GPL.
+# To build with LanDesk support:
+# First copy the library to ../lib/libipmiapi.a
+# Then ./configure --enable-landesk
+# Result:
+# AM_CPPFLAGS += -DLINK_LANDESK
+# LDADD += -lipmiapi -L../lib
+
+# For lanplus plugin support (IPMI LAN 2.0 RMCP+) used by SOL:
+# If ./configure --disable-lanplus
+# AM_CPPFLAGS +=
+# LDADD +=
+# Otherwise default result is lanplus enabled:
+# AM_CPPFLAGS += -DHAVE_LANPLUS
+# LDADD += -L../lib -lipmi_lanplus -L/usr/local/lib -lcrypto
+# LDADD += -L../lib -lintf_lanplus -L/usr/local/lib -lcrypto (older)
+# Could also use CMDMOD += ipmilan2.c instead, if completed.
+AM_CPPFLAGS = $(OS_CF) -DLOCALEDIR=\"$(localedir)\" @IA64_CFLAGS@ \
+ @GPL_CFLAGS@ -I. -I.. -DMETACOMMAND @LANDESK_CFLAGS@ \
+ @LANPLUS_CFLAGS@ $(am__empty)
+LDADD = $(OS_LF) -lpthread @LANDESK_LDADD@ @LANPLUS_LIB@ \
+ @LANPLUS_CRYPTO@ $(am__empty)
+LDSAM = $(OS_LF) @LD_SAMX@
+CFLAGS_SAMX = -O2 -g -I. -I.. $(OS_CF) @LANPLUS_CFLAGS@
+CFLAGS_SAM = -O2 -g -I. -I.. $(OS_CF)
+# May be /usr/bin/install or /bin/install
+INSTALLBIN = install -c
+extradir = $(datadir)/ipmiutil
+inc_dir = $(includedir)
+tmpobj = obj
+tmpwin = tmp
+LIBDIR = @LIB_DIR@
+CMDMOD = ipmicmd.c mem_if.c ipmidir.c imbapi.c ipmimv.c ipmild.c \
+ ipmibmc.c ipmilipmi.c subs.c md5.c md2.c ipmilan.c \
+ ipmilanplus.c
+# CMDMOD = ipmicmd.c mem_if.c @OS_DRIVERS@
+# am: configure substitutions are not allowed in _SOURCES variables
+LIBOBJ = ipmicmd.o mem_if.o ipmidir.o imbapi.o ipmimv.o ipmild.o ipmibmc.o ipmilipmi.o subs.o md5.o md2.o $(tmpobj)/ipmilan.o $(tmpobj)/ipmilanplus.o
+OEMMOD = oem_kontron.c oem_fujitsu.c oem_intel.c oem_sun.c oem_supermicro.c oem_dell.c oem_quanta.c oem_hp.c oem_newisys.c iekanalyzer.c
+METASOURCE = ipmiutil.c ialarms.c ihealth.c ievents.c ifru.c ifru_picmg.c igetevent.c ireset.c icmd.c ilan.c isensor.c isel.c iserial.c iwdt.c isol.c idiscover.c iconfig.c ipicmg.c ifirewall.c ifwum.c ihpm.c itsol.c idcmi.c $(OEMMOD) $(CMDMOD)
+LANPLUS_OBJ = $(shell ar t @LANPLUS_LIB@ 2>/dev/null)
+DEV_LIB = libipmiutil.a
+SHR_LIB = libipmiutil.so
+SHRLINK = @SHR_LINK@
+TESTPROGS = libimbapi.a iconfig ipmimv ifruset ipmi_sample2 ialarms_enc
+# OLDPROGS are old/previous binaries that may exist and need to be deleted.
+OLDPROGS = alarms bmchealth fruconfig getevent hwreset icmd isolconsole pefconfig sensor showsel tmconfig wdt
+ipmiutil_SOURCES = $(METASOURCE)
+ievents_SOURCES = ievents.c
+idiscover_SOURCES = idiscover.c
+ipmi_port_SOURCES = ipmi_port.c
+EXTRA_DIST = imb_api.h ipmicmd.h ipmidir.h ipmilan.h ipmilanplus.h AnsiTerm.h ifirewall.h ifwum.h ihpm.h ipicmg.h ipmiutil.h md2.h oem_dell.h oem_fujitsu.h oem_intel.h oem_kontron.h oem_sun.h idcmi.h isensor.h iekanalyzer.h
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+ && exit 0; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign util/Makefile'; \
+ cd $(top_srcdir) && \
+ $(AUTOMAKE) --foreign util/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ test -z "$(bindir)" || $(mkdir_p) "$(DESTDIR)$(bindir)"
+ @list='$(bin_PROGRAMS)'; for p in $$list; do \
+ p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+ if test -f $$p \
+ || test -f $$p1 \
+ ; then \
+ f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(bindir)/$$f'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(bindir)/$$f" || exit 1; \
+ else :; fi; \
+ done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; for p in $$list; do \
+ f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \
+ echo " rm -f '$(DESTDIR)$(bindir)/$$f'"; \
+ rm -f "$(DESTDIR)$(bindir)/$$f"; \
+ done
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; for p in $$list; do \
+ f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f $$p $$f"; \
+ rm -f $$p $$f ; \
+ done
+install-sbinPROGRAMS: $(sbin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ test -z "$(sbindir)" || $(mkdir_p) "$(DESTDIR)$(sbindir)"
+ @list='$(sbin_PROGRAMS)'; for p in $$list; do \
+ p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+ if test -f $$p \
+ || test -f $$p1 \
+ ; then \
+ f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(sbinPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(sbindir)/$$f'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(sbinPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(sbindir)/$$f" || exit 1; \
+ else :; fi; \
+ done
+
+uninstall-sbinPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(sbin_PROGRAMS)'; for p in $$list; do \
+ f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \
+ echo " rm -f '$(DESTDIR)$(sbindir)/$$f'"; \
+ rm -f "$(DESTDIR)$(sbindir)/$$f"; \
+ done
+
+clean-sbinPROGRAMS:
+ @list='$(sbin_PROGRAMS)'; for p in $$list; do \
+ f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f $$p $$f"; \
+ rm -f $$p $$f ; \
+ done
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ialarms.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/icmd.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iconfig.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/idcmi.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/idiscover.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iekanalyzer.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ievents.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ifirewall.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ifru.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ifru_picmg.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ifwum.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/igetevent.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ihealth.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ihpm.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ilan.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/imbapi.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipicmg.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmi_port.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmi_sample.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmi_sample_evt.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmibmc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmicmd.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmidir.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmilan.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmilanplus.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmild.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmilipmi.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmimv.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipmiutil.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ireset.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isel.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iseltime.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isensor.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iserial.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isol.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/itsol.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iwdt.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/md2.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/md5.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mem_if.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_dell.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_fujitsu.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_hp.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_intel.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_kontron.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_newisys.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_quanta.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_sun.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oem_supermicro.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/subs.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \
+@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@ if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+distclean-libtool:
+ -rm -f libtool
+uninstall-info-am:
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ mkid -fID $$unique
+tags: TAGS
+
+TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ tags=; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$tags $$unique; \
+ fi
+ctags: CTAGS
+CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ tags=; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ test -z "$(CTAGS_ARGS)$$tags$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$tags $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && cd $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+ list='$(DISTFILES)'; for file in $$list; do \
+ case $$file in \
+ $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+ $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+ esac; \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+ dir="/$$dir"; \
+ $(mkdir_p) "$(distdir)$$dir"; \
+ else \
+ dir=''; \
+ fi; \
+ if test -d $$d/$$file; then \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+ fi; \
+ cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+ else \
+ test -f $(distdir)/$$file \
+ || cp -p $$d/$$file $(distdir)/$$file \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+ for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(sbindir)"; do \
+ test -z "$$dir" || $(mkdir_p) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ `test -z '$(STRIP)' || \
+ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libtool \
+ clean-sbinPROGRAMS mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-exec-am: install-binPROGRAMS install-sbinPROGRAMS
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-info-am \
+ uninstall-sbinPROGRAMS
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
+ clean-generic clean-libtool clean-sbinPROGRAMS ctags distclean \
+ distclean-compile distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-binPROGRAMS install-data \
+ install-data-am install-exec install-exec-am install-info \
+ install-info-am install-man install-sbinPROGRAMS install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-info-am uninstall-sbinPROGRAMS
+
+
+# To build an imb api library (libimbapi.a):
+libimbapi.a: imbapi.c
+ mkdir -p $(tmpobj)
+ $(CC) -I. -I.. $(OS_CF) -fPIC $(CFLAGS) -o $(tmpobj)/imbapi.o -c imbapi.c
+ $(AR) cru libimbapi.a $(tmpobj)/imbapi.o
+ $(RANLIB) libimbapi.a
+ rm -f $(tmpobj)/imbapi.o
+
+# Build a lib to support all of the IPMI drivers (libipmiutil.a)
+# If LANPLUS_SAM = yes, include LANPLUS_OBJ, else do not.
+# See configure --enable-liblanplus to change this
+$(DEV_LIB): $(CMDMOD:.c=.o) @LANPLUS_LIB@
+ mkdir -p $(tmpobj)
+ if [ "x@LANPLUS_SAM@" = "xyes" ]; then \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ ar x @LANPLUS_LIB@ ; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) $(LANPLUS_OBJ); \
+ $(RANLIB) $(DEV_LIB); \
+ else \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ $(AR) cru $(DEV_LIB) $(LIBOBJ) ; \
+ $(RANLIB) $(DEV_LIB) ; \
+ fi
+
+$(SHR_LIB): $(CMDMOD:.c=.o) @LANPLUS_LIB@
+ mkdir -p $(tmpobj)
+ if [ "x@LANPLUS_SAM@" = "xyes" ]; then \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAMX) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ ar x @LANPLUS_LIB@ ; \
+ $(CC) $(LDFLAGS) -shared -o $(SHR_LIB) $(LIBOBJ) $(LANPLUS_OBJ); \
+ else \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilanplus.o -c ipmilanplus.c; \
+ $(CC) $(CFLAGS_SAM) -o $(tmpobj)/ipmilan.o -c ipmilan.c; \
+ $(CC) $(LDFLAGS) -shared -o $(SHR_LIB) $(LIBOBJ) ; \
+ fi
+
+# To build ipmiutil, need to use METACFLAGS for each .c/.o
+
+idiscover$(EXEEXT): idiscover.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) $(OS_LF) -o idiscover idiscover.c
+
+ipmimv: ipmimv.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -DTEST_BIN -o ipmimv ipmimv.c
+
+ievents$(EXEEXT): ievents.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -DALONE -o ievents ievents.c
+
+ipmi_sample: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -c ipmi_sample.c
+ $(CC) -g -O2 -o ipmi_sample ipmi_sample.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ialarms_enc: $(DEV_LIB) ialarms.c oem_intel.c
+ $(CC) $(CFLAGS_SAM) -DTEST_ENC -o ialarms2.o -c ialarms.c
+ $(CC) $(CFLAGS_SAM) -DNO_EVENTS -o oem_intel2.o -c oem_intel.c
+ $(CC) -g -O2 -o ialarms_enc ialarms2.o oem_intel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifru_picmg2.o: ifru_picmg.c
+ $(CC) $(CFLAGS_SAM) -o ifru_picmg2.o -c ifru_picmg.c
+
+# To build ipmi_sample with GET_SENSORS enabled, need isensors.o, ievents.o
+# Note that this does not include oem_intel, etc. for OEM SEL decoding.
+ipmi_sample2: $(DEV_LIB) ipmi_sample.c isensor.c ievents.c ifru.c isel.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -D GET_SENSORS -D GET_FRU -o ipmi_sample2.o -c ipmi_sample.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -o ievents2.o -c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ifru2.o -c ifru.c
+ $(CC) $(CFLAGS_SAM) -o isel2.o -c isel.c
+ $(CC) -g -O2 -o ipmi_sample2 ipmi_sample2.o isensor2.o ievents2.o ifru2.o ifru_picmg2.o isel2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ipmi_sample_evt: $(DEV_LIB) ipmi_sample_evt.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -o ipmi_sample_evt.o -c ipmi_sample_evt.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -DSENSORS_OK -o ievents2.o -c ievents.c
+ $(CC) -g -O2 -o ipmi_sample_evt ipmi_sample_evt.o isensor2.o ievents2.o $(DEV_LIB) $(LDFLAGS) $(LDSAM)
+
+ifruset: $(DEV_LIB) ifruset.c ifru_picmg2.o
+ $(CC) $(CFLAGS_SAM) -c ifruset.c
+ $(CC) -g -O2 -o ifruset ifruset.o ifru_picmg2.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+iseltime: $(DEV_LIB) iseltime.c
+ $(CC) $(CFLAGS_SAM) -c iseltime.c
+ $(CC) -g -O2 -o iseltime iseltime.o $(DEV_LIB) $(LDFLAGS) $(LDADD)
+
+ipmi_port$(EXEEXT): ipmi_port.c
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -o ipmi_port ipmi_port.c
+
+iconfig: iconfig.c $(DEV_LIB)
+ $(CC) $(CFLAGS_SAM) $(LDFLAGS) -o iconfig iconfig.c $(DEV_LIB) @LANPLUS_CRYPTO@
+
+# @LANPLUS_LIB@ is ../lib/libipmi_lanplus.a
+../lib/libipmi_lanplus.a:
+ cd ../lib; make
+
+ipmiutil$(EXEEXT): $(METASOURCE:.c=.o) @LANPLUS_LIB@
+ $(CC) $(CFLAGS) $(LDFLAGS) -o ipmiutil $(METASOURCE:.c=.o) $(LDADD)
+
+all-am: Makefile $(bin_PROGRAMS) $(sbin_PROGRAMS) $(EXTRA_PROGRAMS) $(DEV_LIB) $(SHRLINK)
+
+install-data-am: $(EXTRA_PROGRAMS) $(DEV_LIB) $(SHRLINK)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(extradir)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(LIBDIR)
+ @INS_LIB@ mkdir -p $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f ipmi_sample.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmi_sample_evt.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f ipmicmd.h $(DESTDIR)$(inc_dir)
+ @INS_LIB@ cp -f isensor.c ievents.c $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f isensor.h ievents.h $(DESTDIR)$(extradir)
+ @INS_LIB@ cp -f Makefile.sample $(DESTDIR)$(extradir)/Makefile
+ @INS_LIB@ cp -f $(DEV_LIB) $(DESTDIR)$(LIBDIR)
+ if [ "x$(SHRLINK)" != "x" ]; then \
+ @INS_LIB@ cp -f $(SHR_LIB) $(DESTDIR)$(LIBDIR) ; \
+ fi
+
+clean-generic:
+ rm -f $(DEV_LIB) $(EXTRA_PROGRAMS) $(OLDPROGS) $(TESTPROGS) $(SHRLINK)
+ if [ -d $(tmpobj) ]; then rm -rf $(tmpobj) ; fi
+ if [ -d $(tmpwin) ]; then rm -rf $(tmpwin) ; fi
+ rm -f *.log *.tmp debug*.list *.o *.pdb *.lo *.la *.so
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/util/Makefile.sample b/util/Makefile.sample
new file mode 100644
index 0000000..2976dd5
--- /dev/null
+++ b/util/Makefile.sample
@@ -0,0 +1,28 @@
+# Makefile for ipmi_sample program
+#
+TARGETS = ipmi_sample ipmi_sample_evt
+incl_dir = /usr/include
+CFLAGS_SAM = -O2 -g -I. -DLINUX
+LDFLAGS = -lpthread
+# if building without lanplus, comment out these two lines
+CFLAGS_SAM += -DHAVE_LANPLUS
+LDFLAGS += -lcrypto
+
+# see /usr/lib/libipmiutil.a
+LDFLAGS += -lipmiutil
+
+all: $(TARGETS)
+
+ipmi_sample: ipmi_sample.c $(incl_dir)/ipmicmd.h
+ $(CC) $(CFLAGS_SAM) -c ipmi_sample.c
+ $(CC) -g -O2 -o ipmi_sample ipmi_sample.o $(LDFLAGS)
+
+ipmi_sample_evt: ipmi_sample_evt.c isensor.c ievents.c
+ $(CC) $(CFLAGS_SAM) -c ipmi_sample_evt.c
+ $(CC) $(CFLAGS_SAM) -o isensor2.o -c isensor.c
+ $(CC) $(CFLAGS_SAM) -DSENSORS_OK -o ievents2.o -c ievents.c
+ $(CC) -g -O2 -o ipmi_sample_evt ipmi_sample_evt.o isensor2.o ievents2.o $(LDFLAGS)
+
+clean-generic:
+ rm -f $(TARGETS) *.o *.tmp
+
diff --git a/util/ialarms.c b/util/ialarms.c
new file mode 100644
index 0000000..dbbdf0c
--- /dev/null
+++ b/util/ialarms.c
@@ -0,0 +1,689 @@
+/*
+ * ialarms.c
+ *
+ * This tool reads and sets the alarms panel on an Intel Telco chassis.
+ * Note that the Intel Server Management software will set these alarms
+ * based on firmware-detected thresholds and events.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2003-2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 02/25/03 Andy Cress - created
+ * 04/08/03 Andy Cress - added -i for ChassisIdentify
+ * 04/30/03 Andy Cress - only try to set ID on/off if option specified
+ * 01/20/04 Andy Cress - mods for mBMC w Chesnee platform
+ * 05/05/04 Andy Cress - call ipmi_close before exit
+ * 10/11/04 Andy Cress 1.4 - if -o set relays too (fsetall)
+ * 11/01/04 Andy Cress 1.5 - add -N / -R for remote nodes
+ * 03/07/05 Andy Cress 1.6 - add bus for Intel TIGI2U
+ * 03/28/05 Andy Cress 1.7 - add check for BMC TAM if setting alarms
+ * 06/22/05 Andy Cress 1.8 - adding fpicmg for ATCA alarm LEDs
+ * 03/17/06 Andy Cress 1.9 - adding BUS_ID7 for Harbison
+ * 04/20/07 Andy Cress 1.25 - adding disk Enclosure HSC LEDs
+ */
+/*M*
+Copyright (c) 2003-2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#ifdef WIN32
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include "getopt.h"
+#elif defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include "ipmicmd.h"
+#include "oem_intel.h"
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "ialarms";
+static char fdebug = 0;
+static char fbmctam = 0;
+static char fpicmg = 0;
+static char fHasAlarms = 0;
+static char fNSC = 0;
+static char fHasEnc = 0; /* Has disk Enclosure HSC? */
+static int maxdisks = 6; /* default to max of 6 disks */
+static uchar fdoencl = 1;
+static uchar picmg_id = 0; /* always 0 for picmg */
+static uchar fru_id = 0; /* fru device id */
+//static uchar led_id = 0; /* 0 = blue led, 1,2,3=led1,2,3 */
+static uchar ipmi_maj, ipmi_min;
+
+#define ENC_LED_WRITE 0x21 // only used for Ballenger-CT HSC
+#define ENC_LED_READ 0x20 // only used for Ballenger-CT HSC
+
+#define NETFN_ENC 0x30
+#define NETFN_PICMG 0x2c
+#define PICMG_GET_LED_PROPERTIES 0x05
+#define PICMG_SET_LED_STATE 0x07
+#define PICMG_GET_LED_STATE 0x08
+
+#ifdef METACOMMAND
+extern int get_alarms_fujitsu(uchar *rgalarms);
+extern int show_alarms_fujitsu(uchar *rgalarms);
+extern int set_alarms_fujitsu(uchar num, uchar val);
+extern int get_led_status_intel(uchar *pstate);
+#endif
+#ifdef ALONE
+extern int get_led_status_intel(uchar *pstate);
+#endif
+
+static uchar busid = PRIVATE_BUS_ID;
+static uchar enc_sa = HSC_SA;
+static char fRomley = 0;
+
+static int get_enc_leds(uchar *val)
+{
+ uchar idata[16];
+ uchar rdata[16];
+ int rlen, i;
+ int rv = 0;
+ uchar cc;
+ char *pstr = NULL;
+ rlen = sizeof(rdata);
+ for (i = 0; i < 3; i++) {
+ rv = ipmi_cmdraw( ENC_LED_READ, NETFN_ENC, enc_sa, PUBLIC_BUS,BMC_LUN,
+ idata,0, rdata, &rlen, &cc, fdebug);
+ if (fdebug)
+ printf("get_enc_leds() rv=%d cc=%x val=%02x\n",rv,cc,rdata[0]);
+ if (rv == 0 && cc == 0x83) os_usleep(0,50000); /* HSC busy, wait 50ms */
+ else break;
+ }
+ if (rv != 0) pstr = decode_rv(rv);
+ else if (cc != 0) pstr = decode_cc(0,cc);
+ /* if get cc==0x83 here, the power state may be soft-off */
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) { /*success*/
+ *val = rdata[0];
+ } else /*error*/
+ printf("get_enc_leds: error %s\n",pstr);
+ return(rv);
+}
+
+static int set_enc_leds(uchar val)
+{
+ uchar idata[16];
+ uchar rdata[16];
+ int rlen;
+ int rv = 0;
+ uchar cc;
+
+ idata[0] = val;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( ENC_LED_WRITE, NETFN_ENC, enc_sa, PUBLIC_BUS,BMC_LUN,
+ idata,1, rdata, &rlen, &cc, fdebug);
+ if (fdebug) printf("set_enc_leds(%02x) rv = %d, cc = %x\n",val,rv,cc);
+ if (rv == 0 && cc != 0) rv = cc;
+ return(rv);
+}
+
+static void show_enc_leds(uchar val)
+{
+ char *enc_pattn = "disk slot %d LED: %s\n";
+ uchar mask;
+ int i, n;
+ if (fdebug) printf("val = %02x\n",val);
+ n = maxdisks;
+ if (n > 8) n = 8;
+ mask = 0x01;
+ /* Ballenger HSC only supports 6 slots, some support 8 */
+ for (i = 0; i < n; i++) {
+ if (val & mask) printf(enc_pattn,i,"ON");
+ else printf(enc_pattn,i,"off");
+ mask = (mask << 1);
+ }
+}
+
+static int set_chassis_id(uchar val)
+{
+ uchar inputData[4];
+ uchar responseData[16];
+ int responseLength = 4;
+ uchar completionCode;
+ int ret;
+ uchar ilen;
+
+ ilen = 1;
+ inputData[0] = val; /* #seconds to turn on id, 0=turn off */
+ /* IPMI 2.0 has an optional 2nd byte,
+ * if 01, turn ID on indefinitely. */
+ if (val == 255 && ipmi_maj >= 2) {
+ inputData[1] = 1;
+ ilen = 2;
+ }
+ /* CHASSIS_IDENTIFY=0x04, using NETFN_CHAS (=00) */
+ ret = ipmi_cmd(CHASSIS_IDENTIFY, inputData, ilen, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (ret == 0 && completionCode != 0) ret = completionCode;
+ if (ret != 0) {
+ printf("set_chassis_id: ret = %d, ccode %02x, value = %02x\n",
+ ret, completionCode, val);
+ }
+ return(ret);
+} /*end set_chassis_id*/
+
+
+static int get_alarms_picmg(uchar *rgv, uchar picmgid, uchar fruid, uchar led)
+{
+ uchar inputData[4];
+ uchar responseData[16];
+ int responseLength;
+ uchar completionCode;
+ int ret, i;
+
+ if (rgv == NULL) return(ERR_BAD_PARAM);
+ inputData[0] = picmgid;
+ inputData[1] = fruid;
+ inputData[2] = led; // 0 = blue led
+ responseLength = sizeof(responseData);
+ ret = ipmi_cmdraw( PICMG_GET_LED_STATE, NETFN_PICMG,
+ BMC_SA, PUBLIC_BUS,BMC_LUN,
+ inputData,3, responseData, &responseLength,
+ &completionCode, fdebug);
+ if ((ret != 0) || (completionCode != 0)) {
+ if (fdebug)
+ printf("get_alarms_picmg(%d,%d,%d): ret = %d, ccode %02x\n",
+ picmgid,fruid,led,ret, completionCode);
+ if (ret == 0) ret = completionCode;
+ return(ret);
+ }
+ /* if here, success */
+ if (fdebug) {
+ printf("get_alarms_picmg(%d,%d,%d): ", picmgid,fruid,led);
+ for (i = 0; i < responseLength; i++)
+ printf("%02x ",responseData[i]);
+ printf("\n");
+ }
+ memcpy(rgv,responseData,responseLength);
+ return(ret);
+}
+
+static int set_alarms_picmg(uchar val, uchar picmgid, uchar fruid, uchar led,
+ char color)
+{
+ uchar inputData[6];
+ uchar responseData[16];
+ int responseLength;
+ uchar completionCode;
+ int ret, i;
+
+ inputData[0] = picmgid;
+ inputData[1] = fruid;
+ inputData[2] = led; // 0 = blue led
+ inputData[3] = val;
+ inputData[4] = 0;
+ switch(color) {
+ case 'w': i = 6; break;
+ case 'o': i = 5; break;
+ case 'a': i = 4; break;
+ case 'g': i = 3; break;
+ case 'r': i = 2; break;
+ case 'b':
+ default: i = 1; break;
+ }
+ inputData[5] = (uchar)i; // 1 = blue
+ responseLength = sizeof(responseData);
+ ret = ipmi_cmdraw( PICMG_SET_LED_STATE, NETFN_PICMG,
+ BMC_SA, PUBLIC_BUS,BMC_LUN,
+ inputData,6, responseData, &responseLength,
+ &completionCode, fdebug);
+ if ((ret != 0) || (completionCode != 0)) {
+ printf("set_alarms_picmg(%02x,%d,%d,%d): ret = %d, ccode %02x\n",
+ val,picmgid,fruid,led,ret, completionCode);
+ if (ret == 0) ret = completionCode;
+ return(ret);
+ }
+ printf("set_alarms_picmg(%02x,%d,%d,%d): ", val,picmgid,fruid,led);
+ for (i = 0; i < responseLength; i++)
+ printf("%02x ",responseData[i]);
+ printf("\n");
+ return(ret); /* success */
+}
+
+static void show_alarms_picmg(uchar *v, uchar pid, uchar fruid, uchar led)
+{
+ char led_str[10];
+ char state_str[20];
+ char *func_str;
+ char *color_str;
+ if (v == NULL) return;
+ if (fdebug)
+ printf("picmg(%d,%d,%d) alarm LED state is %02x %02x %02x %02x %02x\n",
+ pid,fruid,led,v[0],v[1],v[2],v[3],v[4]);
+ switch(led) {
+ case 0: strcpy(led_str,"HSLed"); break; /*Blue LED*/
+ default: sprintf(led_str," Led%d",led); break;
+ }
+ state_str[0] = 0;
+ if (v[1] & 0x01) strcat(state_str,"local");
+ if (v[1] & 0x02) strcat(state_str," override");
+ if (v[1] & 0x04) strcat(state_str," lamptest");
+ switch(v[2]) {
+ case 0x00: func_str = "off"; break;
+ case 0xFF: func_str = "ON"; break;
+ default: func_str = "Blink"; break; /*duration of blink/off*/
+ }
+ /* v[3] is duration of blink/on in tens of msec */
+ switch(v[4]) {
+ case 6: color_str = "white"; break;
+ case 5: color_str = "orange"; break;
+ case 4: color_str = "amber"; break;
+ case 3: color_str = "green"; break;
+ case 2: color_str = "red"; break;
+ case 1:
+ default: color_str = "blue"; break;
+ }
+ printf("picmg(%d,%d) %s is %s,%s,%s\n",fruid,led,led_str,
+ state_str,func_str,color_str);
+}
+
+
+#ifdef METACOMMAND
+int i_alarms(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int c;
+ uchar fsetled = 0;
+ uchar fsetall = 0;
+ uchar fsetdisk = 0;
+ uchar fsetid = 0;
+ uchar fcrit = 2;
+ uchar fmaj = 2;
+ uchar fmin = 2;
+ uchar fpow = 2;
+ uchar fdiska = 2;
+ uchar fdiskb = 2;
+ uchar fdiskn = 2;
+ uchar ndisk = 0;
+ int fid = 0;
+ uchar alarms = 0;
+ uchar rgalarms[10] = {0,0,0,0,0,0};
+ uchar newvalue = 0xff;
+ uchar diskled = 0xff;
+ uchar encled = 0;
+ uchar devrec[16];
+ uchar ledn = 0;
+ uchar ledv = 0;
+ char ledc = 'c';
+ int i;
+ int flags = 0;
+ int prod_id, vend_id;
+
+ printf("%s ver %s\n", progname,progver);
+ /* default to admin privilege if get/set alarms remotely */
+ parse_lan_options('V',"4",0);
+
+ while ( (c = getopt( argc, argv,"rxa:b:c:d:efm:n:p:i:ow:Z:EF:P:N:R:U:T:V:J:Y?")) != EOF )
+ switch(c) {
+ case 'r': fsetled=0; fsetid=0; fsetdisk = 0; break; /* read only */
+ case 'a': fdiska = atob(optarg); /* set disk A LED value */
+ fsetdisk = 1; break;
+ case 'b': fdiskb = atob(optarg); /* set disk B LED value */
+ fsetdisk = 2; break;
+ case 'c': fcrit = atob(optarg); /* set critical alarm value */
+ fsetled = 1; break;
+ case 'd': ndisk = optarg[0] & 0x0f; /* set disk N LED on or off */
+ fdiskn = optarg[1] & 0x0f;
+ fsetdisk = 3; break;
+ case 'e': fdoencl = 0; /* skip disk/enclosure LEDs */
+ case 'f': fdiska = 10; /* set all disk LEDs off */
+ fsetdisk = 1; break;
+ case 'm': fmaj = atob(optarg); /* set major alarm value */
+ fsetled = 1; break;
+ case 'n': fmin = atob(optarg); /* set minor alarm value */
+ fsetled = 1; break;
+ case 'p': fpow = atob(optarg); /* set power alarm value */
+ fsetled = 1; break;
+ case 'w': ledn = optarg[0] & 0x0f; /* set picmg LED N on or off */
+ ledv = optarg[1] & 0x0f;
+ ledc = optarg[2]; /*color char, usu 'b' for blue*/
+ fsetled = 1; break;
+ case 'i': fid = atoi(optarg); /* set chassis id on/off */
+ if (fid > 255) {
+ printf("Adjusting %d to max 255 sec for ID\n",fid);
+ fid = 255;
+ }
+ fsetid=1; break;
+ case 'o': fcrit=0; fmaj=0; fmin=0; fpow=0; /* set all alarms off */
+ fsetdisk = 1; fdiska = 0; fdiskb = 0; fsetall=1;
+ fsetled = 1; fsetid=1; fid=0; break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-abcdfimnoprx -NUPRETVFY]\n", progname);
+ printf(" where -r means read-only\n");
+ printf(" -i5 sets Chassis ID on for 5 sec\n");
+ printf(" -i0 sets Chassis ID off\n");
+ printf(" -a1 sets Disk A Fault on\n");
+ printf(" -a0 sets Disk A Fault off\n");
+ printf(" -b1 sets Disk B Fault on\n");
+ printf(" -b0 sets Disk B Fault off\n");
+ printf(" -c1 sets Critical Alarm on\n");
+ printf(" -c0 sets Critical Alarm off\n");
+ printf(" -d31 sets Disk 3 Fault on (disks 0-6)\n");
+ printf(" -d30 sets Disk 3 Fault off\n");
+ printf(" -e skip disk Enclosure LEDs\n");
+ printf(" -f sets all Disk Fault LEDs off\n");
+ printf(" -m1 sets Major Alarm on\n");
+ printf(" -m0 sets Major Alarm off\n");
+ printf(" -n1 sets Minor Alarm on\n");
+ printf(" -n0 sets Minor Alarm off\n");
+ printf(" -p1 sets Power Alarm on\n");
+ printf(" -p0 sets Power Alarm off\n");
+ printf(" -o sets all Alarms off\n");
+ printf(" -w21b writes picmg LED 2 on(1) color=blue(b)\n");
+ printf(" -x show eXtra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ /*
+ * Check the Device ID to determine which bus id to use.
+ */
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ int j;
+
+ if (fdebug) {
+ printf("devid: ");
+ for (j = 0; j < 16; j++) printf("%02x ",devrec[j]);
+ printf("\n");
+ }
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ prod_id = devrec[9] + (devrec[10] << 8);
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+
+ printf("-- %s version %x.%x, IPMI version %d.%d \n",
+ "BMC", devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+
+#ifdef TEST_ENC
+ fHasEnc = 1;
+ fHasAlarms = 0;
+ fbmctam = 0;
+ fpicmg = 0;
+ fRomley = 1;
+ maxdisks = 8;
+#else
+ ret = ipmi_getpicmg(devrec,16,fdebug);
+ if (ret == 0) {
+ fpicmg = 1;
+ fHasAlarms = 1;
+ } else ret = 0; /* ignore error if not picmg */
+
+#if defined(METACOMMAND) || defined(ALONE)
+ {
+ uchar rgalarms[3];
+ uchar idstate;
+ char *pmsg;
+ switch(vend_id) {
+ case VENDOR_NSC: /* for Intel TIGPT1U */
+ case VENDOR_INTEL: /* requires oem_intel.c */
+ /* check_prod_capab */
+ ret = detect_capab_intel(vend_id,prod_id,&flags,&maxdisks,fdebug);
+ busid = (uchar)ret;
+ if (fdebug) printf("prod_capab: busid=%x, flags=%02x\n",busid,flags);
+ if ((flags & HAS_ALARMS_MASK) != 0) fHasAlarms = 1;
+ if ((flags & HAS_BMCTAM_MASK) != 0) fbmctam = 1;
+ if ((flags & HAS_ENCL_MASK) != 0) fHasEnc = 1;
+ if ((flags & HAS_PICMG_MASK) != 0) fpicmg = 1;
+ if ((flags & HAS_NSC_MASK) != 0) fNSC = 1;
+ if ((flags & HAS_ROMLEY_MASK) != 0) fRomley = 1;
+ /* get ID LED status */
+ ret = get_led_status_intel(&idstate);
+ if (ret == 0) {
+ switch(idstate) {
+ case 1: pmsg = "ON"; break;
+ case 2: pmsg = "Blink"; break;
+ default: pmsg = "off"; break;
+ }
+ printf("ID LED: %s\n",pmsg);
+ }
+ break;
+#ifdef METACOMMAND
+ case VENDOR_KONTRON:
+ if (prod_id == 1590) { fHasEnc = 1; maxdisks = 8; }
+ break;
+ case VENDOR_FUJITSU:
+ printf("Getting Fujitsu alarm LEDs ...\n");
+ ret = get_alarms_fujitsu(rgalarms);
+ if (fdebug) printf("get_alarms_fujitsu ret = %d\n",ret);
+ /* if ret != 0, fall through and try default methods */
+ if (ret == 0) {
+ show_alarms_fujitsu(rgalarms);
+ if (fsetid) {
+ printf("\nSetting fujitsu ID LED to %02x ...\n", fid);
+ ret = set_alarms_fujitsu(0, (uchar)fid);
+ printf("set_alarms_fujitsu ret = %d\n",ret);
+ ret = get_alarms_fujitsu(rgalarms);
+ if (ret == 0) show_alarms_fujitsu(rgalarms);
+ }
+ fHasAlarms = 0; /*skip the other LED functions*/
+ }
+ break;
+ case VENDOR_SUN:
+ printf("Do get_alarms_sun() \n"); // TODO: add this
+/*
+ ret = get_alarms_sun();
+ if (ret == 0) show_alarms_sun()
+ if (fsetled) {
+ printf("\nSetting sun(%d) alarm LED to %02x %c...\n",
+ ledn,ledv,ledc);
+ ret = set_alarms_sun(ledv,ledn,ledc);
+ printf("set_alarms_sun ret = %d\n",ret);
+ ret = get_alarms_sun(rgalarms,ledn);
+ if (ret == 0) show_alarms_sun(rgalarms,ledn);
+ }
+*/
+ break;
+#endif
+ default:
+ break;
+ }
+ }
+#endif
+
+#endif
+ if (fHasAlarms)
+ { /* get the telco picmg or intel alarm LED states */
+ if (fpicmg) {
+ for (i = 0; i < 5; i++) {
+ ret = get_alarms_picmg(rgalarms,picmg_id,fru_id,(uchar)i);
+ if (ret == 0)
+ show_alarms_picmg(rgalarms,picmg_id,fru_id,(uchar)i);
+ }
+ } else {
+ alarms = get_alarms_intel(busid);
+ if (alarms == 0) { /* failed to get alarm panel data */
+ if (fHasAlarms) { /* baseboard which may have Telco alarm panel*/
+ printf("Could not obtain Telco LED states, Telco alarm panel "
+ "may not be present.\n\n");
+ }
+ fHasAlarms = 0;
+ } else { /* have Telco alarm panel data */
+ ret = 0;
+ show_alarms_intel(alarms);
+ }
+ }
+
+ if (fsetled) {
+ if (fpicmg) {
+ printf("\nSetting picmg(%d,%d) alarm LED to %02x %c...\n",
+ fru_id,ledn,ledv,ledc);
+ ret = set_alarms_picmg(ledv,picmg_id,fru_id,ledn,ledc);
+ printf("set_alarms_picmg ret = %d\n",ret);
+ ret = get_alarms_picmg(rgalarms,picmg_id,fru_id,ledn);
+ if (ret == 0) show_alarms_picmg(rgalarms,picmg_id,fru_id,ledn);
+ } else { /* not picmg, set Intel Telco Alarm LEDs */
+ if (fbmctam) { /* Platform supports BMC Telco Alarms Manager */
+ ret = check_bmctam_intel();
+ } /*endif fbmctam*/
+ if (ret == LAN_ERR_ABORT) {
+ printf("Conflict with BMC TAM - Skipping TAM LEDs.\n");
+ } else {
+ if (fsetall) newvalue = 0xFF; /* alarms and relays */
+ else {
+ newvalue = alarms;
+ if (fcrit == 1) newvalue &= 0xFD; /*bit1 = 0*/
+ else if (fcrit == 0) newvalue |= 0xF2;
+ if (fmaj == 1) newvalue &= 0xFB; /*bit2 = 0*/
+ else if (fmaj == 0) newvalue |= 0xF4;
+ if (fmin == 1) newvalue &= 0xF7; /*bit3 = 0*/
+ else if (fmin == 0) newvalue |= 0xF8;
+ if (fpow == 1) newvalue &= 0xFE; /*bit0 = 0*/
+ else if (fpow == 0) newvalue |= 0xF1;
+ }
+ printf("\nSetting alarms to %02x ...\n",newvalue);
+ ret = set_alarms_intel(newvalue,busid);
+ alarms = get_alarms_intel(busid);
+ show_alarms_intel(alarms);
+ }
+ } /*end else Intel*/
+ } /*endif fsetled*/
+ } /*endif fHasAlarms*/
+
+ if (fsetid) {
+ printf("Setting ID LED to %d ...\n\n",fid);
+ ret = set_chassis_id((uchar)fid);
+ }
+
+ if (fHasEnc && fdoencl) { /* disk enclosure exists */
+ if (fRomley) { /* Romley (Patsburg) */
+ int rv; /*do not change ret*/
+ rv = get_enc_leds_intel(&encled);
+ if (rv == 0) {
+ show_enc_leds_intel(encled,maxdisks);
+ if (fsetdisk) {
+ /* Set fault if user param, and disk is present. */
+ if (fsetall) newvalue = 0x00; /* all LEDs off */
+ else if (fdiska == 10) newvalue = 0x00;
+ else {
+ newvalue = encled;
+ if (fdiskb == 1) newvalue |= 0x02;
+ else if (fdiskb == 0) newvalue &= 0xFD;
+ if (fdiska == 1) newvalue |= 0x01;
+ else if (fdiska == 0) newvalue &= 0xFE;
+ if (fdiskn == 1) newvalue |= (0x01 << ndisk);
+ else if (fdiskn == 0) newvalue &= ~(0x01 << ndisk);
+ }
+ printf("\nSetting Enclosure LEDs to %02x ...\n",newvalue);
+ ret = set_enc_leds_intel(newvalue);
+ ret = get_enc_leds_intel(&encled);
+ show_enc_leds_intel(encled,maxdisks);
+ }
+ }
+ } else { /* Vitesse disk Enclosure chipset */
+ ret = get_enc_leds(&encled);
+ if (ret == 0) {
+ show_enc_leds(encled);
+ if (fsetdisk) {
+ /* Set fault if user param, and disk is present. */
+ if (fsetall) newvalue = 0x00; /* all LEDs off */
+ else if (fdiska == 10) newvalue = 0x00;
+ else {
+ newvalue = encled;
+ if (fdiskb == 1) newvalue |= 0x02;
+ else if (fdiskb == 0) newvalue &= 0xFD;
+ if (fdiska == 1) newvalue |= 0x01;
+ else if (fdiska == 0) newvalue &= 0xFE;
+ if (fdiskn == 1) newvalue |= (0x01 << ndisk);
+ else if (fdiskn == 0) newvalue &= ~(0x01 << ndisk);
+ }
+ printf("\nSetting Enclosure LEDs to %02x ...\n",newvalue);
+ ret = set_enc_leds(newvalue);
+ ret = get_enc_leds(&encled);
+ show_enc_leds(encled);
+ }
+ }
+ } /*end-else Vitesse*/
+ } /*endif fHasEnc*/
+ else if (fNSC && fdoencl) { /*Chesnee NSC platform has special disk LEDs*/
+ diskled = get_nsc_diskleds(busid);
+ show_nsc_diskleds(diskled);
+ if (fsetdisk) {
+ newvalue = diskled;
+ // newvalue |= 0xFC; /*leave upper bits high (off) */
+ /* Set fault if user param, and disk is present. */
+ if (fdiskb == 1) newvalue &= 0xFE; /*bit0=0*/
+ else if (fdiskb == 0) newvalue |= 0x01;
+ if (fdiska == 1) newvalue &= 0xFD; /*bit1=0*/
+ else if (fdiska == 0) newvalue |= 0x02;
+ else if (fdiska == 10) newvalue = 0x00;
+ printf("\nSetting Disk LEDs to %02x ...\n",newvalue);
+ ret = set_nsc_diskleds(newvalue,busid);
+ diskled = get_nsc_diskleds(busid);
+ show_nsc_diskleds(diskled);
+ }
+ }
+do_exit:
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return (ret);
+} /* end main()*/
+
+/* end ialarms.c */
diff --git a/util/icmd.c b/util/icmd.c
new file mode 100644
index 0000000..5911262
--- /dev/null
+++ b/util/icmd.c
@@ -0,0 +1,366 @@
+/*
+ * icmd.c
+ *
+ * This tool takes command line input as an IPMI command.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2003-2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 03/30/04 Andy Cress - created
+ * 04/08/04 Andy Cress - display response data, changed usage order
+ * 05/05/04 Andy Cress - call ipmi_close before exit
+ * 11/01/04 Andy Cress - add -N / -R for remote nodes
+ * 12/08/04 Andy Cress v1.5 changed usage order, moved bus to first byte,
+ * gives better compatibility with ipmicmd.exe.
+ * 04/13/06 Andy Cress v1.6 fixed istart for -U -R
+ */
+/*M*
+Copyright (c) 2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#if defined(EFI)
+ #ifndef NULL
+ #define NULL 0
+ #endif
+ #include <types.h>
+ #include <libdbg.h>
+ #include <unistd.h>
+ #include <errno.h>
+#else
+ /* Linux, Solaris, BSD, Windows */
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <string.h>
+ #ifdef WIN32
+ #include "getopt.h"
+ #elif defined(DOS)
+ #include <dos.h>
+ #include "getopt.h"
+ #elif defined(HPUX)
+ /* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+ #else
+ #include <getopt.h>
+ #endif
+#endif
+#include "ipmicmd.h"
+extern void ipmi_lan_set_timeout(int ipmito, int tries, int pingto);
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "icmd";
+static char fdebug = 0;
+static char fquiet = 0;
+static char fset_mc = 0;
+static char ftest = 0;
+static int vend_id;
+static int prod_id;
+static char fmBMC = 0;
+static char fdecimal = 0;
+extern int fjustpass; /*see ipmicmd.c*/
+
+#define PRIVATE_BUS_ID 0x03 // w Sahalee, the 8574 is on Private Bus 1
+#define PERIPHERAL_BUS_ID 0x24 // w mBMC, the 8574 is on the Peripheral Bus
+#define MAXRQLEN 64
+#define MAXRSLEN 200
+
+static char usagemsg[] = "Usage: %s [-kqmsxEFNPRTUV] bus rsSa netFn/lun cmd [data bytes]\n";
+static uchar busid = PRIVATE_BUS_ID;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = 0; /*0x20*/
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+static int send_icmd(uchar *cmd, int len)
+{
+ uchar responseData[MAXRSLEN];
+ int responseLength;
+ uchar completionCode;
+ int ret, i;
+ uchar netfn, lun;
+ ushort icmd;
+
+ /* icmd format: 0=bus, 1=rsSa, 2=netFn/lun, 3=cmd, 4-n=data */
+ netfn = cmd[2] >> 2;
+ lun = cmd[2] & 0x03;
+ icmd = cmd[3] + (netfn << 8);
+ if (fjustpass) {
+ ret = ipmi_cmdraw(IPMB_SEND_MESSAGE,NETFN_APP,BMC_SA,0,0,
+ &cmd[0],(uchar)(len), responseData, &responseLength,
+ &completionCode, fdebug);
+ } else {
+ responseLength = sizeof(responseData);
+ if (g_addrtype == ADDR_IPMB) { /* && (g_sa != 0) */
+ /* if -m used, do ipmi_cmd_mc for IPMB commands */
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ ret = ipmi_cmd_mc(icmd, &cmd[4], (uchar)(len-4), responseData,
+ &responseLength, &completionCode, fdebug);
+ ipmi_restore_mc();
+ } else {
+ /* ipmi_cmdraw: bus, cmd, netfn, sa, lun, pdata, ... */
+ ret = ipmi_cmdraw(cmd[3], netfn, cmd[1], cmd[0], lun, &cmd[4],
+ (uchar)(len-4), responseData, &responseLength,
+ &completionCode, fdebug);
+ }
+ }
+ if (ret < 0) {
+ printf("ipmi_cmd: ret = %d %s\n",ret,decode_rv(ret));
+ return(ret);
+ } else if ((ret != 0) || (completionCode != 0)) {
+ printf("ipmi_cmd: ret = %d, ccode %02x %s\n",
+ ret, completionCode, decode_cc(icmd,completionCode));
+ return(ret);
+ } else if (responseLength > 0) {
+ /* show the response data */
+ printf("respData[len=%d]: ",responseLength);
+ for (i = 0; i < responseLength; i++)
+ printf("%02x ",responseData[i]);
+ printf("\n");
+ }
+ return(ret);
+} /*end send_icmd()*/
+
+
+#ifdef METACOMMAND
+int i_cmd(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int c;
+ uchar devrec[17];
+ uchar cmdbuf[MAXRQLEN];
+ int maxlen = MAXRQLEN;
+ int i, j, istart, cmdlen;
+ int fskipdevid = 0;
+ int fprivset = 0;
+ int cmdmin;
+ char *s1;
+
+ istart = 1;
+ while ( (c = getopt( argc, argv,"djkm:qst:xN:P:R:U:EF:J:T:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'j': /* just pass the bytes to KCS */
+ fjustpass = 1;
+ break;
+ case 'd': /* decimal command bytes, skipping bus and sa,
+ which matches 'ipmitool raw' format. */
+ fdecimal = 1;
+ break;
+ case 'm': /* specific MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'q': fquiet = 1; fskipdevid = 1; break; /* minimal output */
+ case 's': fskipdevid = 1; break; /* skip devid */
+ case 't': /* set IPMI timeout for ipmilan, usu 2 * 4 = 8 sec */
+ i = atoi(optarg);
+ if (i >= 2) { j = i / 2; i = j; }
+ else { i = 1; j = 1; }
+ ipmi_lan_set_timeout(i,j,1);
+ break;
+ case 'k': /* check for IPMI access */
+ ftest = 1;
+ break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'V': /* priv level */
+ fprivset = 1;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("%s ver %s\n", progname,progver);
+ printf(usagemsg, progname);
+ printf(" where -x shows eXtra debug messages\n");
+ printf(" -d decimal input, matching ipmitool syntax\n");
+ printf(" -k check for IPMI access\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -q quiet mode, with minimal headers\n");
+ printf(" -s skips the GetDeviceID command\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ if (ftest) {
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret == 0) {
+ /*check if a driver is loaded, or direct*/
+ i = get_driver_type();
+ printf("IPMI access is ok, driver type = %s\n",show_driver_type(i));
+ if ((i == DRV_KCS) || (i == DRV_SMB))
+ printf("Using driverless method\n");
+ }
+ else printf("IPMI access error %d\n",ret);
+ goto do_exit;
+ }
+
+ if (!fquiet) {
+ printf("%s ver %s\n", progname,progver);
+ printf("This is a test tool to compose IPMI commands.\n");
+ printf("Do not use without knowledge of the IPMI specification.\n");
+ }
+ istart = optind;
+ if (fdebug) printf("icmd: argc=%d istart=%d\n",argc,istart);
+
+ if (fset_mc == 1) {
+ /* target a specific MC via IPMB (usu a picmg blade) */
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ } else g_sa = BMC_SA;
+
+ for (i = 0; i < istart; i++) {
+ argv++; argc--;
+ }
+ if (argc < maxlen) maxlen = argc;
+ if (fdebug) printf("icmd: len=%d, cmd byte0=%s\n",maxlen,argv[0]);
+ if (fdecimal) {
+ uchar b;
+ cmdbuf[0] = g_bus;
+ cmdbuf[1] = g_sa;
+ for (i = 0; i < maxlen; i++) {
+ if (argv[i][0] == '0' && argv[i][1] == 'x') /*0x00*/
+ b = htoi(&argv[i][2]);
+ else b = atob(argv[i]); /*decimal default, or 0x00*/
+ if (i == 0) { /*special handling for netfn */
+ cmdbuf[i+2] = (b << 2) | (g_lun & 0x03);
+ } else
+ cmdbuf[i+2] = b;
+ }
+ cmdlen = i + 2;
+ } else {
+ for (i = 0; i < maxlen; i++) {
+ cmdbuf[i] = htoi(argv[i]);
+ }
+ cmdlen = i;
+ }
+
+ if (fdebug) {
+ printf("ipmi_cmd: ");
+ for (i = 0; i < cmdlen; i++)
+ printf("%02x ",cmdbuf[i]);
+ printf("\n");
+ }
+
+ if (is_remote() && fprivset == 0) { /*IPMI LAN, privilege not set by user*/
+ /* commands to other MCs require admin privilege */
+ if ((g_sa != BMC_SA) || (cmdbuf[1] != BMC_SA))
+ parse_lan_options('V',"4",0);
+ }
+
+ if (!fskipdevid) {
+ /*
+ * Check the Device ID to determine which bus id to use.
+ */
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ uchar b, j;
+ char *pstr;
+
+ if (fdebug) {
+ printf("devid: ");
+ for (j = 0; j < 16; j++) printf("%02x ",devrec[j]);
+ printf("\n");
+ }
+ b = devrec[4] & 0x0f;
+ j = devrec[4] >> 4;
+ prod_id = devrec[9] + (devrec[10] << 8);
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ if (vend_id == VENDOR_NSC) { /* NSC = 0x000322 */
+ fmBMC = 1; /*NSC miniBMC*/
+ } else if (vend_id == VENDOR_INTEL) { /* Intel = 0x000157 */
+ switch(prod_id) {
+ case 0x4311: /* Intel NSI2U*/
+ fmBMC = 1; /* Intel miniBMC*/
+ break;
+ case 0x003E: /* NSN2U or CG2100*/
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ break;
+ default:
+ break;
+ }
+ }
+ if (fmBMC) { /*NSC mini-BMC*/
+ pstr = "mBMC";
+ busid = PERIPHERAL_BUS_ID; /*used by alarms MWR*/
+ } else { /* treat like Intel Sahalee = 57 01 */
+ pstr = "BMC";
+ busid = PRIVATE_BUS_ID; /*used by alarms MWR*/
+ }
+ printf("-- %s version %x.%x, IPMI version %d.%d \n",
+ pstr, devrec[2], devrec[3], b, j);
+ }
+ // ret = ipmi_getpicmg( devrec, sizeof(devrec),fdebug);
+ // if (ret == 0) fpicmg = 1;
+ } /*endif skip devid*/
+
+ if (fjustpass) cmdmin = 2;
+ else cmdmin = 4;
+ if (cmdlen < cmdmin) {
+ printf("command length (%d) is too short\n",cmdlen);
+ printf(usagemsg, progname);
+ } else {
+ ret = send_icmd(cmdbuf,cmdlen);
+ if (!fquiet) printf("send_icmd ret = %d\n",ret);
+ }
+do_exit:
+ ipmi_close_();
+ // if (!fquiet) show_outcome(progname,ret);
+ return (ret);
+} /* end main()*/
+
+/* end icmd.c */
diff --git a/util/iconfig.c b/util/iconfig.c
new file mode 100644
index 0000000..0bb54e9
--- /dev/null
+++ b/util/iconfig.c
@@ -0,0 +1,2680 @@
+/*---------------------------------------------------------------------------
+ * Filename: iconfig.c (was bmcconfig.c)
+ *
+ * Author: arcress at users.sourceforge.net
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * Abstract:
+ * This tool saves and restores the BMC Configuration parameters.
+ * This includes BMC PEF, LAN, Serial, User, Channel, and SOL parameters.
+ *
+ * ----------- Change History -----------------------------------------------
+ * 08/18/08 Andy Cress - created from pefconfig.c
+ */
+/*M*
+ *---------------------------------------------------------------------------
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *---------------------------------------------------------------------------
+ *M*/
+#ifdef WIN32
+#include <winsock2.h>
+#include <iphlpapi.h>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <errno.h>
+#endif
+#ifdef SOLARIS
+#include <sys/sockio.h>
+#define SIOCGIFHWADDR SIOCGENADDR
+#define ifr_netmask ifr_ifru.ifru_addr
+#elif defined(BSD)
+#include <sys/sockio.h>
+#define SIOCGIFHWADDR SIOCGIFMAC
+#define ifr_netmask ifr_ifru.ifru_addr
+#elif defined(MACOS)
+#include <sys/sockio.h>
+// #define SIOCGIFHWADDR SIOCGIFMAC
+#define ifr_netmask ifr_ifru.ifru_addr
+#endif
+#include "ipmicmd.h"
+#include "oem_intel.h"
+
+extern int find_ifname(char *ifname); /*see idiscover.c*/
+/* atoip was moved to subs.c, defined in ipmicmd.h */
+
+#define SELprintf printf
+#define RTF_UP 0x0001 /* route usable */
+
+#define SOL_ENABLE_FLAG 0x01
+#define SOL_DISABLE_FLAG 0x00
+#define SOL_PRIVILEGE_LEVEL_USER 0x02
+#define SOL_PREFERRED_BAUD_RATE 0x07 /*19.2k*/
+/* For IPMI 1.5, use Intel SOL commands & subfunctions */
+#define SOL_ENABLE_PARAM 0x01
+#define SOL_AUTHENTICATION_PARAM 0x02
+#define SOL_ACC_INTERVAL_PARAM 0x03
+#define SOL_RETRY_PARAM 0x04
+#define SOL_BAUD_RATE_PARAM 0x05 /*non-volatile*/
+#define SOL_VOL_BAUD_RATE_PARAM 0x06 /*volatile*/
+/* For IPMI 2.0, use IPMI SOL commands & subfunctions */
+#define SOL_ENABLE_PARAM2 0x08
+#define SOL_AUTHENTICATION_PARAM2 0x09
+#define SOL_BAUD_RATE_PARAM2 0x11
+
+/* IPMI 2.0 SOL PAYLOAD commands */
+#define SET_PAYLOAD_ACCESS 0x4C
+#define GET_PAYLOAD_ACCESS 0x4D
+#define GET_PAYLOAD_SUPPORT 0x4E
+
+/* Channel Access values */
+#define CHAN_ACC_DISABLE 0x20 /* PEF off, disabled*/
+#define CHAN_ACC_PEFON 0x02 /* PEF on, always avail */
+#define CHAN_ACC_PEFOFF 0x22 /* PEF off, always avail*/
+/* special channel access values for ia64 */
+#define CHAN_ACC_PEFON64 0x0A /* PEF on, always avail, UserLevelAuth=off */
+#define CHAN_ACC_PEFOFF64 0x2A /* PEF off, always avail, UserLevelAuth=off */
+
+ /* TSRLT2/TIGPR2U Channels: 0=IPMB, 1=Serial/EMP, 6=LAN2, 7=LAN1 */
+ /* S5000/other Channels: 1=LAN1, 2=LAN2, 3=LAN3, 4=Serial, 6=pci, 7=sys */
+#define LAN_CH 1
+#define SER_CH 4
+#define MAXCHAN 12 /*was 16, reduced for gnu ipmi_lan*/
+#define NUM_DEVICES_TO_CHECK 32 /*for GetBmcEthDevice()*/
+#define MAC_LEN 6 /*length of MAC Address*/
+#define PSW_LEN 16 /*see also PSW_MAX=20 in ipmicmd.h*/
+#define MAXPEF 41 /* max pefnum offset = 40 (41 entries) */
+
+ /* IP address source values */
+#define SRC_STATIC 0x01
+#define SRC_DHCP 0x02 /* BMC running DHCP */
+#define SRC_BIOS 0x03 /* BIOS, sometimes DHCP */
+#define SRC_OTHER 0x04
+
+/* PEF event severities */
+#define PEF_SEV_UNSPEC 0x00
+#define PEF_SEV_MON 0x01
+#define PEF_SEV_INFO 0x02
+#define PEF_SEV_OK 0x04
+#define PEF_SEV_WARN 0x08
+#define PEF_SEV_CRIT 0x10
+#define PEF_SEV_NORECOV 0x20
+
+typedef struct
+{ /* See IPMI Table 15-2 */
+ uchar rec_id;
+ uchar fconfig;
+ uchar action;
+ uchar policy;
+ uchar severity;
+ uchar genid1;
+ uchar genid2;
+ uchar sensor_type;
+ uchar sensor_no;
+ uchar event_trigger;
+ uchar data1;
+ uchar mask1;
+ uchar res[9];
+} PEF_RECORD;
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "iconfig";
+static char fdebug = 0;
+static char fipmilan = 0;
+static FILE * fd_bmc = NULL;
+static char fIPMI10 = 0; /* =1 if IPMI v1.0 or less */
+static char fIPMI20 = 0; /* =1 if IPMI v2.0 or greater */
+static char fSOL20 = 1; /* =1 if SOL v2.0 is ok */
+static char freadonly = 1; /* =1 to only read LAN & PEF parameters */
+static char func = 'd'; /* function: display, save, restore */
+static char fdomac = 0; /* =1 to restore MAC also */
+static char fpassword = 0; /* =1 user-specified a password, so set it. */
+static uchar fmBMC = 0;
+static uchar fiBMC = 0;
+static uchar fRomley = 0;
+static char fipv6 = 0;
+static char fcanonical = 0;
+static char fchan2wart = 0; /* =1 if need wart to skip channel 2 */
+static char bdelim = BCOLON; /*':' as default*/
+static char bcomment = BCOMMENT; /* '#' */
+static char pefmax = MAXPEF; /* 20 for Sahalee, 30 for miniBMC */
+static int nerrs = 0;
+static int ngood = 0;
+static int lasterr = 0;
+static uchar nusers = 5;
+static uchar max_users = 5;
+static uchar enabled_users = 0;
+static uchar last_user_enable = 0; /* last user enabled */
+static uchar passwordData[16];
+static uchar fsetifn = 0;
+static ushort setsolcmd;
+static ushort getsolcmd;
+static uchar sol_bchan = 0;
+static uchar authmask = 0;
+static uchar lan_access = 0x04; /* see SetPassword*/
+
+static uchar pefnum = 12;
+static uchar fsharedMAC = 0;
+//static uchar alertnum = 1;
+//static uchar rgdestip[4];
+static uchar rgdestmac[6];
+static uchar rggwymac[6];
+#ifdef WIN32
+static uchar rggwyip[4] = {0,0,0,0};
+static uchar rgmyip [4] = {0,0,0,0}; /*WIN32*/
+static uchar rgmymac[6] = {0xFF,0,0,0,0,0}; /*WIN32*/
+static uchar rgsubnet[4] = {0,0,0,0}; /*WIN32*/
+static uchar osmyip[4] = {0,0,0,0};
+static uchar osmymac[6] = {0xff,0,0,0,0,0};
+#endif
+static uchar bmcmyip[4] = {0,0,0,0};
+static uchar bmcdestip[4] = {0,0,0,0};
+static uchar bmcmymac[6] = {0xFF,0,0,0,0,0};
+static char ifname[16] = "eth0"; /* interface name */
+static char ifname0[16] = "eth0"; /* first interface name */
+static char ifpattn[14] = "eth"; /* default, discovered via find_ifname */
+static int vend_id;
+static int prod_id;
+static uchar ser_ch = 0; /*was SER_CH==4*/
+static uchar lan_ch = LAN_CH;
+static uchar lan_ch_parm = 0xff;
+static uchar lan_ch_sav = 0xff;
+static uchar gcm_ch = 0;
+static uchar SessInfo[16];
+static uchar chan_type[MAXCHAN];
+static int nlans = 0;
+#define MAX_PEFPARAMS 14 /* max pef params = 14 */
+static char **pefdesc;
+static char *pefdesc1[MAXPEF] = { /* for Sahalee BMC */
+/* 0 0x00 */ "",
+/* 1 0x01 */ "Temperature Sensor",
+/* 2 0x02 */ "Voltage Sensor",
+/* 3 0x04 */ "Fan Failure",
+/* 4 0x05 */ "Chassis Intrusion",
+/* 5 0x08 */ "Power Supply Fault",
+/* 6 0x0c */ "Memory ECC Error",
+/* 7 0x0f */ "FRB Failure",
+/* 8 0x07 */ "BIOS POST Error",
+/* 9 0x13 */ "Fatal NMI",
+/*10 0x23 */ "Watchdog Timer Reset",
+/*11 0x12 */ "System Restart",
+/*12 0x20 */ "OS Critical Stop",
+/*13 0x09 */ "Power Redundancy Lost",
+/*14 0x00 */ "reserved",
+/*15 0x00 */ "reserved",
+/*16 0x00 */ "reserved",
+/*17 */ "reserved",
+/*18 */ "reserved",
+/*19 */ "reserved",
+/*20 */ "reserved",
+/*21 */ "reserved",
+/*22 */ "reserved",
+/*23 */ "reserved",
+/*24 */ "reserved",
+/*25 */ "reserved",
+/*26 */ "reserved",
+/*27 */ "reserved",
+/*28 */ "reserved",
+/*29 */ "unused",
+/*30 */ "unused" };
+
+static char *pefdesc2[MAXPEF] = { /* for NSC miniBMC */
+/* 0 */ "",
+/* 1 0x02*/ "Voltage Sensor Assert",
+/* 2 0x23*/ "Watchdog FRB Timeout", /* was "Proc FRB Thermal", */
+/* 3 0x02*/ "Voltage Sensor Deassert",
+/* 4 0x07*/ "Proc1 IERR",
+/* 5 0xff*/ "Digital Sensor OK",
+/* 6 0x14*/ "Chassis Identify",
+/* 7 0x13*/ "NMI Button",
+/* 8 0x14*/ "Clear CMOS via Panel",
+/* 9 0x0f*/ "OS Load POST Code",
+/*10 0x20*/ "OS Critical Stop",
+/*11 0x09 */ "Power Redundancy Lost",
+/*12 0x00*/ "reserved",
+/*13 */ "reserved",
+/*14 */ "reserved",
+/*15 */ "reserved",
+/*16 */ "reserved",
+/*17 */ "reserved",
+/*18 */ "reserved",
+/*19 */ "reserved",
+/*20 */ "reserved",
+/*21 */ "reserved",
+/*22 */ "reserved",
+/*23 */ "reserved",
+/*24 */ "reserved",
+/*25 */ "reserved",
+/*26 0x05*/ "Chassis Intrusion",
+/*27 0x0f*/ "POST Code Error",
+/*28 0x02*/ "Voltage Failure",
+/*29 0x04*/ "Fan Failure",
+/*30 0x01*/ "Temperature Failure"};
+
+#define NLAN 39
+static struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} lanparams[NLAN] = { /* see IPMI Table 19-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 4, "IP address"},
+ /* 4 */ { 4, 1, "IP addr src"}, /* (DHCP/Static) */
+ /* 5 */ { 5, 6, "MAC addr"},
+ /* 6 */ { 6, 4, "Subnet mask"},
+ /* 7 */ { 7, 3, "IPv4 header"},
+ /* 8 */ { 8, 2, "Prim RMCP port"},
+ /* 9 */ { 9, 2, "Sec RMCP port"},
+ /* 10 */ {10, 1, "BMC grat ARP"},
+ /* 11 */ {11, 1, "grat ARP interval"},
+ /* 12 */ {12, 4, "Def gateway IP"},
+ /* 13 */ {13, 6, "Def gateway MAC"},
+ /* 14 */ {14, 4, "Sec gateway IP"},
+ /* 15 */ {15, 6, "Sec gateway MAC"},
+ /* 16 */ {16,18, "Community string"},
+ /* 17 */ {17, 1, "Num dest"},
+ /* 18 */ {18, 5, "Dest type"},
+ /* 19 */ {19, 13, "Dest address"},
+ /* 20 */ {20, 2, "VLAN ID"},
+ /* 21 */ {21, 1, "VLAN Priority"},
+ /* 22 */ {22, 1, "Cipher Suite Support"},
+ /* 23 */ {23,17, "Cipher Suites"},
+ /* 24 */ {24, 9, "Cipher Suite Privilege"},
+ /* 25 */ {25, 4, "VLAN Dest Tag"},
+ /* 26 */ {96, 28, "OEM Alert String"},
+ /* 27 */ {97, 1, "Alert Retry Algorithm"},
+ /* 28 */ {98, 3, "UTC Offset"},
+ /* 29 */ {102, 1, "IPv6 Enable"},
+ /* 30 */ {103, 1, "IPv6 Addr Source"},
+ /* 31 */ {104,16, "IPv6 Address"},
+ /* 32 */ {105, 1, "IPv6 Prefix Len"},
+ /* 33 */ {106,16, "IPv6 Default Gateway"},
+ /* 34 */ {108,17, "IPv6 Dest address"},
+ /* 35 */ {192, 4, "DHCP Server IP"},
+ /* 36 */ {193, 6, "DHCP MAC Address"},
+ /* 37 */ {194, 1, "DHCP Enable"},
+ /* 38 */ {201, 2, "Channel Access Mode(Lan)"}
+};
+
+#define NSER 22 /* max=32 */
+static struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} serparams[NSER] = { /* see IPMI Table 20-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 1, "Connection Mode"},
+ /* 4 */ { 4, 1, "Sess Inactiv Timeout"},
+ /* 5 */ { 5, 5, "Channel Callback"},
+ /* 6 */ { 6, 1, "Session Termination"},
+ /* 7 */ { 7, 2, "IPMI Msg Comm"},
+ /* 8 */ { 8, 2, "Mux Switch"},
+ /* 9 */ { 9, 2, "Modem Ring Time"},
+ /* 10 */ {10,17, "Modem Init String"},
+ /* 11 */ {11, 5, "Modem Escape Seq"},
+ /* 12 */ {12, 8, "Modem Hangup Seq"},
+ /* 13 */ {13, 8, "Modem Dial Command"},
+ /* 14 */ {14, 1, "Page Blackout Interval"},
+ /* 15 */ {15,18, "Community String"},
+ /* 16 */ {16, 1, "Num of Alert Dest"},
+ /* 17 */ {17, 5, "Destination Info"},
+ /* 18 */ {18, 1, "Call Retry Interval"},
+ /* 19 */ {19, 3, "Destination Comm Settings"},
+ /* 20 */ {29, 2, "Terminal Mode Config"},
+ /* 21 */ {201, 2,"Channel Access Mode (Ser)"}
+};
+
+#define NSYS 6 /* num SystemParam */
+#define CHAS_RESTORE 0x00 /*chassis power restore policy*/
+#define SYS_INFO 0x01 /*System Info (1,2,3,4) */
+#define LAN_FAILOVER 0x02 /*Intel LAN Failover*/
+/* TODO: Future DCMI 1.5 params */
+#define DCMI_POWER 0x03 /*DCMI Power limit*/
+#define DCMI_THERMAL 0x04 /*DCMI Thermal params*/
+#define DCMI_CONFIG 0x05 /*DCMI Config params*/
+
+static int GetDeviceID(uchar *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pLanRecord == NULL) return(-1);
+
+ status = ipmi_cmd(GET_DEVICE_ID, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetDeviceID: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ memcpy(pLanRecord,&responseData[0],responseLength);
+ set_mfgid(&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*end GetDeviceID() */
+
+static int GetChanAcc(uchar chan, uchar parm, uchar *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pLanRecord == NULL) return(-1);
+ responseLength = 3;
+ inputData[0] = chan;
+ inputData[1] = parm; /* 0x80 = active, 0x40 = non-volatile */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_CHANNEL_ACC, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("%c GetChanAcc: completion code=%x\n",
+ bcomment,completionCode);
+ status = completionCode;
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pLanRecord,&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*GetChanAcc()*/
+
+static int SetChanAcc(uchar chan, uchar parm, uchar val, uchar access)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (fmBMC) return(0); /* mBMC doesn't support this */
+ /* parm: 0x80 = active, 0x40 = set non-vol*/
+ responseLength = 1;
+ inputData[0] = chan; /* channel */
+ inputData[1] = (parm & 0xc0) | (val & 0x3F);
+ inputData[2] = (parm & 0xc0) | access; /* set priv level */
+
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_CHANNEL_ACC, inputData, 3, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SetChanAcc: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*SetChanAcc()*/
+
+static int GetUser(int user_num)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status, i;
+ uchar completionCode;
+ char inputData[24];
+
+ inputData[0] = lan_ch;
+ inputData[1] = (uchar)user_num; /* usually = 1 for BMC LAN */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_USER_ACCESS, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == 0 && completionCode == 0) {
+ uchar c;
+ if (user_num == 1) {
+ max_users = responseData[0] & 0x3f;
+ enabled_users = responseData[1] & 0x3f;
+ if (enabled_users > nusers) nusers = enabled_users;
+ }
+ fprintf(fd_bmc,"UserAccess %d,%d%c %02x %02x %02x %02x \n",
+ lan_ch,user_num,bdelim,responseData[0],responseData[1],
+ responseData[2], responseData[3]);
+ c = responseData[3];
+ inputData[0] = (uchar)user_num; /* usually = 1 for BMC LAN */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_USER_NAME, inputData, 1, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != 0 || completionCode != 0)
+ responseData[0] = 0;
+ else {
+ fprintf(fd_bmc,"UserName %d%c",user_num,bdelim);
+ for (i=0; i< responseLength; i++)
+ fprintf(fd_bmc," %02x",responseData[i]);
+ fprintf(fd_bmc,"\n");
+ fprintf(fd_bmc,"%c UserPassword %d%c",bcomment,user_num,bdelim);
+ for (i=0; i< PSW_LEN; i++)
+ fprintf(fd_bmc," 00");
+ fprintf(fd_bmc,"\n");
+ }
+ } else
+ printf("%c GetUserAccess(%d,%d), status=%x, ccode=%x\n",
+ bcomment,lan_ch,user_num, status, completionCode);
+ return(status);
+} /*end GetUser()*/
+
+static int GetSerEntry(uchar subfunc, uchar bset, uchar *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+ uchar chan;
+
+ if (pLanRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetSerEntry(%d): error, output buffer is NULL\n",subfunc);
+ return (-1);
+ }
+
+ chan = ser_ch; /* 1=EMP, 0=IPMB, 6=LAN2, 7=LAN1 */
+
+ inputData[0] = chan; // flags, channel 3:0 (1=EMP)
+ inputData[1] = subfunc; // Param selector
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+ if (subfunc == 10) {
+ inputData[2] = 0;
+ inputData[3] = 1;
+ }
+
+ status = ipmi_cmd(GET_SER_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetSerEntry(%d,%d): completion code=%x\n",
+ chan,subfunc,completionCode);
+ status = completionCode;
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pLanRecord,&responseData[1],responseLength-1);
+ pLanRecord[responseLength-1] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetSerEntry(%d,%d): ipmi_cmd status=%x ccode=%x\n",
+ chan,subfunc,status,completionCode);
+ return status;
+}
+
+static int SetSerEntry(uchar subfunc, uchar *pSerRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pSerRecord == NULL) {
+ if (fdebug)
+ printf("SetSerEntry(%d): error, input buffer is NULL\n",
+ subfunc);
+ return (-1);
+ }
+ inputData[0] = ser_ch; // flags, channel 3:0 (EMP)
+ inputData[1] = subfunc; // Param selector
+ memcpy(&inputData[2],pSerRecord,reqlen);
+ status = ipmi_cmd(SET_SER_CONFIG, inputData, (uchar)(reqlen+2),
+ responseData, &responseLength, &completionCode, fdebug);
+
+ if (fdebug)
+ printf("SetSerEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ status = completionCode;
+ if (completionCode == 0x80)
+ printf("SetSerEntry(%d): Parameter not supported\n",
+ subfunc);
+ else
+ printf("SetSerEntry(%d): completion code=%x\n",
+ subfunc, completionCode);
+ }
+ // else successful, done
+ }
+ return status;
+} /* end SetSerEntry() */
+
+static int GetLanEntry(uchar subfunc, uchar bset, uchar *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status, n;
+ uchar completionCode;
+ uchar chan;
+
+ if (pLanRecord == NULL) {
+ if (fdebug) printf("GetLanEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ chan = lan_ch; /* LAN 1 = 7 */
+
+ inputData[0] = chan; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+
+ status = ipmi_cmd(GET_LAN_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetLanEntry(%d,%d): completion code=%x\n",
+ chan,subfunc,completionCode);
+ status = completionCode;
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ if (responseLength > 0) {
+ n = responseLength-1;
+ memcpy(pLanRecord,&responseData[1],n);
+ } else n = 0;
+ pLanRecord[n] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetLanEntry(%d,%d): status=%d completionCode=%x\n",
+ chan,subfunc,status,completionCode);
+ return (status);
+} /* end GetLanEntry() */
+
+static int SetLanEntry(uchar subfunc, uchar *pLanRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pLanRecord == NULL)
+ {
+ if (fdebug)
+ printf("SetLanEntry(%d): error, input buffer is NULL\n",subfunc);
+ return (-1);
+ }
+
+ if ((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) {
+ /* SUPERMICRO cannot set grat arp or grat arp interval */
+ if (subfunc == 10 || subfunc == 11) return(0);
+ }
+ inputData[0] = lan_ch; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ memcpy(&inputData[2],pLanRecord,reqlen);
+
+ status = ipmi_cmd(SET_LAN_CONFIG, inputData, (uchar)(reqlen+2),
+ responseData, &responseLength,&completionCode,fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("SetLanEntry(%d,%d): completion code=%x\n",
+ lan_ch,subfunc,completionCode);
+ return(completionCode);
+ } else {
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("SetLanEntry(%d,%d): ipmi_cmd status=%d ccode=%x\n",
+ lan_ch,subfunc,status,completionCode);
+ return (status);
+} /* end SetLanEntry() */
+
+static int GetPefEntry(uchar subfunc, ushort rec_id, PEF_RECORD *pPefRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status, n;
+ uchar completionCode;
+
+ if (pPefRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetPefEntry(%d): error, output buffer is NULL\n",subfunc);
+ return (-1);
+ }
+
+ inputData[0] = subfunc; // Parameter = Evt Filter Table
+ inputData[1] = (uchar)rec_id;
+ inputData[2] = 0;
+
+ status = ipmi_cmd(GET_PEF_CONFIG, inputData, 3, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetPefEntry(%d/%d): completion code=%x\n",
+ subfunc,rec_id,completionCode);
+ status = completionCode;
+ } else {
+ /* expect PEF record to be >=21 bytes */
+ if (responseLength > 1) n = responseLength-1;
+ else n = 0;
+ if (n > 21) n = 21;
+ // dont copy first byte (Parameter revision, usu 0x11)
+ if (n == 0) memset(pPefRecord,0,21);
+ else memcpy(pPefRecord,&responseData[1],n);
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetPefEntry: ipmi_cmd status=%x completionCode=%x\n",
+ status, completionCode);
+ return status;
+} /* end GetPefEntry() */
+
+static int SetPefEntry(PEF_RECORD *pPefRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24]; /* sizeof(PEF_RECORD) = 21 +1=22 */
+ int status;
+ uchar completionCode;
+ uchar subfunc;
+
+ subfunc = 0x06; // Parameter = Evt Filter Table
+
+ if (pPefRecord == NULL) {
+ if (fdebug)
+ printf("SetPefEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
+ // 06 0c 80 01 01 00 ff ff 20 ff 6f ff 00 00 00 00 00 00 00 00 00 00
+ // memset(&inputData[0],0,requestData.dataLength);
+ inputData[0] = subfunc;
+ memcpy(&inputData[1],pPefRecord,sizeof(PEF_RECORD));
+
+ status = ipmi_cmd(SET_PEF_CONFIG, inputData, sizeof(PEF_RECORD)+1,
+ responseData, &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("SetPefEntry: completion code=%x\n",
+ completionCode); // responseData[0]);
+ status = completionCode;
+ } else {
+ //successful, done
+ return(0);
+ }
+
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("SetPefEntry: ipmi_cmd status=%d ccode=%x\n",
+ status,completionCode);
+ return(status);
+
+} /* end SetPefEntry() */
+
+static int MacIsValid(uchar *mac)
+{
+ int fvalid = 0;
+ int i;
+ /* check for initial invalid value of FF:00:... */
+ if (mac[0] == 0xFF && mac[1] == 0x00) /* marked as invalid */
+ return(fvalid);
+ /* check for all zeros */
+ for (i = 0; i < MAC_LEN; i++)
+ if (mac[i] != 0) { /* not all zeros */
+ fvalid = 1;
+ break;
+ }
+ return(fvalid);
+}
+
+static int IpIsValid(uchar *ipadr)
+{
+ int fvalid = 1;
+ if (ipadr[0] == 0) fvalid = 0;
+ return(fvalid);
+}
+
+static int SubnetIsValid(uchar *subnet)
+{
+ int fvalid = 0;
+ /* if masking off at least one bit, say valid */
+ if ((subnet[0] & 0x80) == 0x80) fvalid = 1;
+ return(fvalid);
+}
+
+#ifdef WIN32
+/*
+ * Obtain network adapter information (Windows).
+ */
+static PIP_ADAPTER_ADDRESSES GetAdapters() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ ULONG OutBufferLength = 0;
+ ULONG RetVal = 0, i;
+
+ // The size of the buffer can be different
+ // between consecutive API calls.
+ // In most cases, i < 2 is sufficient;
+ // One call to get the size and one call to get the actual parameters.
+ // But if one more interface is added or addresses are added,
+ // the call again fails with BUFFER_OVERFLOW.
+ // So the number is picked slightly greater than 2.
+ // We use i <5 in the example
+ for (i = 0; i < 5; i++) {
+ RetVal = GetAdaptersAddresses(
+ AF_INET, 0, NULL,
+ AdapterAddresses,
+ &OutBufferLength);
+
+ if (RetVal != ERROR_BUFFER_OVERFLOW) {
+ break;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+
+ AdapterAddresses = (PIP_ADAPTER_ADDRESSES) malloc(OutBufferLength);
+ if (AdapterAddresses == NULL) {
+ RetVal = GetLastError();
+ break;
+ }
+ }
+ if (RetVal == NO_ERROR) {
+ // If successful, return pointer to structure
+ return AdapterAddresses;
+ }
+ else {
+ LPVOID MsgBuf;
+
+ printf("Call to GetAdaptersAddresses failed.\n");
+ if (FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ RetVal,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPTSTR) &MsgBuf,
+ 0,
+ NULL )) {
+ printf("\tError: %s", MsgBuf);
+ }
+ LocalFree(MsgBuf);
+ }
+ return NULL;
+}
+
+/*
+ * Set BMC MAC corresponding to current BMC IP address (Windows).
+ */
+static int GetLocalMACByIP() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ addr = AdapterList->FirstUnicastAddress;
+ if (addr == NULL) si = NULL;
+ else si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ if (si != NULL) {
+ if(memcmp(&si->sin_addr.s_addr, rgmyip, 4) == 0) {
+ memcpy(rgmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ result = 1;
+ break;
+ }
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+/*
+ * Set BMC MAC corresponding to current BMC IP address (Windows).
+ */
+static int GetLocalIPByMAC(uchar *macadr) {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ if(memcmp(AdapterList->PhysicalAddress, macadr, MAC_LEN) == 0) {
+ addr = AdapterList->FirstUnicastAddress;
+
+ si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ if (fdebug) {
+ uchar *psaddr;
+ psaddr = (uchar *)&si->sin_addr.s_addr;
+ printf("mac match: rgmyip=%d.%d.%d.%d s_addr=%d.%d.%d.%d\n",
+ rgmyip[0], rgmyip[1], rgmyip[2], rgmyip[3],
+ psaddr[0], psaddr[1], psaddr[2], psaddr[3]);
+ }
+ if (!IpIsValid(rgmyip) && (fsharedMAC==1)) /*not specified, shared*/
+ memcpy(rgmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ wcstombs(ifname,AdapterList->FriendlyName, sizeof(ifname));
+ result = 1;
+ break;
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+/*
+ * Set MAC and IP address from given interface name (Windows).
+ */
+static int GetLocalDataByIface() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ size_t origsize, newsize, convertedChars;
+ wchar_t* wcstring;
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ origsize = strlen(ifname) + 1;
+ newsize = origsize;
+ convertedChars = 0;
+ wcstring = (wchar_t*) malloc(sizeof(wchar_t) * newsize) ;
+ if (wcstring == NULL) AdapterList = NULL; /*skip loop, do free*/
+ else mbstowcs(wcstring, ifname, origsize );
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ if(wcsstr(AdapterList->FriendlyName, wcstring)) {
+ printf("Using interface: %S\n", AdapterList->FriendlyName);
+ printf("\t%S\n", AdapterList->Description);
+ addr = AdapterList->FirstUnicastAddress;
+
+ si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ memcpy(rgmyip, &si->sin_addr.s_addr, 4);
+ memcpy(rgmymac, AdapterList->PhysicalAddress, MAC_LEN);
+
+ result = 1;
+ break;
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+static int FindEthNum(uchar *macadrin)
+{
+ int i;
+ uchar macadr[MAC_LEN];
+ memcpy(macadr,macadrin,MAC_LEN);
+ if (fsharedMAC == 0 && vend_id == VENDOR_INTEL) {
+ /* Intel factory assigns them this way, so use that to compare */
+ macadr[MAC_LEN-1] -= 2; /*OS MAC = BMC MAC - 2*/
+ }
+ i = GetLocalIPByMAC(macadr);
+ if (fdebug) /* show the local OS eth if and MAC */
+ printf("FindEth: OS %s IP=%d.%d.%d.%d MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ ifname, rgmyip[0], rgmyip[1], rgmyip[2], rgmyip[3],
+ rgmymac[0], rgmymac[1], rgmymac[2], rgmymac[3],
+ rgmymac[4], rgmymac[5]);
+ /* The actual Windows ethernet interface is determined
+ * in Get_IPMac_Addr using ipconfig, so
+ * init eth interface number as eth0 for Windows. */
+ return(i);
+}
+#elif defined(HPUX)
+static int FindEthNum(uchar *macadrin)
+{
+ return(0);
+}
+#else
+/* Linux, BSD, Solaris */
+static char *get_ifreq_mac(struct ifreq *ifrq)
+{
+ char *ptr;
+#ifdef SOLARIS
+ ptr = (char *)&ifrq->ifr_ifru.ifru_enaddr[0];
+#elif BSD
+ ptr = (char *)&ifrq->ifr_ifru.ifru_addr.sa_data[0];
+#elif MACOS
+ static uchar mactmp[MAC_LEN];
+ ptr = &mactmp[0];
+ MacSetInvalid(ptr);
+#else
+ ptr = (char *)&ifrq->ifr_hwaddr.sa_data[0];
+#endif
+ return (ptr);
+}
+
+
+static int FindEthNum(uchar *macadrin)
+{ /*only used for Linux*/
+ struct ifreq ifr;
+ int skfd;
+ int nCurDevice;
+ uchar macadr[MAC_LEN];
+ char szDeviceName[ 16 ]; /* sizeof(ifpattn), MAX_DEVICE_NAME_LENGTH + 1 */
+ int devnum = -1;
+ int n;
+
+ memcpy(macadr,macadrin,MAC_LEN);
+ if (fsharedMAC == 0 && vend_id == VENDOR_INTEL) {
+ /* Intel factory assigns them this way, so use that to compare */
+ macadr[MAC_LEN-1] -= 2; /*OS MAC = BMC MAC - 2*/
+ }
+ n = find_ifname(szDeviceName);
+ if (n >= 0) {
+ n = strlen_(szDeviceName);
+ if (n < sizeof(ifpattn)) {
+ strcpy(ifname0,szDeviceName);
+ strcpy(ifpattn,szDeviceName);
+ ifpattn[n - 1] = 0; /*truncate last digit*/
+ }
+ if (fdebug)
+ printf("found ifname %s, pattern %s\n",szDeviceName,ifpattn);
+ }
+
+ if ( ( skfd = socket(AF_INET, SOCK_DGRAM, 0 ) ) < 0) {
+ if ( fdebug ) {
+ perror("socket");
+ return devnum;
+ }
+ }
+
+ for( nCurDevice = 0 ;
+ (nCurDevice < NUM_DEVICES_TO_CHECK) && (devnum == -1);
+ nCurDevice++ )
+ {
+ sprintf( szDeviceName, "%s%d", ifpattn, nCurDevice );
+ strcpy(ifr.ifr_name, szDeviceName );
+#ifdef SIOCGIFHWADDR
+ if (ioctl(skfd, SIOCGIFHWADDR, &ifr) > 0) {
+ if ( fdebug )
+ printf("FindEthNum: Could not get MAC address for %s\n",
+ szDeviceName);
+ } else
+#endif
+ {
+ if (memcmp(get_ifreq_mac(&ifr), macadr, MAC_LEN) == 0) {
+ devnum = nCurDevice;
+ break;
+ }
+ }
+ }
+ close(skfd);
+ return(devnum);
+}
+#endif
+
+/*
+ * GetBmcEthDevice
+ * Attempt to auto-detect the BMC LAN channel and matching OS eth port.
+ * INPUT: lan_parm = lan channel from user -L option, 0xFF if not specified
+ * OUTPUT: lan_ch is set to BMC LAN channel number
+ * if success, returns index of OS eth port (0, 1, ...).
+ * if no lan channels found, returns -2.
+ * if other error, returns -1.
+ */
+static int GetBmcEthDevice(uchar lan_parm)
+{
+ uchar LanRecord[30];
+ int devnum = -1;
+ int ret;
+ uchar bmcMacAddress[ MAC_LEN ]; /*MAC_LEN = 6*/
+ int rlen;
+ uchar iData[2];
+ uchar rData[10];
+ uchar cc;
+ int i = 0;
+ int j, jstart, jend, jlan;
+ uchar mtype;
+ uchar *pb;
+ int fchgmac;
+
+ /* Find the LAN channel(s) via Channel Info */
+ if (lan_parm < MAXCHAN) { /* try user-specified channel only */
+ lan_ch = lan_parm;
+ jstart = lan_parm;
+ jend = lan_parm+1;
+ } else {
+ jstart = 1;
+ jend = MAXCHAN;
+ for (j = 0; j < MAXCHAN; j++) chan_type[j] = 0;
+ }
+ memset(bmcMacAddress,0xff,sizeof(bmcMacAddress)); /*initialize to invalid*/
+ for (j = jstart; j < jend; j++) {
+ rlen = sizeof(rData);
+ iData[0] = (uchar)j; /*channel #*/
+ memset(rData,0,9); /*initialize recv data*/
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug);
+ if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */
+ continue;
+ if (ret != 0) {
+ if (fdebug) printf("get_chan_info rc = %x\n",ret);
+ break;
+ }
+ mtype = rData[1]; /* channel medium type */
+ chan_type[j] = mtype;
+ if (mtype == 4) { /* 802.3 LAN type*/
+ if (fdebug) printf("chan[%d] = lan\n",j);
+ jlan = lan_ch; /*save prev lan chan */
+ /* Get BMC MAC for this LAN channel. */
+ /* Note: BMC MAC may not be valid yet. */
+ lan_ch = (uchar)j; /*set lan channel for GetLanEntry()*/
+ ret = GetLanEntry( 5 /*MAC_ADDRESS_LAN_PARAM*/,0, LanRecord);
+ if ( ret < 0 ) {
+ lan_ch = (uchar)jlan; /*restore lan_ch*/
+ printf( "GetBmcEthDevice: GetLanEntry failed\n" );
+ return devnum;
+ }
+ pb = &LanRecord[0];
+ if (fdebug) printf("chan[%d] BMC MAC %x:%x:%x:%x:%x:%x\n",j,
+ pb[0], pb[1], pb[2], pb[3], pb[4], pb[5] );
+ fchgmac = 0;
+ if (!MacIsValid(bmcMacAddress)) /* old MAC not valid */
+ fchgmac = 1;
+ else if (MacIsValid(pb) && /* new MAC is valid and */
+ (memcmp(bmcMacAddress,pb, sizeof(bmcMacAddress)) > 0))
+ fchgmac = 1; /* new MAC lower */
+ if (fchgmac) { /* use lowest valid MAC */
+ memcpy(bmcMacAddress,pb,sizeof(bmcMacAddress));
+ lan_ch = (uchar)j;
+ } else lan_ch = (uchar)jlan; /* restore prev lan chan */
+ i++; /* i = num lan channels found */
+ } else if (mtype == 5) { /* serial type*/
+ if (fdebug) printf("chan[%d] = serial\n",j);
+ ser_ch = (uchar)j; /* set to last serial channel */
+ } else if (mtype == 7) { /* PCI SMBus */
+ if (fdebug) printf("chan[%d] = pci_smbus\n",j);
+ } else if (mtype == 12) { /* system interface */
+ if (fdebug) printf("chan[%d] = system_interface\n",j);
+ } else /* other channel medium types, see IPMI 1.5 Table 6-3 */
+ if (fdebug) printf("chan[%d] = %d\n",j,mtype);
+ }
+ nlans = i;
+ if (i == 0) return(-2); /* no lan channels found */
+ if (fdebug) printf("lan_ch detected = %d\n",lan_ch);
+
+ devnum = FindEthNum(bmcMacAddress);
+ if ( fdebug )
+ printf("GetBmcEthDevice: channel %d, %s%d\n",lan_ch,ifpattn,devnum);
+ return devnum;
+}
+
+/*
+ * atomac - converts ASCII string to binary MAC address (array).
+ * Accepts input formatted as 11:22:33:44:55:66 or 11-22-33-44-55-66.
+ */
+static void atomac(uchar *array, char *instr)
+{
+ int i,j,n;
+ char *pi;
+ j = 0;
+ pi = instr;
+ n = strlen_(instr);
+ for (i = 0; i <= n; i++) {
+ if (instr[i] == ':') {
+ array[j++] = htoi(pi);
+ pi = &instr[i+1];
+ } else if (instr[i] == '-') {
+ array[j++] = htoi(pi);
+ pi = &instr[i+1];
+ } else if (instr[i] == 0) {
+ array[j++] = htoi(pi);
+ }
+ if (j >= MAC_LEN) break; /*safety valve*/
+ }
+ if (fdebug)
+ printf("atomac: %02x %02x %02x %02x %02x %02x\n",
+ array[0],array[1],array[2],array[3], array[4],array[5]);
+} /*end atomac()*/
+
+/* file_grep/findmatch no longer used here, see ievents.c */
+
+/*
+ * Get_Mac
+ * This routine finds a MAC address from a given IP address.
+ * Usually for the Alert destination.
+ * It uses ARP cache to do this.
+ */
+#ifdef WIN32
+static int Get_Mac(uchar *ipadr,uchar *macadr)
+{
+ DWORD dwRetVal;
+ IPAddr DestIp = 0;
+ IPAddr SrcIp = 0; /* default for src ip */
+ ULONG MacAddr[2]; /* for 6-byte hardware addresses */
+ ULONG PhysAddrLen = MAC_LEN; /* default to length of six bytes */
+ BYTE *bPhysAddr;
+
+
+ memcpy(&DestIp, ipadr, 4);
+
+ /* invoke system ARP query */
+ dwRetVal = SendARP(DestIp, SrcIp, MacAddr, &PhysAddrLen);
+
+ if (dwRetVal == NO_ERROR)
+ { /* no error - get the MAC */
+ bPhysAddr = (BYTE *) & MacAddr;
+ if (PhysAddrLen) {
+ memcpy(macadr, bPhysAddr, MAC_LEN);
+ } else
+ printf("Warning: SendArp completed successfully, but returned length=0\n");
+ } else if (dwRetVal == ERROR_GEN_FAILURE)
+ { /* MAC not available in this netowork - get gateway MAC */
+ memcpy(macadr, rggwymac, MAC_LEN);
+ } else
+ { /* other errors */
+ printf("Error: SendArp failed with error: %d", dwRetVal);
+ switch (dwRetVal) {
+ case ERROR_INVALID_PARAMETER:
+ printf(" (ERROR_INVALID_PARAMETER)\n");
+ break;
+ case ERROR_INVALID_USER_BUFFER:
+ printf(" (ERROR_INVALID_USER_BUFFER)\n");
+ break;
+ case ERROR_BAD_NET_NAME:
+ printf(" (ERROR_GEN_FAILURE)\n");
+ break;
+ case ERROR_BUFFER_OVERFLOW:
+ printf(" (ERROR_BUFFER_OVERFLOW)\n");
+ break;
+ case ERROR_NOT_FOUND:
+ printf(" (ERROR_NOT_FOUND)\n");
+ break;
+ default:
+ printf("\n");
+ break;
+ }
+ return 1;
+ }
+ return 0;
+} /* end Get_Mac()*/
+/*endif WIN32 */
+#else
+/*else Linux */
+static int Get_Mac(uchar *ipadr,uchar *macadr)
+{
+ FILE *fparp;
+ char buff[1024];
+ /* char arpfile[] = "/proc/net/arp"; */
+ char alertfile[] = "/tmp/dest.arping";
+ char arping_cmd[128];
+ char *pb, *pm, *px;
+ int num, i;
+ int foundit = 0;
+ int ret = 0;
+ char *_ifname;
+
+ if (strcmp(ifname,"gcm") == 0) _ifname = ifname0;
+ else _ifname = ifname;
+
+ /* Get a MAC address for a given IP address */
+ if (ipadr[0] != 0) { /* if valid IP address */
+
+ /* make sure the destination is in the arp cache */
+ sprintf(arping_cmd,
+ "arping -I %s -c 2 %d.%d.%d.%d |grep reply |tail -n1 >%s\n",
+ _ifname,ipadr[0],ipadr[1],ipadr[2],ipadr[3],alertfile);
+ if (fdebug) printf("%s", arping_cmd);
+ system(arping_cmd);
+
+ fparp = fopen(alertfile,"r");
+ if (fparp == NULL) {
+ fprintf(stdout,"Get_Mac: Cannot open %s, errno = %d\n",
+ alertfile,get_errno());
+ ret = -1;
+ } else {
+ while (fgets(buff, 1023, fparp)) {
+ /* should only run through loop once */
+ num = strcspn(buff," \t"); /* skip 1st word ("Unicast") */
+ i = strspn(&buff[num]," \t");
+ pb = &buff[num+i];
+ if (strncmp(pb,"reply",5) == 0) { /* valid output */
+ /* Find the ip address */
+ pb += 6 + 5; /* skip "reply from " */
+ num = strcspn(pb," \t");
+ pb[num] = 0;
+ if (fdebug) printf("Alert ip=%s\n",pb);
+ /* IP address should already match input param */
+ /* if (rgdestip[0] == 0) atoip(rgdestip,pb); */
+ /* Now find the mac address */
+ pm = strchr(&pb[num+1],'[');
+ if (pm == NULL) pm = &pb[num+2]; /* just in case */
+ pm++;
+ px = strchr(pm,']');
+ if (px == NULL) px = pm + 17; /* just in case */
+ px[0] = 0;
+ if (fdebug) printf("Alert mac=%s\n",pm);
+ foundit = 1;
+ if (!MacIsValid(macadr)) atomac(macadr,pm);
+ break;
+ }
+ } /*end while*/
+ fclose(fparp);
+ } /*end else file opened*/
+ } /*endif valid IP */
+ else ret = -1;
+
+ if (ret == -1 || foundit == 0) { /* couldn't get it */
+ if (MacIsValid(rggwymac) && !MacIsValid(rgdestmac))
+ memcpy(rgdestmac,rggwymac,6); /* get to it from the default gateway */
+ }
+ return(ret);
+} /* end Get_Mac()*/
+/*end else Linux*/
+#endif
+
+#ifdef WIN32
+
+/*
+ * Set subnet mask based on current IP address (Windows).
+ */
+static int SetSubnetMask() {
+ PMIB_IPADDRTABLE pIPAddrTable;
+ unsigned int i;
+ DWORD dwSize = 0, dwRetVal;
+ LPVOID lpMsgBuf;
+
+ pIPAddrTable = (MIB_IPADDRTABLE*) malloc( sizeof( MIB_IPADDRTABLE) );
+
+ if ( pIPAddrTable ) {
+ // Make an initial call to GetIpAddrTable to get the
+ // necessary size into the dwSize variable
+ if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
+ free( pIPAddrTable );
+ pIPAddrTable = (MIB_IPADDRTABLE *) malloc ( dwSize );
+ }
+ } else
+ printf("Memory allocation failed.\n");
+
+ if ( pIPAddrTable ) {
+ // Make a second call to GetIpAddrTable to get the
+ // actual data we want
+ if ( (dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 )) == NO_ERROR ) {
+ for(i = 0; i < pIPAddrTable->dwNumEntries; ++i) {
+ if(memcmp(&(pIPAddrTable->table[i].dwAddr), rgmyip, 4) == 0) {
+ memcpy(rgsubnet, &(pIPAddrTable->table[i].dwMask), 4);
+ free( pIPAddrTable );
+ return 1;
+ }
+ }
+ } else {
+ if (FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ dwRetVal,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPTSTR) &lpMsgBuf,
+ 0,
+ NULL )) {
+ printf("\tError: %s", lpMsgBuf);
+ }
+
+ printf("Call to GetIpAddrTable failed.\n");
+ }
+ }
+
+ if ( pIPAddrTable )
+ free( pIPAddrTable );
+
+ return 0;
+}
+
+/*
+ * Extract gateway address from routing table (Windows).
+ */
+static int SetDefaultGateway() {
+ PMIB_IPFORWARDTABLE pIpForwardTable;
+ DWORD dwRetVal, dwSize;
+
+ unsigned int nord_mask;
+ unsigned int nord_ip;
+ unsigned int nord_net;
+
+ unsigned int i;
+
+ nord_mask = *((unsigned int *)rgsubnet);
+ nord_ip = *((unsigned int *)rgmyip);
+
+ nord_net = nord_ip & nord_mask;
+
+ pIpForwardTable = (MIB_IPFORWARDTABLE*) malloc(sizeof(MIB_IPFORWARDTABLE));
+ if (pIpForwardTable == NULL) {
+ printf("Error allocating memory\n");
+ return 0;
+ }
+
+ dwSize = 0;
+ if (GetIpForwardTable(pIpForwardTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
+ free(pIpForwardTable);
+ pIpForwardTable = (MIB_IPFORWARDTABLE*) malloc(dwSize);
+ if (pIpForwardTable == NULL) {
+ printf("Error allocating memory\n");
+ return 0;
+ }
+ }
+
+ /*
+ * Note that the IPv4 addresses returned in
+ * GetIpForwardTable entries are in network byte order
+ */
+ if ((dwRetVal = GetIpForwardTable(pIpForwardTable, &dwSize, 0)) == NO_ERROR) {
+ for (i = 0; i < (int) pIpForwardTable->dwNumEntries; i++) {
+ unsigned int gwaddr = pIpForwardTable->table[i].dwForwardNextHop;
+ if(nord_net == (gwaddr & nord_mask) && nord_ip != gwaddr)
+ { /* searching for gateways from our network with different address than ours */
+ memcpy(rggwyip, &gwaddr, 4);
+ return 0;
+ }
+ }
+ free(pIpForwardTable);
+ return 1;
+ }
+ else {
+ printf("\tGetIpForwardTable failed.\n");
+ free(pIpForwardTable);
+ return 0;
+ }
+
+}
+/*endif WIN32*/
+#endif
+
+static int ShowChanAcc(uchar bchan)
+{
+ uchar LanRecord[30];
+ int ret = 0;
+
+ ret = GetChanAcc(bchan, 0x40, LanRecord);
+ if (fdebug)
+ printf(" GetChanAcc(%d) ret = %d, data = %02x %02x\n",
+ bchan,ret, LanRecord[0], LanRecord[1]);
+ if (ret == 0)
+ fprintf(fd_bmc,"ChannelAccess %d%c %02x %02x \n",
+ bchan,bdelim,LanRecord[0],LanRecord[1]);
+ return(ret);
+}
+
+static int GetSerialOverLan( uchar chan, uchar bset, uchar block )
+{
+ uchar requestData[24];
+ uchar rData[MAX_BUFFER_SIZE];
+ int rlen;
+ int status, i;
+ uchar ccode;
+ uchar enable_parm, auth_parm, baud_parm;
+ uchar user;
+
+ if (fIPMI20 && fSOL20) {
+ getsolcmd = GET_SOL_CONFIG2;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ } else {
+ getsolcmd = GET_SOL_CONFIG;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ chan = 0; /*override chan for IPMI 1.5*/
+ }
+ printf("%c## %s, GetSOL for channel %d ...\n",bcomment,progname,chan);
+
+ requestData[0] = chan; /*channel*/
+ requestData[1] = enable_parm;
+ requestData[2] = bset; /*set*/
+ requestData[3] = block; /*block*/
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd, requestData,4, rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ if (ccode == 0xC1) { /* unsupported command */
+ printf("%c Serial-Over-Lan not available on this platform\n",
+ bcomment);
+ return(status);
+ } else {
+ printf("%c SOL Enable ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ }
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,enable_parm,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+
+ requestData[0] = chan;
+ requestData[1] = auth_parm;
+ requestData[2] = bset; // selector
+ requestData[3] = block; // block
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd, requestData,4,rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("%c SOL Auth ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,auth_parm,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+
+ requestData[0] = chan;
+ requestData[1] = SOL_ACC_INTERVAL_PARAM;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd, requestData,4,rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("%c SOL Accum Interval ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,SOL_ACC_INTERVAL_PARAM,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+
+ requestData[0] = chan;
+ requestData[1] = SOL_RETRY_PARAM;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd, requestData,4,rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("%c SOL Retry ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,SOL_RETRY_PARAM,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+
+ if (!fRomley) {
+ requestData[0] = chan;
+ requestData[1] = baud_parm;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("%c SOL nvol Baud ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,baud_parm,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+
+ requestData[0] = chan;
+ requestData[1] = SOL_VOL_BAUD_RATE_PARAM; /*0x06*/
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("%c SOL vol Baud ccode = %x\n",bcomment,ccode);
+ status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLParam %d,%d,%d%c",chan,SOL_VOL_BAUD_RATE_PARAM,bset,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+ }
+
+ if (fIPMI20) {
+ requestData[0] = chan;
+ rlen = sizeof(rData);
+ status = ipmi_cmdraw(GET_PAYLOAD_SUPPORT, NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ requestData,1,rData, &rlen, &ccode, fdebug);
+ if ((status != 0) || (ccode != 0)) {
+ printf("%c SOL Payload Support(%d) error %d, ccode = %x\n",
+ bcomment,chan,status,ccode);
+ if (status == 0) status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLPayloadSupport %d%c",chan,bdelim);
+ for (i = 1; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+ /* get Payload Access for nusers, not just lan_user */
+ for (user = 1; user <= nusers; user++)
+ {
+ /* IPMI 2.0 nusers >= 4 users */
+ requestData[0] = chan;
+ requestData[1] = user;
+ rlen = sizeof(rData);
+ status = ipmi_cmdraw(GET_PAYLOAD_ACCESS, NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ requestData,2,rData, &rlen, &ccode, fdebug);
+ if ((status != 0) || (ccode != 0)) {
+ printf("%c SOL Payload Access(%d,%d) error %d, ccode = %x\n",
+ bcomment,chan,user,status,ccode);
+ if (status == 0) status = ccode;
+ } else { /*success*/
+ fprintf(fd_bmc,"SOLPayloadAccess %d,%d%c",chan,user,bdelim);
+ for (i = 0; i < rlen; i++) fprintf(fd_bmc," %02x",rData[i]);
+ fprintf(fd_bmc,"\n");
+ }
+ } /*end user loop*/
+ }
+
+ return(status);
+} /*end GetSerialOverLan */
+
+static char *PefDesc(int idx, uchar stype)
+{
+ char *pdesc;
+ if (pefdesc == NULL) pdesc = "reserved";
+ else pdesc = pefdesc[idx];
+ if ((stype != 0) && (strcmp(pdesc,"reserved") == 0)) {
+ /* pefdesc may not match on some non-Intel systems. */
+ /* so use sensor type */
+ switch(stype) {
+ case 0x01: pdesc = "Temperature"; break;
+ case 0x02: pdesc = "Voltage"; break;
+ case 0x04: pdesc = "Fan"; break;
+ case 0x05: pdesc = "Chassis"; break;
+ case 0x07: pdesc = "BIOS"; break;
+ case 0x08: pdesc = "Power Supply"; break;
+ case 0x09: pdesc = "Power Unit"; break;
+ case 0x0c: pdesc = "Memory"; break;
+ case 0x0f: pdesc = "Boot"; break;
+ case 0x12: pdesc = "System Restart"; break;
+ case 0x13: pdesc = "NMI"; break;
+ case 0x23: pdesc = "Watchdog"; break;
+ case 0x20: pdesc = "OS Critical Stop"; break;
+ default: pdesc = "Other"; break;
+ }
+ }
+ return(pdesc);
+}
+
+static int GetSessionInfo(uchar *rData, int sz)
+{
+ int rv, rlen;
+ uchar ccode;
+ uchar iData[5];
+
+ iData[0] = 0x00; /*get data for this session*/
+ rlen = sz;
+ rv = ipmi_cmdraw(CMD_GET_SESSION_INFO,NETFN_APP, BMC_SA,PUBLIC_BUS,BMC_LUN,
+ iData,1,rData, &rlen, &ccode, fdebug);
+ if ((rv == 0) && (ccode != 0)) rv = ccode;
+ return(rv);
+}
+
+static int GetPefCapabilities(uchar *bmax)
+{
+ int rv, rlen;
+ uchar ccode;
+ uchar rData[MAX_BUFFER_SIZE];
+
+ rlen = sizeof(rData);
+ rv = ipmi_cmdraw(0x10, NETFN_SEVT, BMC_SA,PUBLIC_BUS,BMC_LUN,
+ NULL,0,rData, &rlen, &ccode, fdebug);
+ if ((rv == 0) && (ccode != 0)) rv = ccode;
+ if ((rv == 0) && (bmax != NULL))
+ *bmax = rData[2]; /*max num PEF table entries*/
+ return(rv);
+}
+
+int WaitForSetComplete(int limit)
+{
+ int rv = 0;
+ int i;
+ uchar bdata[4];
+
+ for (i = 0; i < limit; i++) {
+ rv = GetLanEntry(0, 0, bdata);
+ if (fdebug) printf("WaitForSetComplete(%d): i=%d rv=%d val=%x\n",
+ limit,i,rv,bdata[1]);
+ if ((rv == 0) && (bdata[1] == 0)) break;
+ else os_usleep(0,100);
+ }
+ return(rv);
+}
+
+int SerialIsOptional(int bparam)
+{
+ /* These Serial Parameters are for optional Modem/Callback functions. */
+ int optvals[9] = { 5, 9, 10, 11, 12, 13, 14, 20, 21 };
+ int rv = 0;
+ int i;
+ for (i = 0; i < sizeof(optvals); i++) {
+ if (optvals[i] == bparam) { rv = 1; break; }
+ }
+ return(rv);
+}
+
+static int parse_line(char *line, char *keyret, char *value)
+{
+ char *eol;
+ char *key;
+ char *val;
+ int i, n;
+
+ key = &line[0];
+ eol = &line[strlen(line)];
+ while( *key < 0x21 && key < eol )
+ key++; /*remove leading whitespace */
+ if( key[0] == bcomment ) return 2; /*skip comments */
+ /*
+ * find the value set, delimited by bdelim (':' or '|')
+ */
+ val = strchr( line, bdelim );
+ if( val == NULL ) return 1; /* skip if empty or no delimeter */
+ val[0] = 0; /*stringify the key*/
+ val++;
+ while( val[0] < 0x21 && val < eol )
+ val++; /*remove leading whitespace */
+ /*
+ * truncate trailing newline/whitespace after last word
+ */
+ n = strlen_( val );
+ for( i = n; i >= 0; i-- ) /*decrease from end*/
+ if( val[i] >= 0x21 ) break; /*found last valid char */
+ if (i < n) val[i + 1] = 0;
+
+ strcpy(keyret, key); /*has keyword and params*/
+ strcpy(value, val); /*has list of hex values*/
+ return 0;
+}
+
+#ifdef METACOMMAND
+int i_config(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret;
+ PEF_RECORD *pPefRecord;
+ PEF_RECORD PefRecord;
+ uchar LanRecord[64];
+ uchar bParams[5];
+ char filename[80] = "";
+ int i, j, c, n;
+ uchar idx;
+ // char *pstr;
+ uchar bset = 0;
+ int ndest = 4;
+ int idest;
+ // char mystr[80];
+ uchar * pc; int sz;
+ char line[240]; /* hdr(18) + data(192 = 64 * 3) + '\0' = 211 */
+ char key[40];
+ char value[100];
+ uchar rData[50];
+ int rlen;
+ uchar cc;
+ uchar chan;
+ char *pk;
+ char fpefok = 1;
+ char fignore_err;
+
+ // progname = argv[0];
+ printf("%s ver %s \n",progname,progver);
+ func = 'l'; freadonly = 1; /*list is default*/
+
+ while ((c = getopt(argc, argv,"cdmlr:s:xL:T:V:J:EYF:P:N:R:U:Z:?")) != EOF)
+ switch(c) {
+ case 'c': fcanonical = 1; bdelim = BDELIM; break;
+ case 'd': func = 'd'; freadonly = 0; break; /*set Defaults*/
+ case 'l': func = 'l'; freadonly = 1; break; /*list*/
+ case 'm': fdomac = 1; break; /*restore mac*/
+ case 'r': func = 'r'; freadonly = 0; /*restore*/
+ sz = strlen_(optarg);
+ if (sz > sizeof(filename)) sz = sizeof(filename);
+ strncpy(filename,optarg,sz);
+ break;
+ case 's': func = 's'; freadonly = 1; /*save*/
+ sz = strlen_(optarg);
+ if (sz > sizeof(filename)) sz = sizeof(filename);
+ strncpy(filename,optarg,sz);
+ break;
+ case 'x': fdebug = 1; break;
+ case 'p': /* password to set */
+ fpassword = 1;
+ if (strlen_(optarg) > 16) optarg[16] = 0;
+ strcpy(passwordData,optarg);
+ if (fdebug) printf("Password = %s\n",passwordData);
+ /* Hide password from 'ps' */
+ memset(optarg, ' ', strlen_(optarg));
+ break;
+ case 'L':
+ lan_ch_parm = atob(optarg);
+ if (lan_ch_parm >= MAXCHAN) lan_ch_parm = 0xff; /*invalid*/
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-clmpxLNUPREFTJVY -r <file> -s <file>]\n",
+ progname);
+ printf("where -l Lists BMC configuration parameters\n");
+ printf(" -r Restores BMC configuration from <file>\n");
+ printf(" -s Saves BMC configuration to <file>\n");
+ printf(" -c canonical output with delimiter '%c'\n",BDELIM);
+ printf(" -m Set BMC MAC during restore\n");
+ printf(" -x show eXtra debug messages\n");
+ printf(" -p <psw> specify a user password to set\n");
+ printf(" -L 3 specify lan channel number 3\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ switch(func) {
+ case 'l': fd_bmc = stdout; break;
+ case 'r': fd_bmc = fopen(filename,"r"); break;
+ case 's': fd_bmc = fopen(filename,"w"); break;
+ default: break;
+ }
+ if (fd_bmc == NULL) {
+ printf("Error: cannot open %s\n",filename);
+ ret = ERR_FILE_OPEN;
+ fd_bmc = stdout;
+ goto do_exit;
+ }
+ fipmilan = is_remote();
+
+ if (fipmilan) parse_lan_options('V',"4",0);
+
+ ret = GetDeviceID( LanRecord);
+ if (ret != 0) {
+ goto do_exit;
+ } else { /* success */
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = LanRecord[4] & 0x0f;
+ ipmi_min = LanRecord[4] >> 4;
+ show_devid( LanRecord[2], LanRecord[3], ipmi_maj, ipmi_min);
+ if (ipmi_maj == 0) fIPMI10 = 1;
+ else if (ipmi_maj == 1 && ipmi_min < 5) fIPMI10 = 1;
+ else fIPMI10 = 0; /* >= IPMI 1.5 is ok */
+ if (ipmi_maj >= 2) fIPMI20 = 1;
+ /* nusers can be up to 15 max */
+ if (fIPMI20) nusers = 5;
+ else nusers = 3;
+ if (fIPMI10) {
+ printf("%c This IPMI v%d.%d system does not support PEF records.\n",
+ bcomment,ipmi_maj,ipmi_min);
+ /* Wont handle PEF, but continue and look for BMC LAN anyway */
+ // fIPMI10 = 1;
+ // ipmi_close_();
+ // exit(1);
+ }
+ prod_id = LanRecord[9] + (LanRecord[10] << 8);
+ vend_id = LanRecord[6] + (LanRecord[7] << 8)
+ + (LanRecord[8] << 16);
+ /* check Device ID response for Manufacturer ID = 0x0322 (NSC) */
+ if (vend_id == VENDOR_NSC) { /* NSC = 0x000322 */
+ fmBMC = 1; /*NSC miniBMC*/
+ if (pefnum == 12) pefnum = 10; /* change CritStop pefnum to 0x0a */
+ pefdesc = &pefdesc2[0];
+ pefmax = 30;
+ fsharedMAC = 1; /*LAN1 shares MAC with OS*/
+ } else if (vend_id == VENDOR_LMC) { /* LMC (on SuperMicro) = 0x000878 */
+ fmBMC = 0;
+ pefdesc = NULL; /* unknown, see PefDesc() */
+ if (pefnum == 12) pefnum = 15; /* change CritStop pefnum */
+ pefmax = 16;
+ fsharedMAC = 0; /* not-shared BMC LAN port */
+ } else if (vend_id == VENDOR_INTEL) { /* Intel = 0x000157 */
+ pefdesc = &pefdesc1[0]; /*Intel defaults*/
+ pefmax = 20; /*Intel default pefmax = 20*/
+ switch(prod_id) {
+ case 0x4311: /* Intel NSI2U*/
+ fmBMC = 1; /* Intel miniBMC*/
+ if (pefnum == 12) pefnum = 14; /* change CritStop pefnum */
+ pefdesc = &pefdesc2[0];
+ pefmax = 30;
+ fsharedMAC = 1; /*LAN1 shares MAC with OS*/
+ break;
+ case 0x0026:
+ case 0x0028:
+ case 0x0811: /* Alcolu & TIGW1U */
+ fmBMC = 0; /* Intel Sahalee BMC*/
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ gcm_ch = 3;
+ break;
+ case 0x003E: /*NSN2U or CG2100 Urbanna*/
+ fiBMC = 1; /* Intel iBMC */
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ set_max_kcs_loops(URNLOOPS); /*longer for SetLan cmds (default 300)*/
+ break;
+ case 0x0107: /* Intel Caneland*/
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ gcm_ch = 3;
+ break;
+ case 0x0022: /* Intel TIGI2U*/
+ fsharedMAC = 1; /*LAN1 shares MAC with OS*/
+ gcm_ch = 3;
+ nusers = 4;
+ break;
+ default: /* else other Intel */
+ if (fIPMI20) fsharedMAC = 0; /* recent, not-shared BMC MAC */
+ else fsharedMAC = 1; /* usu IPMI 1.x has shared BMC MAC */
+#ifdef TEST
+ /* also check for ia64, and set chan_pefon, chan_pefoff accordingly*/
+ if (prod_id == 0x0100) { /* Intel Tiger2, Itanium2 */
+ chan_pefon = CHAN_ACC_PEFON64;
+ chan_pefoff = CHAN_ACC_PEFOFF64;
+ }
+#endif
+ break;
+ } /*end switch*/
+ if (is_romley(vend_id,prod_id)) {
+ fRomley = 1;
+ fiBMC = 1; /* Intel iBMC */
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ set_max_kcs_loops(URNLOOPS); /*longer for SetLan cmds */
+ fipv6 = 1;
+ }
+ } else if (vend_id == VENDOR_KONTRON) {
+ //if (prod_id == 0x1590) fchan2wart = 1; /* KTC5520 chan2 wart */
+ fsharedMAC = 0; /* not-shared BMC MAC */
+ pefdesc = NULL; /* unknown, see PefDesc() */
+ if (pefnum == 12) pefnum = 15; /* change CritStop pefnum to 15 */
+ } else { /* else other vendors */
+ if (fIPMI20) fsharedMAC = 0; /* recent, not-shared BMC MAC */
+ else fsharedMAC = 1; /* usu IPMI 1.x has shared BMC MAC */
+ fmBMC = 0;
+ pefdesc = NULL; /* unknown, see PefDesc() */
+ if (pefnum == 12) pefnum = 15; /* change CritStop pefnum to 15? */
+ pefmax = 20;
+ }
+ if (fmBMC) nusers = 1;
+ }
+
+ ret = GetPefCapabilities(&bset);
+ if ((ret == 0) && (bset <= MAXPEF)) pefmax = bset;
+
+ /* Get the BMC LAN channel & match it to an OS eth if. */
+ i = GetBmcEthDevice(lan_ch_parm);
+ if (i == -2) { /* no lan channels */
+ printf("This system does not support BMC LAN channels.\n");
+ ret = ERR_NOT_ALLOWED;
+ goto do_exit;
+ } else if (i < 0) { /* mac not found, use platform defaults */
+ i = 0; /* default to eth0, lan_ch set already. */
+ if (vend_id == VENDOR_INTEL) {
+ if ((prod_id == 0x001B) || (prod_id == 0x000c)) {
+ /* Intel TIGPR2U or TSRLT2 defaults are special */
+ if (lan_ch_parm == 6)
+ { i = 0; lan_ch = 6; }
+ else { i = 1; lan_ch = 7; }
+ ser_ch = 1;
+ }
+ }
+ }
+ if ((gcm_ch != 0) && (lan_ch_parm == 0xff)) {
+ /* Has a GCM, and user didn't specify -L */
+ /* Need this to avoid picking channel 3, the IMM GCM channel. */
+ lan_ch = 1; /*default BMC LAN channel*/
+ // i = 1; /*default eth1*/
+ }
+ if (fsetifn == 0) {
+ if (lan_ch == gcm_ch) strcpy(ifname,"gcm");
+ else sprintf(ifname,"%s%d",ifpattn,i);
+ }
+ if (fdebug) printf("lan_ch = %d, ifname = %s\n",lan_ch,ifname);
+
+ /* initialize the correct SOL command values */
+ if (fIPMI20 && fSOL20) {
+ setsolcmd = SET_SOL_CONFIG2;
+ getsolcmd = GET_SOL_CONFIG2;
+ sol_bchan = lan_ch;
+ } else {
+ setsolcmd = SET_SOL_CONFIG;
+ getsolcmd = GET_SOL_CONFIG;
+ sol_bchan = 0x00; /*override chan for IPMI 1.5*/
+ }
+
+ memset(SessInfo,0,sizeof(SessInfo));
+ ret = GetSessionInfo(SessInfo,sizeof(SessInfo));
+ // rlen = sizeof(SessInfo)); ret = get_session_info(0,0,SessInfo,&rlen);
+ if (fdebug) printf("GetSessionInfo ret=%d, data: %02x %02x %02x %02x \n",
+ ret,SessInfo[0],SessInfo[1],SessInfo[2],SessInfo[3]);
+ if (!freadonly && fipmilan) { /* setting LAN params, and using IPMI LAN */
+ if (SessInfo[2] > 1) { /* another session is active also */
+ printf("Another session is also active, cannot change IPMI LAN settings now.\n");
+ ret = ERR_NOT_ALLOWED;
+ goto do_exit;
+ }
+ }
+
+ /* set the lan_user appropriately */
+ if (freadonly)
+ {
+ if (!fIPMI10) {
+ printf("%c## %s, GetPefEntry ...\n",bcomment,progname);
+ for (idx = 1; idx <= pefmax; idx++)
+ {
+ ret = GetPefEntry( 0x06, (ushort)idx, &PefRecord);
+ if (ret == 0) { // Show the PEF record
+ pc = (uchar *)&PefRecord;
+ sz = 21; // sizeof(PEF_RECORD) = 21
+ printf("%c PefParam(%d): %s\n",bcomment,idx,PefDesc(idx,pc[7]));
+ fprintf(fd_bmc,"PEFParam %d,%02d%c",6,idx,bdelim);
+ for (i = 0; i < sz; i++) fprintf(fd_bmc," %02x",pc[i]);
+ fprintf(fd_bmc,"\n");
+ } else {
+ char *pstr;
+ if (ret > 0) pstr = decode_cc(0,(uchar)ret);
+ else pstr = "";
+ printf("%c GetPefEntry(%d): ret = %d %s\n",bcomment,idx,ret,pstr);
+ if (ret == 0xC1) {
+ fpefok = 0;
+ ndest = 0;
+ break;
+ }
+ }
+ }
+ if (fpefok) {
+ ret = GetPefEntry(0x01, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ fprintf(fd_bmc,"PEFParam %d%c %02x\n",1,bdelim,LanRecord[0]);
+ }
+ ret = GetPefEntry(0x02, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ fprintf(fd_bmc,"PEFParam %d%c %02x\n",2,bdelim,LanRecord[0]);
+ }
+ ret = GetPefEntry(0x03, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0)
+ fprintf(fd_bmc,"PEFParam %d%c %02x\n", 3,bdelim,LanRecord[0]);
+ if (!fmBMC) {
+ ret = GetPefEntry(0x04, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0)
+ fprintf(fd_bmc,"PEFParam %d%c %02x\n",4,bdelim,LanRecord[0]);
+ /* fmBMC gets cc=0x80 here */
+ }
+ /* note that ndest should be read from lan param 17 below. */
+ for (i = 1; i <= ndest; i++)
+ {
+ ret = GetPefEntry(0x09, (ushort)i,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ fprintf(fd_bmc,"PEFParam %d,%d%c %02x %02x %02x %02x \n",9,i,bdelim,
+ LanRecord[0], LanRecord[1],LanRecord[2], LanRecord[3]);
+ }
+ } /*endfor ndest*/
+ } /*endif fpefok*/
+ } /*endif not fIPMI10*/
+
+ for (chan = lan_ch; chan < MAXCHAN; chan++ )
+ {
+ if (chan_type[chan] != 4) continue; /*chan != LAN, skip it*/
+ lan_ch = chan;
+ printf("%c## %s, GetLanEntry for channel %d ...\n",bcomment,progname,lan_ch);
+ idest = 1;
+ for (idx = 0; idx < NLAN; idx++)
+ {
+ int ival;
+ if (idx == 8 || idx == 9) continue; /* not implemented */
+ ival = lanparams[idx].cmd;
+ if (ival >= 96 && ival <= 98) continue; /* not implemented */
+ if (ival >= 102 && ival <= 108) { /*custom IPv6 parameters*/
+ if (fipv6 == 0) continue; /*skip these*/
+ }
+ if (ival == 194 && vend_id == VENDOR_KONTRON) { /*oem hostname parm*/
+ lanparams[idx].sz = 36;
+ strcpy(lanparams[idx].desc,"IPMI Hostname");
+ } else if (ival >= 192 && ival <= 194) { /*custom DHCP parameters*/
+ if (vend_id != VENDOR_INTEL) continue;
+ if (fmBMC || fiBMC || fRomley || fcanonical) continue; /*skip*/
+ }
+ /* VLAN params 20-25, fIPMI20 only*/
+ if (ival >= 20 && ival <= 25) { if (!fIPMI20) continue; }
+ if (ival == 11) { /*grat arp interval*/
+ if (vend_id == VENDOR_SUPERMICROX) continue;
+ if (vend_id == VENDOR_SUPERMICRO) continue;
+ }
+ if (ival == 14 || ival == 15) { /*secondary gateway is optional*/
+ if (vend_id == VENDOR_KONTRON) continue;
+ }
+ if (ival == 201) { /*Get Channel Access*/
+ ret = ShowChanAcc(lan_ch);
+ } else {
+ if (ival == 18 || ival == 19) { /*dest params*/
+ if (ndest == 0) continue; /*skip if none*/
+ bset = (uchar)idest; /* dest id = 1 thru n */
+ } else bset = 0;
+ ret = GetLanEntry((uchar)ival, bset, LanRecord);
+ }
+ if (ret == 0) { // Show the LAN record
+ pc = (uchar *)&LanRecord;
+ sz = lanparams[idx].sz;
+ if (ival == 201) ; /* ShowChanAcc(lan_ch) above */
+ else {
+ fprintf(fd_bmc,"LanParam %d,%d,%d%c ",lan_ch,ival,bset,bdelim);
+ for (i = 0; i < sz; i++) fprintf(fd_bmc," %02x",pc[i]);
+ fprintf(fd_bmc,"\n");
+ if (ival == 3)
+ printf("%c LanParam(%d,%d,%d) IP address: %d.%d.%d.%d\n",
+ bcomment, lan_ch,ival,bset,
+ pc[0], pc[1], pc[2], pc[3]);
+ }
+
+ if (ival == 1) {
+ authmask = pc[0]; /* auth type support mask */
+ /* if (fmBMC) authmask is usually 0x15, else 0x14 */
+ } else if (ival == 3) {
+ if (IpIsValid(pc)) memcpy(bmcmyip,pc,4);
+ } else if (ival == 5) {
+ if (MacIsValid(pc)) memcpy(bmcmymac,pc,MAC_LEN);
+ } else if (ival == 17) { /* num dest */
+ ndest = pc[0]; /* save the number of destinations */
+ } else if (ival == 19) { /* dest addr */
+ if (IpIsValid(&pc[3])) memcpy(bmcdestip,&pc[3],4);
+ }
+
+ if (ival == 18 || ival == 19) {
+ if (idest < ndest) {
+ idest++;
+ idx--; /* repeat this param*/
+ } else idest = 1;
+ }
+ } else { /* ret != 0 */
+ if (ival >= 20 && ival <= 25) ;
+ else
+ printf("%c GetLanEntry(%d,%d,%d), ret = %d\n",bcomment,lan_ch,ival,bset,ret);
+ if (ival == 17) ndest = 0; /*error getting num dest*/
+ }
+ } /*end for NLAN*/
+ if (!fIPMI10) { /* Get SOL params */
+ ret = GetSerialOverLan(lan_ch,0,0);
+ if (ret != 0) printf("%c GetSOL error %d\n",bcomment,ret);
+ }
+ for (idx = 1; idx <= nusers; idx++)
+ GetUser(idx);
+ if (lan_ch_parm != 0xff) chan = MAXCHAN;
+ } /*end-for chan*/
+
+ printf("%c## %s, GetSerEntry for channel %d ...\n",bcomment,progname,ser_ch);
+ if (fmBMC || (ser_ch == 0)) { /* mBMC doesn't support serial */
+ printf("%cNo serial channel support on this platform\n",
+ bcomment);
+ } else {
+ idest = 1;
+ for (idx = 0; idx < NSER; idx++) {
+ int ival;
+ // if (idx == 9) continue; /* not implemented */
+ ival = serparams[idx].cmd;
+ if (vend_id == VENDOR_SUPERMICRO && ival == 8) continue;
+ if (ival == 201) {
+ j = ShowChanAcc(ser_ch);
+ } else {
+ if (ival == 17 || ival == 19 || ival == 21 || ival == 23)
+ bset = (uchar)idest;
+ else bset = 0; /*default*/
+ ret = GetSerEntry((uchar)ival, bset, LanRecord);
+ if (ret == 0) { // Show the SER record
+ pc = (uchar *)&LanRecord;
+ sz = serparams[idx].sz;
+ fprintf(fd_bmc,"SerialParam %d,%d,%d%c",
+ ser_ch,ival,bset,bdelim);
+ for (i = 0; i < sz; i++)
+ fprintf(fd_bmc," %02x",pc[i]); /* show in hex */
+ fprintf(fd_bmc,"\n");
+ if (ival == 16) ndest = pc[0];
+ } else { /*ret != 0, error*/
+ char *pstr;
+ char *tag;
+ if (SerialIsOptional(ival)) tag = "Optional";
+ else tag = "";
+ if (ret > 0) pstr = decode_cc(0,ret);
+ else pstr = "";
+ printf("%c GetSerEntry(%d,%d): %s ret = %d %s\n",
+ bcomment,ser_ch,ival,tag,ret,pstr);
+ if (ival == 16) ndest = 0;
+ if (ret == 0xC1) {
+ ret = 0;
+ break; /*not supported, exit for loop*/
+ }
+ }
+ }
+ if (ival == 17 || ival == 19 || ival == 21 || ival == 23) {
+ if (idest < ndest) {
+ idest++;
+ idx--; /* repeat this param*/
+ } else idest = 1;
+ }
+ } /*end for NSER*/
+ lan_ch_sav = lan_ch;
+ lan_ch = ser_ch; /* use ser_ch for User functions now */
+ for (idx = 1; idx <= nusers; idx++)
+ GetUser(idx);
+ lan_ch = lan_ch_sav;
+ } /*endif serial*/
+
+ printf("%c## %s, GetSystemParams ...\n",bcomment,progname);
+ for (idx = 0; idx < NSYS; idx++) { /*Get System Params*/
+ switch(idx) {
+ case 0: j = CHAS_RESTORE; bset = 0; break;
+ case 1: j = SYS_INFO; bset = 1; break;
+ case 2: j = SYS_INFO; bset = 2; break;
+ case 3: j = SYS_INFO; bset = 3; break;
+ case 4: j = SYS_INFO; bset = 4; break;
+ case 5:
+ default: j = LAN_FAILOVER; bset = 0; break;
+ }
+ fignore_err = 0;
+ pc = (uchar *)&LanRecord;
+ switch(j) {
+ case CHAS_RESTORE: /* Chassis Status, Power Restore Policy */
+ sz = 0;
+ rlen = sizeof(rData);
+ ret = ipmi_cmdraw(CHASSIS_STATUS, NETFN_CHAS,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ pc,0,rData,&rlen,&cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ if (ret == 0) {
+ sz = rlen;
+ memcpy(pc,&rData,sz); /*should be 3 bytes*/
+ }
+ break;
+ case SYS_INFO: /* System Info */
+ if (! fIPMI20) continue; /*skip if not IPMI 2.0*/
+ rlen = sizeof(LanRecord); /* param from read */
+ ret = get_system_info(bset,LanRecord,&rlen);
+ /* find actual string size (ends at first 0x00) */
+ for (i=0; i<rlen; i++) if (LanRecord[i] == 0) break;
+ if (i < rlen) rlen = i;
+ sz = rlen;
+ fignore_err = 1;
+ break;
+ case LAN_FAILOVER: /* Intel LAN Failover */
+ if (is_romley(vend_id,prod_id))
+ ret = lan_failover_intel(0xFF,&LanRecord[0]);
+ else continue; /*skip if not Intel Romley */
+ sz = 1;
+ fignore_err = 1;
+ break;
+ default: /*do nothing*/
+ sz = 0;
+ ret = LAN_ERR_NOTSUPPORT;
+ break;
+ } /*end switch*/
+ if (ret == 0) {
+ fprintf(fd_bmc,"SystemParam %d,%d%c ",j,bset,bdelim);
+ for (i = 0; i < sz; i++) fprintf(fd_bmc," %02x",pc[i]);
+ fprintf(fd_bmc,"\n");
+ } else {
+ char *pstr;
+ if (ret > 0) pstr = decode_cc(0,ret);
+ else pstr = "";
+ if (fdebug || !fignore_err)
+ printf("%c GetSystemParam(%d,%d): ret = %d %s\n",
+ bcomment,j,bset,ret,pstr);
+ if (fignore_err) ret = 0;
+ }
+ } /*end-for System Params*/
+
+ } /*endif readonly*/
+
+ if (!freadonly) /* Set parameters via Restore */
+ {
+ if (fipmilan) { /* Sets not valid via ipmi_lan if same channel. */
+ printf("\nWarning: Setting LAN %d params while using a LAN channel.\n", lan_ch);
+ }
+ GetUser(1); /*sets num enabled_users */
+
+ /* Set BMC parameters. (restore) */
+ /* read each record from the file */
+ while ( fgets( line, sizeof(line), fd_bmc) != NULL )
+ {
+ ret = parse_line(line, key, value);
+ if (ret != 0) {
+ if (ret == 2) ret = 0; /*just skip comment*/
+ else if (fdebug) printf("parse error on line: %s\n",line);
+ continue;
+ }
+
+ /* get parameters from key */
+ sz = sizeof(bParams);
+ memset(bParams,0,sz);
+ pk = strchr(key,' '); /*skip keyword, to first param*/
+ if (pk == NULL) {
+ pk = &key[0];
+ }
+ for (n=0; n<sz; n++)
+ {
+ pc = strchr(pk,',');
+ if (pc != NULL) {
+ *pc = 0;
+ bParams[n] = atob(pk);
+ pk = (char *)++pc;
+ } else {
+ bParams[n] = atob(pk);
+ break;
+ }
+ }
+ /* n == number of params, usually 3 */
+ chan = bParams[0];
+ idx = bParams[1];
+ bset = bParams[2];
+ /* get data from value */
+ pc = value;
+ sz = strlen_(value);
+ for (j=0,i=0; i<sz; i+=3)
+ LanRecord[j++] = htoi(&pc[i]);
+ if (fdebug) {
+ printf("Record(%d,%d,%d):",chan,idx,bset);
+ for (i=0; i<j; i++) printf(" %02x",LanRecord[i]);
+ printf("\n");
+ }
+
+ if (strncasecmp(key,"LanParam",8) == 0) {
+ if (idx == 0) continue; /*skip Set in progress*/
+ if (idx == 1 || idx == 17) continue; /*read-only params*/
+ if (idx == 5 && fIPMI20) /*BMC MAC address & IPMI 2.0(not shared)*/
+ if (fdomac == 0) continue; /*skip BMC MAC unless -m */
+ if ((idx == 10) && (chan == gcm_ch)) continue; /*skip Lan3 arp*/
+ if ((vend_id == VENDOR_PEPPERCON) && (idx == 7)) continue;
+ if ((idx == 18 || idx == 19) && (ndest == 0)) continue;
+ if (idx >= 22 && idx <= 24) continue; /*read-only Cipher*/
+ else if (idx >= 20 && idx <= 25) { /*VLAN*/
+ if (!fIPMI20) continue;
+ }
+ if (idx == 18) j--; /*one less byte for Set than from Get*/
+ lan_ch = chan;
+ if (idx == 3) { /* 3 = IP address */
+ uchar bdata[2];
+ bdata[0] = 0x00; /*disable grat arp while setting IP*/
+ ret = SetLanEntry(10, &bdata[0], 1);
+ if (fdebug) printf("SetLanEntry(%d,10,0), ret = %d\n",chan,ret);
+ WaitForSetComplete(4); /*wait if it is a slow MC */
+ bdata[0] = SRC_STATIC; /*set src to static before setting IP*/
+ ret = SetLanEntry(4, &bdata[0], 1);
+ if (fdebug) printf("SetLanEntry(%d,4,0), ret = %d\n",chan,ret);
+ WaitForSetComplete(4); /*wait if it is a slow MC */
+ }
+ else if ((idx == 6) || (idx == 12)) WaitForSetComplete(4);
+ ret = SetLanEntry(idx, LanRecord, j);
+ if ((ret != 0) && (idx >= 20 && idx <= 25)) ; /*VLAN optional*/
+ else {
+ printf("SetLanEntry(%d,%d), ret = %d\n",chan,idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+
+ } else if (strncasecmp(key,"PEFParam",8) == 0) {
+ if (fpefok == 0) continue;
+ idx = bParams[0];
+ bset = bParams[1];
+ if (idx == 6) { /*PEF table rules*/
+ pPefRecord = (PEF_RECORD *)&LanRecord[0];
+ if (pPefRecord->fconfig == 0xC0) {
+ pPefRecord->fconfig = 0x80; /* enabled, software */
+ ret = SetPefEntry(pPefRecord);
+ if (fdebug)
+ printf("SetPefEntry(%d,%d/80) ret = %d\n",idx,bset,ret);
+ pPefRecord->fconfig = 0xC0;
+ }
+ ret = SetPefEntry(pPefRecord);
+ printf("SetPefEntry(%d,%d) ret = %d\n",idx,bset,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } else {
+ pc = (uchar *)&PefRecord;
+ pc[0] = idx;
+ for (i=0; i<j; i++)
+ pc[i+1] = LanRecord[i];
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_PEF_CONFIG, pc,j+1, rData,&rlen, &cc,fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc;
+ if ((idx == 9) && (bset > 1) && (ret != 0)); /*9=PEF Policy*/
+ else {
+ printf("SetPefEntry(%d,%d) ret = %d\n",idx,bset,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+ if (ret == 0xC1) { fpefok = 0; ndest = 0; }
+
+ } else if (strncasecmp(key,"SerialParam",11) == 0) {
+ if (idx == 0) continue; /*skip Set in progress*/
+ if (idx == 1 || idx == 16) continue; /*read-only param*/
+ if (vend_id == VENDOR_PEPPERCON) {
+ if ((idx >= 3) && (idx <= 6)) continue;
+ }
+ if ((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) {
+ if (idx == 3) continue;
+ if ((idx >= 6) && (idx <= 8)) continue;
+ if (idx == 29) continue;
+ }
+ if (fmBMC || (ser_ch == 0)) continue; /*doesn't support serial*/
+ ser_ch = chan;
+ ret = SetSerEntry(idx, LanRecord, j);
+ if ((ret != 0) && SerialIsOptional(idx)) ; /*ignore errors if opt*/
+ else {
+ printf("SetSerEntry(%d,%d,%d), ret = %d\n",chan,idx,bset,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else if (strncasecmp(key,"ChannelAccess",13) == 0) {
+ if (((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) && chan == 3) ; /*skip serial*/
+ else {
+ ret = SetChanAcc(chan, 0x80, LanRecord[0], LanRecord[1]);
+ if (fdebug) printf("SetChanAcc(%d/active), ret = %d\n",chan,ret);
+ ret = SetChanAcc(chan, 0x40, LanRecord[0], LanRecord[1]);
+ printf("SetChanAcc(%d), ret = %d\n",chan,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+
+ } else if (strncasecmp(key,"UserName",8) == 0) {
+ if (fchan2wart && (lan_ch == 2)) continue;
+ idx = bParams[0];
+ if (idx <= 1) ; /*skip if anonymous user 1*/
+ else if (idx == 2 && vend_id == VENDOR_SUPERMICROX) ; /*skip user2*/
+ else if (idx == 2 && vend_id == VENDOR_SUPERMICRO) ; /*skip user2*/
+ else {
+ pc = (uchar *)&PefRecord;
+ pc[0] = idx; /*user num*/
+ memcpy(&pc[1],&LanRecord[0],16);
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_NAME,pc,17, rData,&rlen, &cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ if (ret == 0xCC) ; /*SetUserName matching previous gives this*/
+ else {
+ printf("SetUserName(%d) ret = %d\n",idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+ if (fpassword) {
+ pc = (uchar *)&PefRecord;
+ pc[0] = idx; /*user num*/
+ pc[1] = 0x02; /*set password*/
+ memset(&pc[2],0, PSW_LEN);
+ strcpy(&pc[2],passwordData);
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_PASSWORD,pc,2+PSW_LEN,rData,&rlen,
+ &cc,fdebug);
+ printf("SetUserPassword(%d) ret = %d\n",idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else if (strncasecmp(key,"UserPassword",12) == 0) {
+ if (fchan2wart && (lan_ch == 2)) continue;
+ idx = bParams[0];
+ pc = (uchar *)&PefRecord;
+ pc[0] = idx; /*user num*/
+ pc[1] = 0x02; /*set password*/
+ memset(&pc[2],0,PSW_LEN);
+ strcpy(&pc[2],passwordData);
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_PASSWORD,pc,2+PSW_LEN,rData,&rlen,
+ &cc,fdebug);
+ printf("SetUserPassword(%d) ret = %d\n",idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } else if (strncasecmp(key,"UserAccess",10) == 0) {
+ if ((idx > enabled_users) && ((LanRecord[3] & 0x10) == 0)) continue;
+ if (vend_id == VENDOR_KONTRON) {
+ if (idx == 1) continue;
+ if (idx > enabled_users) continue;
+ }
+ if (ipmi_reserved_user(vend_id,idx) == 1) continue;
+ if (fchan2wart && (lan_ch == 2)) continue;
+ pc = (uchar *)&PefRecord;;
+ pc[0] = 0x80 | (LanRecord[3] & 0x70) | chan; /*User Channel Access*/
+ pc[1] = idx; /*user id*/
+ pc[2] = (LanRecord[3] & 0x0F); /*User Privilege (Admin,User,Oper)*/
+ pc[3] = 0x00; /* User Session Limit, 0=not limited*/
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_ACCESS,pc,4, rData,&rlen, &cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ if (ret != 0xCC) { /*if invalid user, ignore errors*/
+ printf("SetUserAccess (%x %x %x %x) ret = %d\n",
+ pc[0],pc[1],pc[2],pc[3],ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ if ((LanRecord[3] & 0x0f) != 0x0F) { /*not NoAccess, enable user*/
+ if (idx > last_user_enable) last_user_enable = idx;
+ pc[0] = idx; /*user number, 1=null_user */
+ pc[1] = 0x01; /*enable user*/
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_PASSWORD,pc,2, rData,&rlen, &cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ printf("SetUserEnable (%x %x) ret = %d\n",pc[0],pc[1],ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else if (strncasecmp(key,"SOLParam",8) == 0) {
+ if (fchan2wart && (chan == 2)) continue;
+ pc = (uchar *)&PefRecord;;
+ pc[0] = chan;
+ pc[1] = idx; /*sol parameter number*/
+ memcpy(&pc[2],&LanRecord,j);
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(setsolcmd, pc, j+2, rData,&rlen, &cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ printf("SetSOLParam (%d,%d) ret = %d\n",chan,idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+
+ } else if (strncasecmp(key,"SOLPayloadSupport",17) == 0) {
+ ; /* Nothing to do, this is a read-only parameter */
+
+ } else if (strncasecmp(key,"SOLPayloadAccess",16) == 0) {
+ if (fIPMI20) {
+ if (ipmi_reserved_user(vend_id,idx) == 1) continue;
+ pc = (uchar *)&PefRecord;;
+ pc[0] = chan;
+ pc[1] = idx; // lan_user
+ memcpy(&pc[2],&LanRecord,j);
+ rlen = sizeof(rData);
+ ret = ipmi_cmdraw(SET_PAYLOAD_ACCESS,NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ pc,j+2,rData,&rlen,&cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ printf("SetSOLPayloadAccess (%d,%d) ret = %d\n",
+ chan,idx,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else if (strncasecmp(key,"SystemParam",11) == 0) {
+ idx = bParams[0];
+ bset = bParams[1];
+ switch(idx) {
+ case CHAS_RESTORE: /* Chassis Power Restore Policy*/
+ if (vend_id == VENDOR_KONTRON) continue; /*N/A, cannot set it*/
+ pc = (uchar *)&PefRecord;;
+ i = (LanRecord[0] & 0x60); /*restore policy bits*/
+ if (i & 0x20) pc[0] = 0x01; /*last_state*/
+ else if (i & 0x40) pc[0] = 0x02; /*turn_on*/
+ else pc[0] = 0x00; /*stay_off*/
+ rlen = sizeof(rData);
+ ret = ipmi_cmdraw(0x06 , NETFN_CHAS,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ pc,1,rData,&rlen,&cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ break;
+ case SYS_INFO: /* System Info */
+ if (! fIPMI20) continue; /*skip if not IPMI 2.0*/
+ /* j = #bytes read into LanRecord */
+ ret = set_system_info(bset,LanRecord,j);
+ break;
+ case LAN_FAILOVER: /* Intel LAN Failover */
+ if (is_romley(vend_id,prod_id))
+ ret = lan_failover_intel(LanRecord[0],(uchar *)&i);
+ else continue; /*skip if not Intel Romley*/
+ break;
+ default:
+ ret = LAN_ERR_NOTSUPPORT;
+ }
+ printf("SetSystemParam(%d,%d) ret = %d\n",idx,bset,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } /*end-else*/
+
+ } /*end-while*/
+
+ /* Disable any users not enabled above */
+ for (i = last_user_enable+1; i < max_users; i++) {
+ pc[0] = (uchar)i; /*user number, 1=null_user */
+ pc[1] = 0x00; /*disable user*/
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(SET_USER_PASSWORD,pc,2, rData,&rlen, &cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ printf("SetUserEnable (%x %x) ret = %d\n",pc[0],pc[1],ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } /*endif not readonly*/
+
+do_exit:
+ if (fd_bmc != stdout) fclose(fd_bmc);
+ ipmi_close_();
+ if (nerrs > 0) {
+ printf("Warning: %d ok, %d errors occurred, last error = %d\n",ngood,nerrs,lasterr);
+ ret = lasterr;
+ }
+ // show_outcome(progname,ret);
+ return(ret);
+} /* end main()*/
+
+/* end iconfig.c */
diff --git a/util/idcmi.c b/util/idcmi.c
new file mode 100644
index 0000000..1e53ae8
--- /dev/null
+++ b/util/idcmi.c
@@ -0,0 +1,976 @@
+/*
+ * idcmi.c
+ * Data Center Manageability Interface (DCMI) command support
+ *
+ * Change history:
+ * 11/17/2011 ARCress - created
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2011 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+#ifdef WIN32
+#include <windows.h>
+#include <stdlib.h>
+#include "getopt.h"
+#else
+#include <sys/types.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <sys/time.h>
+#else
+#include <stdlib.h>
+#include <getopt.h>
+#endif
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "isensor.h"
+#include "idcmi.h"
+
+static char * progname = "idcmi";
+static char * progver = "2.93";
+extern char fdebug; /*from ipmicmd.c*/
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static uchar dcmi_ver = 0x00; /* 0x10, 0x11, or 0x15 */
+static uchar fpwm = 0; /* =1 if Power Management supported */
+static uchar do_sensors = 0;
+static uchar set_asset = 0;
+static uchar set_mcid = 0;
+static char *asset_new = NULL;
+static char *mcid_new = NULL;
+static int asset_len = 0;
+static int mcid_len = 0;
+static char mc_id[64];
+static char asset[64];
+
+#ifdef NOT
+/* see idcmi.h */
+#define NETFN_DCMI 0x2C
+#define CMD_DCMI_GET_CAPAB 0x01
+#define CMD_DCMI_GET_POWREAD 0x02
+#define CMD_DCMI_GET_POWLIMIT 0x03
+#define CMD_DCMI_SET_POWLIMIT 0x04
+#define CMD_DCMI_ACT_POWLIMIT 0x05
+#define CMD_DCMI_GET_ASSETTAG 0x06
+#define CMD_DCMI_GET_SENSORINF 0x07
+#define CMD_DCMI_SET_ASSETTAG 0x08
+#define CMD_DCMI_GET_MCIDSTR 0x09
+#define CMD_DCMI_SET_MCIDSTR 0x0A
+/* for DCMI 1.5 only */
+#define CMD_DCMI_SET_THERMLIM 0x0B
+#define CMD_DCMI_GET_THERMLIM 0x0C
+#define CMD_DCMI_GET_TEMPRDNGS 0x10
+#define CMD_DCMI_SET_CONFIG 0x12
+#define CMD_DCMI_GET_CONFIG 0x13
+#endif
+
+static int dcmi_usage(void)
+{
+ printf("Usage: %s [-admsx -NUPREFTVY] <function>\n", progname);
+ printf(" -a Set DCMI Asset Tag to this string\n");
+ printf(" -d Set DCMI MC ID to this string\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -s Get DCMI sensor info\n");
+ printf(" -x Display extra debug messages\n");
+ print_lan_opt_usage();
+ printf("where <function> is one of:\n");
+ printf(" info Get DCMI Capabilities, MC ID, asset tag (default)\n");
+ printf(" power [get] Get Power reading & limit\n");
+ printf(" power set_limit <power> Set Power limit\n");
+ printf(" power set_action <action> Set Power limit exception action\n");
+ printf(" (action = no_action | power_off | log_sel)\n");
+ printf(" power set_correction <ms> Set Power limit correction time (in ms)\n");
+ printf(" power set_sample <sec> Set Power limit sampling period (in sec)\n");
+ printf(" power activate Activate Power limit\n");
+ printf(" power deactivate Deactivate Power limit\n");
+ printf(" thermal Get/Set DCMI Thermal parameters\n");
+ printf(" config Get/Set DCMI Configuration parameters\n");
+ printf(" help Show this help message\n");
+ return(ERR_USAGE);
+}
+
+static int dcmi_get_capab(int param, uchar *pdata, int sdata)
+{
+ uchar idata[4];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int rv, i;
+
+ if (pdata == NULL || sdata == 0) return(ERR_BAD_PARAM);
+ idata[0] = 0xDC;
+ idata[1] = (uchar)param;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_CAPAB, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,2, rdata, &rlen, &cc, fdebug);
+ if ((rv != 0) || (cc != 0)) {
+ if (fdebug)
+ printf("dcmi_get_capab(%d): rv = %d, ccode %02x\n",param,rv,cc);
+ if (rv == 0) rv = cc;
+ return(rv);
+ }
+ /* if here, success */
+ if (fdebug) { /*show raw response*/
+ printf("dcmi_get_capab(%d): rlen = %d\n",param,rlen);
+ for (i = 0; i < rlen; i++) printf("%02x ",rdata[i]);
+ printf("\n");
+ }
+ if (rlen > sdata) {
+ if (fdebug)
+ printf("dcmi_get_capab(%d): data truncated from %d to %d\n",
+ param,rlen,sdata);
+ rlen = sdata;
+ }
+ memcpy(pdata,rdata,rlen);
+ return(rv);
+}
+
+static int dcmi_get_power_read(int param, uchar *pdata, int sdata)
+{
+ uchar idata[5];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int rv, i;
+
+ if (pdata == NULL || sdata == 0) return(ERR_BAD_PARAM);
+ idata[0] = 0xDC;
+ idata[1] = (uchar)param; /*mode 1 or 2*/
+ idata[2] = 0x00;
+ idata[3] = 0x00;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_POWREAD, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,4, rdata, &rlen, &cc, fdebug);
+ if (rv == 0) rv = cc;
+ if (fdebug) { /*show raw response*/
+ printf("dcmi_get_power_read(%d): rv = %d rlen = %d\n",param,rv,rlen);
+ for (i = 0; i < rlen; i++) printf("%02x ",rdata[i]);
+ printf("\n");
+ }
+ if (rv == 0) { /* if here, success */
+ if (rlen > sdata) {
+ if (fdebug)
+ printf("dcmi_get_power_read(%d): data truncated from %d to %d\n",
+ param,rlen,sdata);
+ rlen = sdata;
+ }
+ memcpy(pdata,rdata,rlen);
+ }
+ return(rv);
+}
+
+static int dcmi_get_power_limit( uchar *pdata, int sdata)
+{
+ uchar idata[5];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int rv, i;
+
+ if (pdata == NULL || sdata == 0) return(ERR_BAD_PARAM);
+ idata[0] = 0xDC;
+ idata[1] = 0x00;
+ idata[2] = 0x00;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_POWLIMIT, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,3, rdata, &rlen, &cc, fdebug);
+ if (rv == 0) rv = cc;
+ if (fdebug) { /*show raw response*/
+ printf("dcmi_get_power_limit: rv = %d rlen = %d\n",rv,rlen);
+ for (i = 0; i < rlen; i++) printf("%02x ",rdata[i]);
+ printf("\n");
+ }
+ if (rv == 0) { /* if here, success */
+ if (rlen > sdata) {
+ if (fdebug)
+ printf("dcmi_get_power_limit: data truncated from %d to %d\n",
+ rlen,sdata);
+ rlen = sdata;
+ }
+ memcpy(pdata,rdata,rlen);
+ }
+ return(rv);
+}
+
+static int dcmi_set_power_limit(int param,int value, uchar *pow, int spow)
+{
+ int rv = 0;
+ uchar idata[32];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+
+ if (spow > 15) spow = 15;
+ memcpy(idata,pow,spow);
+ switch(param)
+ {
+ case CORRECTION_TIME:
+ idata[10]=(uchar)((value >> 24) & 0xff);
+ idata[9] =(uchar)((value >> 16) & 0xff);
+ idata[8] =(uchar)((value >> 8) & 0xff);
+ idata[7] =(uchar)((value) & 0xff);
+ break;
+ case EXCEPTION_ACTION:
+ idata[4] = (uchar)(value & 0xff);
+ break;
+ case POWER_LIMIT:
+ idata[5] = (uchar)(value & 0xff);
+ idata[6] = (uchar)((value >> 8) & 0xff);
+ break;
+ case SAMPLE_PERIOD:
+ idata[14] = (uchar)((value >> 8) & 0xff);
+ idata[13] = (uchar)(value & 0xff);
+ break;
+ default:
+ return ERR_BAD_PARAM;
+ break;
+ }
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_SET_POWLIMIT, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,15, rdata, &rlen,&cc, fdebug);
+ if (fdebug)
+ printf("dcmi_set_power_limit(%d,%d): rv = %d cc = %x\n",
+ param,value,rv,cc);
+ if (rv == 0) rv = cc;
+ return (rv);
+}
+
+
+static int dcmi_power_limit_activate ( int yes)
+{
+ int rv;
+ uchar idata[5];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ if (yes < 0) return (ERR_BAD_PARAM);
+ if (yes > 1) return (ERR_BAD_PARAM);
+
+ idata[0] = 0xDC;
+ idata[1] = yes;
+ idata[2] = 0x00;
+ idata[3] = 0x00;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_ACT_POWLIMIT, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,4, rdata, &rlen, &cc, fdebug);
+ if (fdebug)
+ printf("dcmi_power_limit_activate(%d): rv = %d cc = %x\n",yes,rv,cc);
+ if (rv == 0) rv = cc;
+ return(rv);
+}
+
+void dcmi_show_power_read(int parm, uchar *cdata, int sdata)
+{
+ int i;
+ ulong sample_period;
+ time_t t = 0;
+ uchar state;
+
+ if (fdebug) { /*++++*/
+ printf("dcmi_show_power_read(%d,%p,%d) called\n",parm,cdata,sdata);
+ for (i = 0; i < sdata; i++) printf("%02x ",cdata[i]);
+ printf("\n");
+ }
+ if (sdata < 18) {
+ printf("power_read data length %d is too short\n",sdata);
+ return;
+ }
+ if (cdata[0] != 0xDC) {
+ printf("power_read: invalid first data byte (0x%02x)\n",cdata[0]);
+ return;
+ }
+ memcpy(&t,&cdata[9],4);
+ sample_period = cdata[13];
+ sample_period += (cdata[14] << 8);
+ sample_period += (cdata[15] << 16);
+ sample_period += (cdata[16] << 24);
+ state = cdata[17];
+ switch(parm) {
+ case 1: /* Mode 1 - System Power Statistics */
+ printf(" Current Power: %d Watts\n",cdata[1]+(cdata[2]<<8));
+ printf(" Min Power over sample duration: %d Watts\n",cdata[3]+(cdata[4]<<8));
+ printf(" Max Power over sample duration: %d Watts\n",cdata[5]+(cdata[6]<<8));
+ printf(" Avg Power over sample duration: %d Watts\n",cdata[7]+(cdata[8]<<8));
+ printf(" Timestamp: %s\n",ctime(&t));
+ printf(" Sampling period: %d ms\n",sample_period);
+ printf(" Power reading state is: %s\n",(state&0x40)? "active":"not active");
+ break;
+ case 2: /* Mode 2 - Enhanced System Power Statistics */
+ printf("Enhanced Power Mode 2 decoding not yet implemented\n");
+ /* TODO */
+ // break;
+ default:
+ for (i = 0; i < sdata; i++) printf("%02x ",cdata[i]);
+ printf("\n");
+ break;
+ }
+}
+
+void dcmi_show_power_limit(uchar *cdata, int sdata, int rv)
+{
+ ulong correction_time;
+ char *pstr;
+
+ correction_time = cdata[6];
+ correction_time += (cdata[7] << 8);
+ correction_time += (cdata[8] << 16);
+ correction_time += (cdata[9] << 24);
+
+ if (rv == 0) pstr = "(active)";
+ else if (rv == 0x80) pstr = "(inactive)";
+ else pstr = "(error)";
+ printf(" Exception Action: ");
+ if (cdata[3] & 0x01)
+ printf("Hard Power off\n");
+ else if ((cdata[3] & 0x11) == 0x11)
+ printf("SEL logging\n");
+ else
+ printf("OEM defined\n");
+ printf(" Power Limit: %d Watts %s\n",cdata[4]+(cdata[5]<<8), pstr);
+ printf(" Correction Time: %d ms\n", correction_time);
+ printf(" Sampling period: %d sec\n", cdata[12]+(cdata[13]<<8));
+}
+
+static int dcmi_get_sensorinf(uchar styp, uchar snum, uchar offset,
+ uchar *pdata, int sdata)
+{
+ uchar idata[5];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int rv, i;
+
+ if (pdata == NULL || sdata == 0) return(ERR_BAD_PARAM);
+ idata[0] = 0xDC;
+ idata[1] = styp; /*sensor type, 0x01 = Temperature*/
+ idata[2] = snum; /*sensor number */
+ idata[3] = 0x00; /*Entity Instance, 0 = all instances*/
+ idata[4] = offset; /*Entity Instance start/offset */
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_SENSORINF, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,5, rdata, &rlen, &cc, fdebug);
+ if (rv == 0) rv = cc;
+ if (fdebug) { /*show raw response*/
+ printf("dcmi_get_sensorinf(%d): rlen = %d\n",snum,rlen);
+ for (i = 0; i < rlen; i++) printf("%02x ",rdata[i]);
+ printf("\n");
+ }
+ if (rv == 0) { /* if here, success */
+ if (rlen > sdata) {
+ if (fdebug)
+ printf("dcmi_get_sensorinf(%d): data truncated from %d to %d\n",
+ snum,rlen,sdata);
+ rlen = sdata;
+ }
+ memcpy(pdata,rdata,rlen);
+ }
+ return(rv);
+}
+
+static char *entstr(int i)
+{
+ char *pstr = NULL;
+ switch(i) {
+ case 0: pstr = "Inlet"; break;
+ case 1: pstr = "CPU"; break;
+ case 2:
+ default:
+ pstr = "Baseboard"; break;
+ }
+ return(pstr);
+}
+
+static int dcmi_get_sensors(int styp)
+{
+ int i, j, n, r, recs;
+ uchar offset, id;
+ uchar dbuf[20];
+ uchar s1;
+ int rv;
+ uchar *sdrs = NULL;
+ uchar sdr[128];
+
+ offset = 0;
+ r = 1; n = 8;
+ s1 = 0x40; /*0x40,0x41,0x42*/
+ rv = get_sdr_cache(&sdrs);
+
+ printf("---Sensors---\n");
+ for (i = 0; i < 3; i++)
+ {
+ rv = dcmi_get_sensorinf(styp,s1+i,offset,dbuf,sizeof(dbuf));
+ if (rv != 0) break;
+ n = dbuf[1];
+ recs = dbuf[2];
+ printf(" %d %s temp sensors: \tn_returned=%d\n",n,entstr(i),recs);
+ for (r = 0; r < n; r += recs)
+ {
+ recs = dbuf[2];
+ if (recs == 0) break;
+ for (j = 0; j < r; j++) {
+ id = (dbuf[4 + (2*j)] << 8) + dbuf[3 + (2*j)];
+ if (fdebug) printf("j=%d id=%x \n",j,id);
+ /* get the sensor info for each record id */
+ rv = find_sdr_next(sdr,sdrs,(id-1));
+ ShowSDR("",sdr);
+ }
+ offset += recs;
+ rv = dcmi_get_sensorinf(1,s1+i,offset,dbuf,sizeof(dbuf));
+ if (rv != 0) break;
+ }
+ }
+ if (rv != 0) printf("dcmi_get_sensors(%d,%d) error %d\n",styp,i,rv);
+ free_sdr_cache(sdrs);
+ return(rv);
+}
+
+static int dcmi_get_asset_tag(char *pdata, int sdata, int *dlen)
+{
+ uchar idata[4];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int n, rv = -1;
+ int sz_chunk = 16;
+ int sz_all;
+
+ if (pdata == NULL || sdata < 16) return(ERR_BAD_PARAM);
+ memset(pdata,0,sdata);
+ sz_all = sdata;
+ for (n = 0; (n < sdata && n < sz_all); n += sz_chunk) {
+ idata[0] = 0xDC;
+ idata[1] = n; /*offset*/
+ idata[2] = sz_chunk; /*bytes to read*/
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_ASSETTAG, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,3, rdata, &rlen, &cc, fdebug);
+ if (fdebug)
+ printf("dcmi_get_asset(%d): rv=%d ccode=%02x rlen=%d\n",
+ n,rv,cc,rlen);
+ if (rv == 0) rv = cc;
+ if (rv == 0) { /* if here, success */
+ if (n == 0) sz_all = rdata[1];
+ if ((n + sz_chunk) > sdata) {
+ if (fdebug)
+ printf("dcmi_get_asset(%d): data truncated from %d to %d\n",
+ n,(n+sz_chunk),sdata);
+ sz_chunk = (sdata - n);
+ }
+ memcpy(&pdata[n],&rdata[2],sz_chunk);
+ } else break;
+ } /*end-for loop*/
+ pdata[n] = 0; /*stringify*/
+ if (dlen != NULL) *dlen = n;
+ return(rv);
+}
+
+static int dcmi_get_mc_id(char *pdata, int sdata, int *dlen)
+{
+ uchar idata[4];
+ uchar rdata[32];
+ int rlen;
+ uchar cc;
+ int n, rv = -1;
+ int sz_chunk = 16;
+ int sz_all;
+
+ if (pdata == NULL || sdata < 16) return(ERR_BAD_PARAM);
+ memset(pdata,0,sdata);
+ sz_all = sdata;
+ for (n = 0; (n < sdata && n < sz_all); n += sz_chunk) {
+ idata[0] = 0xDC;
+ idata[1] = n; /*offset*/
+ idata[2] = sz_chunk; /*bytes to read*/
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_GET_MCIDSTR, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,3, rdata, &rlen, &cc, fdebug);
+ if (fdebug)
+ printf("dcmi_get_mc_id(%d): rv=%d ccode=%02x rlen=%d\n",
+ n,rv,cc,rlen);
+ if (rv == 0) rv = cc;
+ if (rv == 0) { /* if here, success */
+ if (n == 0) sz_all = rdata[1];
+ if ((n + sz_chunk) > sdata) {
+ if (fdebug)
+ printf("dcmi_get_mc_id(%d): data truncated from %d to %d\n",
+ n,(n+sz_chunk),sdata);
+ sz_chunk = (sdata - n);
+ }
+ memcpy(&pdata[n],&rdata[2],sz_chunk);
+ } else break;
+ } /*end-for loop*/
+ pdata[n] = 0; /*stringify*/
+ if (dlen != NULL) *dlen = n;
+ return(rv);
+}
+
+static int dcmi_set_asset_tag(char *pdata, int sdata)
+{
+ int rv = -1;
+ uchar idata[32];
+ uchar rdata[8];
+ uchar cc;
+ int ilen, rlen, n;
+ int sz_chunk = 16;
+
+ if (pdata == NULL || sdata < 2) return(ERR_BAD_PARAM);
+ for (n = 0; (n < sdata); n += sz_chunk) {
+ idata[0] = 0xDC;
+ idata[1] = n; /*offset*/
+ idata[2] = sz_chunk; /*bytes to read*/
+ memset(&idata[3],0x20,sz_chunk);
+ ilen = 3 + sz_chunk;
+ if ((n + sz_chunk) > sdata) sz_chunk = sdata - n;
+ memcpy(&idata[3],&pdata[n],sz_chunk);
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_SET_ASSETTAG, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,ilen, rdata, &rlen, &cc, fdebug);
+ if (rv == 0) {
+ if (fdebug)
+ printf("dcmi_set_asset_tag(%d,%d,%d) cc=%x resp: %02x %02x %02x\n",
+ sdata,n,sz_chunk,cc,rdata[0],rdata[1],rdata[2]);
+ rv = cc;
+ }
+ if (rv != 0) break;
+ }
+ return(rv);
+}
+
+static int dcmi_set_mc_id(char *pdata, int sdata)
+{
+ int rv = -1;
+ uchar idata[32];
+ uchar rdata[8];
+ uchar cc;
+ int ilen, rlen, n;
+ int sz_chunk = 16;
+
+ if (pdata == NULL || sdata < 2) return(ERR_BAD_PARAM);
+ for (n = 0; (n < sdata); n += sz_chunk) {
+ if ((n + sz_chunk) > sdata) sz_chunk = sdata - n;
+ idata[0] = 0xDC;
+ idata[1] = n; /*offset*/
+ idata[2] = sz_chunk; /*bytes to read*/
+ memset(&idata[3],0x20,sz_chunk);
+ ilen = 3 + sz_chunk;
+ if ((n + sz_chunk) > sdata) sz_chunk = sdata - n;
+ memcpy(&idata[3],&pdata[n],sz_chunk);
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw( CMD_DCMI_SET_MCIDSTR, NETFN_DCMI,
+ g_sa, g_bus, g_lun,
+ idata,ilen, rdata, &rlen, &cc, fdebug);
+ if (rv == 0) {
+ if (fdebug) printf("dcmi_set_mc_id(%d,%d,%d) resp: %02x %02x %02x\n",
+ sdata,n,sz_chunk,rdata[0], rdata[1], rdata[2]);
+ rv = cc;
+ }
+ if (rv != 0) break;
+ }
+ return(rv);
+}
+
+static int dcmi_show_asset_tag(void)
+{
+ int rv = -1;
+ rv = dcmi_get_asset_tag(asset,sizeof(asset),&asset_len);
+ if (rv == 0) printf("DCMI Asset Tag: \t%s\n",asset);
+ return(rv);
+}
+
+static int dcmi_show_mc_id(void)
+{
+ int rv = -1;
+ rv = dcmi_get_mc_id(mc_id,sizeof(mc_id),&mcid_len);
+ if (rv == 0) printf("DCMI Mgt Controller ID: \t%s\n",mc_id);
+ return(rv);
+}
+
+static char *supported[2] = { "Unsupported", "Supported" };
+
+void dcmi_show_capab(int parm, uchar *cdata, int sdata)
+{
+ char mystr[64] = "";
+ int i, j, k, n, f;
+ switch(parm)
+ {
+ case 1:
+ printf("DCMI Version: \t%d.%d\n",cdata[1],cdata[2]);
+ dcmi_ver = ((cdata[1] & 0x0f) << 4) + (cdata[2] & 0x0f);
+ if (cdata[5] & 0x01) { fpwm = 1; }
+ else { fpwm = 0; }
+ printf("DCMI Power Management: \t%s\n",supported[fpwm]);
+ if (cdata[6] & 0x01) f = 1;
+ else f = 0;
+ printf("DCMI System Interface Access:\t%s\n",supported[f]);
+ if (cdata[6] & 0x02) f = 1;
+ else f = 0;
+ printf("DCMI Serial TMode Access:\t%s\n",supported[f]);
+ if (cdata[6] & 0x02) f = 1;
+ else f = 0;
+ printf("DCMI Secondary LAN Channel:\t%s\n",supported[f]);
+ break;
+ case 2:
+ mystr[0] = 0;
+ if (cdata[5] & 0x80) strcat(mystr,"Overwrite ");
+ else strcat(mystr,"NoOverwrite ");
+ if (cdata[5] & 0x40) strcat(mystr,"FlushAll ");
+ if (cdata[5] & 0x20) strcat(mystr,"FlushRec");
+ printf("DCMI SEL Management: \t%s\n",mystr);
+ n = ((cdata[5] & 0x0F) << 8) + cdata[4];
+ printf("DCMI SEL num entries: \t%d\n",n);
+ i = cdata[8];
+ printf("DCMI Temperature Polling: \t%d sec\n",i);
+ break;
+ case 3:
+ n = ((cdata[4] & 0xFE) >> 1);
+ printf("DCMI PWM Slave_Address: \t%02x\n",n);
+ n = ((cdata[5] & 0xF0) >> 4);
+ printf("DCMI PWM Channel: \t%02x\n",n);
+ printf("DCMI PWM Dev_Rev: \t%02x\n",(cdata[5] & 0x0F));
+ break;
+ case 4:
+ printf("DCMI LanPlus primary chan:\t%02x\n",cdata[4]);
+ printf("DCMI LanPlus secondary chan:\t%02x\n",cdata[5]);
+ printf("DCMI Serial channel: \t%02x\n",cdata[6]);
+ break;
+ case 5:
+ n = cdata[4];
+ if (n > (5 + sdata)) n = sdata - 5; /*truncate*/
+ for (i = 0; i < n; i++) {
+ j = (cdata[5+i] & 0x0f);
+ k = ((cdata[5+i] & 0xf0) >> 4);
+ switch(k) {
+ case 3: strcpy(mystr,"days"); break;
+ case 2: strcpy(mystr,"hrs"); break;
+ case 1: strcpy(mystr,"min"); break;
+ case 0:
+ default: strcpy(mystr,"sec"); break;
+ }
+ printf("DCMI Power Stats Duration(%d):\t%d %s\n",i,j,mystr);
+ }
+ break;
+ default:
+ printf("DCMI(%d) data: %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ parm,cdata[1],cdata[2],cdata[3],cdata[4],
+ cdata[5], cdata[6], cdata[7], cdata[8]);
+ break;
+ }
+}
+
+static int dcmi_show_all_capab(void)
+{
+ int rv = -1;
+ int i;
+ uchar cdata[32];
+
+ for (i = 1; i <= 5; i++)
+ {
+ /* only read power stats(5) when power management is supported */
+ if (i == 5 && fpwm == 0) continue;
+ rv = dcmi_get_capab(i, cdata, sizeof(cdata));
+ if (rv != 0) {
+ if (i == 1 && rv == CC_DCMI_INVALID_COMMAND) { /*0xC1 on first*/
+ printf("DCMI not supported on this platform\n");
+ break;
+ } else if (i == 5 && rv == CC_DCMI_RECORD_NOT_PRESENT) /*0xCB*/
+ rv = 0; /*optional, ignore this error*/
+ /*else just dont show the param*/
+ } else dcmi_show_capab(i,cdata,sizeof(cdata));
+
+ } /*end-for dcmi_capab loop */
+ return(rv);
+}
+
+#ifdef METACOMMAND
+int i_dcmi(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rv = 0;
+ int c, i;
+ char *s1;
+ uchar cdata[32];
+ uchar powdata[32];
+
+ printf("%s ver %s\n", progname,progver);
+ parse_lan_options('V',"4",0); /*default to admin priv*/
+
+ while ( (c = getopt( argc, argv,"a:d:m:sT:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'a': set_asset = 1; asset_new = optarg; break;
+ case 'd': set_mcid = 1; mcid_new = optarg; break;
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 's': do_sensors = 1; break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ return(dcmi_usage());
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ if ((argc > 0) && strcmp(argv[0], "help") == 0) {
+ return(dcmi_usage());
+ }
+
+ rv = ipmi_getdeviceid( cdata, sizeof(cdata),fdebug);
+ if (rv == 0) {
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = cdata[4] & 0x0f;
+ ipmi_min = cdata[4] >> 4;
+ show_devid( cdata[2], cdata[3], ipmi_maj, ipmi_min);
+ } else goto do_exit;
+
+ if (set_asset) {
+ rv = dcmi_get_asset_tag(asset,sizeof(asset),&asset_len);
+ memset(asset,' ',asset_len); /*fill with spaces*/
+ asset_len = strlen_(asset_new);
+ if (asset_len >= sizeof(asset)) asset_len = sizeof(asset) - 1;
+ memcpy(asset,asset_new,asset_len);
+ asset[asset_len] = 0;
+ rv = dcmi_set_asset_tag(asset, asset_len);
+ printf("Set DCMI Asset Tag to %s, ret = %d\n",asset_new,rv);
+ }
+ if (set_mcid) {
+ rv = dcmi_get_mc_id(mc_id,sizeof(mc_id),&mcid_len);
+ memset(mc_id,' ',mcid_len); /*fill with spaces*/
+ mcid_len = strlen_(mcid_new);
+ if (mcid_len >= sizeof(mc_id)) mcid_len = sizeof(mc_id) - 1;
+ memcpy(mc_id,mcid_new,mcid_len);
+ mc_id[mcid_len] = 0;
+ rv = dcmi_set_mc_id(mcid_new, mcid_len);
+ printf("Set DCMI MC ID to %s, ret = %d\n",mcid_new,rv);
+ }
+
+ if ( (argc == 0) || (strcmp(argv[0], "info") == 0) ) {
+ rv = dcmi_show_all_capab();
+ if (rv == 0) {
+ rv = dcmi_show_mc_id();
+ rv = dcmi_show_asset_tag();
+ if (do_sensors) rv = dcmi_get_sensors(1); /*temp sensors*/
+ rv = 0; /*ignore errors for optional features*/
+ }
+ } else
+ {
+ rv = dcmi_get_capab(1, cdata, sizeof(cdata));
+ if (rv == 0) dcmi_show_capab(1,cdata,sizeof(cdata));
+ else if (rv == CC_DCMI_INVALID_COMMAND) /*0xC1 on first*/
+ printf("DCMI not supported on this platform\n");
+
+ if (strncmp(argv[0], "power",5) == 0) {
+ if (fpwm == 0) { /*not supported in capab */
+ printf("DCMI Power functions not supported on this platform.\n");
+ rv = LAN_ERR_NOTSUPPORT;
+ } else {
+ rv = dcmi_get_power_read(1, cdata, sizeof(cdata));
+ if (rv == 0) {
+ dcmi_show_power_read(1,cdata,sizeof(cdata));
+ rv = dcmi_get_power_limit(powdata, sizeof(powdata));
+ if (rv == 0)
+ dcmi_show_power_limit(powdata,sizeof(powdata),rv);
+ else if (rv == 0x80) {
+ dcmi_show_power_limit(powdata,sizeof(powdata),rv);
+ rv = 0;
+ }
+ }
+ if (argc < 2) ; /*just get, done above*/
+ else if (strncmp(argv[1],"get",3) == 0) ; /*done above*/
+ else if (strncmp(argv[1],"set_limit",9) == 0) {
+ if (argc < 3) return(dcmi_usage());
+ i = atoi(argv[2]);
+ { /*let range checking be done by DCMI*/
+ rv = dcmi_set_power_limit (POWER_LIMIT, i, powdata,16);
+ switch(rv) {
+ case 0:
+ printf("DCMI Power limit applied successfully.\n");
+ break;
+ case 0x84: printf("Power limit out of range\n"); break;
+ case 0x85: printf("Correction time out of range\n");
+ break;
+ case 0x89:
+ printf("Statistics reporting period out of range\n");
+ break;
+ default:
+ printf("DCMI Power Limit Set error %d\n",rv); break;
+ }
+ if (rv == 0) {
+ rv = dcmi_power_limit_activate(1);
+ printf ("DCMI Power Limit Activate returned %d\n",rv);
+ }
+ }
+ }
+ else if (strncmp(argv[1],"activate",8) == 0) {
+ rv = dcmi_power_limit_activate(1);
+ if (rv == 0)
+ printf ("DCMI Power Limit Activated.\n");
+ else printf("DCMI Power Limit Activate error %d\n",rv);
+ }
+ else if (strncmp(argv[1],"deactivate",10) == 0) {
+ rv = dcmi_power_limit_activate(0);
+ if (rv == 0)
+ printf("DCMI Power Limit Deactivated.\n");
+ else printf("DCMI Power Limit Deactivate error %d\n",rv);
+ }
+ else if (strcmp(argv[1],"set_action")==0) {
+ if (argc < 3) return(dcmi_usage());
+ else if (strcmp(argv[2],"no_action") == 0)
+ rv = dcmi_set_power_limit(EXCEPTION_ACTION,0x00,
+ powdata,16);
+ else if (strcmp(argv[2],"log_sel") == 0)
+ rv = dcmi_set_power_limit(EXCEPTION_ACTION,0x11,
+ powdata,16);
+ else if (strcmp(argv[2],"power_off") == 0)
+ rv = dcmi_set_power_limit(EXCEPTION_ACTION,0x01,
+ powdata,16);
+ else return(dcmi_usage());
+ if (rv == 0)
+ printf("exception action set successfully.\n");
+ else printf("set_exception action error %d\n",rv);
+ }
+ else if (strcmp(argv[1],"set_sample")==0) {
+ if (argc < 3) return(dcmi_usage());
+ i = atoi(argv[2]);
+ if (i != 0) {
+ rv = dcmi_set_power_limit (SAMPLE_PERIOD,i,powdata,16);
+ if (rv == 0x00)
+ printf("sample period set successfully\n");
+ else if (rv == 0x89)
+ printf("sample period %d out of range\n",i);
+ else printf("set_sample period error %d\n",rv);
+ }
+ else { printf("invalid sample period %d\n",i);
+ rv = ERR_USAGE; }
+ }
+ else if (strcmp(argv[1],"set_correction")==0) {
+ if (argc < 3) return(dcmi_usage());
+ i = atoi(argv[2]);
+ if (i != 0) {
+ rv = dcmi_set_power_limit(CORRECTION_TIME,i,powdata,16);
+ if (rv == 0x00)
+ printf("correction time set successfully\n");
+ else if (rv == 0x85)
+ printf("correction time %d out of range\n",i);
+ else {
+ dcmi_usage();
+ rv = ERR_USAGE;
+ }
+ }
+ else { printf("correction time %d invalid\n",i);
+ rv = ERR_USAGE; }
+ }
+ else {
+ printf("invalid subfunction %s\n",argv[1]);
+ rv = ERR_USAGE;
+ }
+ } /* endif power functions supported */
+
+ } else if (strcmp(argv[0], "thermal") == 0) {
+ if (dcmi_ver < 0x15) { /*not supported in DCMI < 1.5 */
+ printf("DCMI 1.5 Thermal functions not supported on this platform.\n");
+ rv = LAN_ERR_NOTSUPPORT;
+ } else {
+ rv = dcmi_get_sensors(1); /*temp sensors*/
+/* These are DCMI 1.5 commands */
+// #define CMD_DCMI_SET_THERMLIM 0x0B
+// #define CMD_DCMI_GET_THERMLIM 0x0C
+// #define CMD_DCMI_GET_TEMPRDNGS 0x10
+/* TODO: implement these 3 DCMI thermal commands */
+ printf("DCMI 1.5 Thermal functions not yet implemented\n");
+ rv = ERR_USAGE;
+ }
+ } else if (strcmp(argv[0], "config") == 0) {
+ if (dcmi_ver < 0x15) { /*not supported in DCMI < 1.5 */
+ printf("DCMI 1.5 Config functions not supported on this platform.\n");
+ rv = LAN_ERR_NOTSUPPORT;
+ } else { /* These are DCMI 1.5 commands */
+// #define CMD_DCMI_SET_CONFIG 0x12
+// #define CMD_DCMI_GET_CONFIG 0x13
+/* TODO: implement these 2 DCMI config commands */
+ printf("DCMI 1.5 Config get/set functions not yet implemented\n");
+ rv = ERR_USAGE;
+ }
+ } else {
+ return(dcmi_usage());
+ }
+ } /*else not info command*/
+
+do_exit:
+ ipmi_close_();
+ return rv;
+}
+/* end idcmi.c */
diff --git a/util/idcmi.h b/util/idcmi.h
new file mode 100644
index 0000000..a528831
--- /dev/null
+++ b/util/idcmi.h
@@ -0,0 +1,69 @@
+/*
+ * idcmi.h
+ * Data Center Manageability Interface (DCMI) command support
+ *
+ * Change history:
+ * 11/17/2011 ARCress - created
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2011 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+#ifndef IPMI_DCMI_H
+#define IPMI_DCMI_H
+
+#define CC_DCMI_INVALID_COMMAND 0xC1
+#define CC_DCMI_RECORD_NOT_PRESENT 0xCB
+#define NETFN_DCMI 0x2C
+/* for DCMI 1.0 and greater */
+#define CMD_DCMI_GET_CAPAB 0x01
+#define CMD_DCMI_GET_POWREAD 0x02
+#define CMD_DCMI_GET_POWLIMIT 0x03
+#define CMD_DCMI_SET_POWLIMIT 0x04
+#define CMD_DCMI_ACT_POWLIMIT 0x05
+#define CMD_DCMI_GET_ASSETTAG 0x06
+#define CMD_DCMI_GET_SENSORINF 0x07
+#define CMD_DCMI_SET_ASSETTAG 0x08
+#define CMD_DCMI_GET_MCIDSTR 0x09
+#define CMD_DCMI_SET_MCIDSTR 0x0A
+/* for DCMI 1.5 only */
+#define CMD_DCMI_SET_THERMLIM 0x0B
+#define CMD_DCMI_GET_THERMLIM 0x0C
+#define CMD_DCMI_GET_TEMPRDNGS 0x10
+#define CMD_DCMI_SET_CONFIG 0x12
+#define CMD_DCMI_GET_CONFIG 0x13
+
+/* CMD_DCMI_SET_POWLIMIT options */
+#define CORRECTION_TIME 0x01
+#define EXCEPTION_ACTION 0x02
+#define POWER_LIMIT 0x03
+#define SAMPLE_PERIOD 0x04
+
+#endif
+/* end idcmi.h */
diff --git a/util/idiscover.c b/util/idiscover.c
new file mode 100644
index 0000000..57471e3
--- /dev/null
+++ b/util/idiscover.c
@@ -0,0 +1,1055 @@
+/*
+ * idiscover.c
+ * Discover all IPMI-LAN-enabled nodes on this network or subnet.
+ * This program is not completely reliable yet, not all IPMI-LAN-enabled
+ * nodes respond.
+ * Currently this utility is compiled with NO_THREADS, but threads can
+ * be enabled by commenting out this flag.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 10/27/06 Andy Cress - created
+ * 05/01/07 Andy Cress - added -g for GetChannelAuthCap method,
+ * added -a logic for broadcast ping,
+ * updated WIN32 logic
+ * 09/20/07 Andy Cress - fixed send/receive thread order
+ * 07/15/08 Andy Cress - added -r for ping repeats
+ * 11/21/08 Andy Cress - detect eth intf and broadcast ip addr
+ */
+/*M*
+Copyright (c) 2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <winsock.h>
+#include <io.h>
+#include <time.h>
+#include "getopt.h"
+#define NO_THREADS 1
+typedef unsigned int socklen_t;
+WSADATA lan_ws; /*global for WSA*/
+
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#define NO_THREADS 1
+
+#else
+/* Linux, BSD, Solaris */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <pthread.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <sys/sockio.h>
+#ifndef HAVE_CONFIG_H
+typedef unsigned int socklen_t;
+#endif
+#else
+#include <getopt.h>
+#endif
+
+/* comment out NO_THREADS to use this utility in Linux with threads */
+#define NO_THREADS 1
+#endif
+#ifndef ETH_P_IP
+#define ETH_P_IP 0x0800 /* Internet Protocol packet, see linux/if_ether.h */
+#endif
+
+/* TODO: fix RAW for -m in Solaris, FreeBSD, Windows (works in Linux) */
+#ifdef SOLARIS
+#include <sys/sockio.h>
+#define RAW_DOMAIN AF_INET
+#define RAW_PROTO IPPROTO_RAW
+static char frawok = 0; /*raw not working in Solaris*/
+#elif BSD
+#define RAW_DOMAIN AF_INET
+#define RAW_PROTO IPPROTO_RAW
+static char frawok = 0; /*raw not working in FreeBSD*/
+#elif MACOS
+#define RAW_DOMAIN AF_INET
+#define RAW_PROTO IPPROTO_RAW
+static char frawok = 0; /*raw not working in FreeBSD*/
+#elif WIN32
+#define RAW_DOMAIN AF_INET
+#define RAW_PROTO IPPROTO_ICMP
+static char frawok = 0; /*raw not working in Windows*/
+#else
+#define RAW_DOMAIN AF_PACKET
+#define RAW_PROTO htons(ETH_P_IP)
+static char frawok = 1; /*raw works in Linux*/
+#endif
+
+#include <string.h>
+#include "ipmicmd.h"
+
+#ifndef INET_ADDRSTRLEN
+#define INET_ADDRSTRLEN 16
+#endif
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 64
+#endif
+
+#define RMCP_PRI_RMCP_PORT 0x26F
+#define SZ_PING 12
+#define IPMI_PING_MAX_LEN 50 /* usu 28 */
+#define CMD_GET_CHAN_AUTH_CAP 0x38
+
+#ifdef WIN32
+int GetFirstIP(uchar *ipaddr, uchar *macadr, char *ipname, char fdb); /*ilan.c*/
+#endif
+
+/*
+ * Global variables
+ */
+static char * progver = "1.9";
+static char * progname = "idiscover";
+static char fdebug = 0;
+static char fping = 1;
+static char fraw = 0;
+static char fBroadcastOk = 0;
+static char fcanonical = 0;
+static int broadcast_pings = 1;
+//static uchar ipmi_maj = 0;
+//static uchar ipmi_min = 0;
+//static uchar netfn;
+static ushort g_port = RMCP_PRI_RMCP_PORT;
+static SockType g_sockfd = 0;
+static SockType g_sockraw = 0;
+static int g_limit = 30; /* after this many 'other' packets, stop. */
+static struct sockaddr_in _srcaddr;
+// static struct sockaddr_in _destaddrlist[255];
+static struct in_addr _startAddr, _endAddr;
+static char g_startDest[MAXHOSTNAMELEN+1] = {'\0'};
+static char g_endDest[MAXHOSTNAMELEN+1] = {'\0'};
+static char g_interface[INET_ADDRSTRLEN+1] = {""}; /*e.g. "eth0"*/
+static int g_num_packets = 0;
+static int g_npings = 0;
+static int g_npongs = 0;
+static int g_recv_status = 0;
+static int g_wait = 1; /* num sec to wait */
+static int g_delay = 0; /* num usec between sends */
+static int g_repeat = 1; /* number of times to repeat ping to each node */
+static char bdelim = BDELIM; /* '|' */
+
+#ifdef METACOMMAND
+extern FILE *fpdbg; /*from ipmicmd.c*/
+extern char *strlasterr(int rv); /*from ipmilan.c*/
+#else
+void dump_buf(char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+ FILE *fpdbg;
+
+ fpdbg = stdout;
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ fprintf(fpdbg,"%s (len=%d): ", tag,sz);
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) { j = 0; fprintf(fpdbg,"%s\n %04x: ",line,i); }
+ if (fshowascii) {
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ }
+ fprintf(fpdbg,"%02x ",pbuf[i]);
+ }
+ if (j < 16) {
+ line[j] = 0;
+ for (i = 0; i < (16-j); i++) fprintf(fpdbg," ");
+ }
+ fprintf(fpdbg,"%s\n",line);
+ return;
+}
+#endif
+
+void printerr( const char *pattn, ...)
+{
+ va_list arglist;
+ FILE *fderr;
+
+ // fderr = fopen("/tmp/idiscover.log","a+");
+ // if (fderr == NULL) return;
+ fderr = stderr;
+
+ va_start(arglist, pattn);
+ vfprintf(fderr, pattn, arglist);
+ va_end(arglist);
+
+ // fclose(fderr);
+}
+
+static char *showlasterr(void)
+{
+ char *str;
+#ifdef WIN32
+ static char strbuf[80];
+ int rv;
+ char *desc;
+ rv = WSAGetLastError();
+#ifdef METACOMMAND
+ /* get descriptions from strlasterr in ipmilan.c */
+ desc = strlasterr(rv);
+#else
+ if (rv == WSAECONNRESET) desc = "Connection reset"; /*10054*/
+ else if (rv == WSAECONNREFUSED) desc = "Connection refused"; /*10061*/
+ else if (rv == WSAEHOSTUNREACH) desc = "No route to host"; /*10065*/
+ else desc = "";
+#endif
+ sprintf(strbuf,"LastError = %d %s",rv,desc);
+ str = strbuf;
+#else
+ str = strerror(errno);
+#endif
+ return(str);
+}
+
+static void cleanup(void)
+{
+ SockType *pfd;
+ int i;
+ for (i = 0; i < 2; i++) {
+ if (i == 0) pfd = &g_sockfd;
+ else pfd = &g_sockraw;
+ if (*pfd > 0) {
+#ifdef WIN32
+ closesocket(*pfd);
+ WSACleanup();
+#else
+ close(*pfd);
+#endif
+ }
+ *pfd = 0;
+ }
+}
+
+void show_usage(void)
+{
+ printf("Usage: %s [-abegix] \n",progname);
+ printf(" -a all nodes, enables broadcast ping\n");
+ printf(" -b <ip> beginning IP address (x.x.x.x), required\n");
+ printf(" -e <ip> ending IP address (x.x.x.x), default is begin IP\n");
+ printf(" -g use GetChanAuthCap instead of RMCP ping\n");
+ printf(" -i interface name, default is eth0\n");
+ printf(" -m get MAC addresses with a raw broadcast ping\n");
+ printf(" -p N specific Port (IPMI LAN port=623)\n");
+ printf(" -r N number of Repeat pings to each node (default=1)\n");
+ // printf(" -s specific subnet\n");
+ printf(" -x show eXtra debug messages\n");
+}
+
+static int os_sleep(unsigned int s, unsigned int u)
+{
+#ifdef WIN32
+ if (s == 0) {
+ if (u >= 1000) Sleep(u/1000);
+ } else {
+ Sleep(s * 1000);
+ }
+#else
+/*Linux*/
+#ifdef SELECT_TIMER
+ struct timeval tv;
+ tv.tv_sec = s;
+ tv.tv_usec = u;
+ if (select(1, NULL, NULL, NULL, &tv) < 0)
+ printerr("select: %s\n", showlasterr());
+#else
+ if (s == 0) {
+ usleep(u);
+ } else {
+ sleep(s);
+ }
+#endif
+#endif
+ return 0;
+}
+
+void split_ip(uint addr, uchar *ip)
+{
+ ip[3] = (addr & 0x000000ff);
+ ip[2] = (addr & 0x0000ff00) >> 8;
+ ip[1] = (addr & 0x00ff0000) >> 16;
+ ip[0] = (addr & 0xff000000) >> 24;
+}
+
+int ntoi(int addr)
+{
+ return(addr);
+}
+
+void show_ip(int saddr)
+{
+ uchar ip[4];
+ split_ip(saddr,ip);
+ printerr("%d.%d.%d.%d\n",ip[0],ip[1],ip[2],ip[3]);
+}
+
+static int ipmilan_sendto(SockType s, const void *msg, size_t len, int flags,
+ const struct sockaddr *to, socklen_t tolen)
+{
+ int n;
+#ifdef NEED_PAD
+ int fusepad = 0;
+ /* Never need a pad byte for ping/pong packets */
+ if (len == 56 || len == 84 || len == 112 || len == 128 || len == 156) {
+ fusepad = 1;
+ len += 1;
+ }
+#endif
+ n = (int)sendto(s,msg,len,flags,to,tolen);
+ // if (fusepad && (n > 0)) n--;
+ return(n);
+}
+
+static int ipmilan_recvfrom(SockType s, void *buf, size_t len, int flags,
+ struct sockaddr *from, socklen_t *fromlen)
+{
+ int rv;
+ rv = (int)recvfrom(s,buf,len,flags,from,fromlen);
+ /* Sometimes the OS sends an ECONNREFUSED error, but
+ * retrying will catch the BMC's reply packet. */
+#ifdef WIN32
+ if (rv < 0) {
+ int err;
+ err = WSAGetLastError();
+ if (err == WSAECONNREFUSED) /*10061*/
+ rv = (int)recvfrom(s,buf,len,flags,from,fromlen);
+ }
+#else
+ if ((rv < 0) && (errno == ECONNREFUSED))
+ rv = (int)recvfrom(s,buf,len,flags,from,fromlen);
+#endif
+ return(rv);
+}
+
+#if defined(WIN32)
+int inet_aton(const char *cp, struct in_addr *inp)
+{
+ int rv;
+ int adr;
+ inp->s_addr = inet_addr(cp);
+ adr = (int)inp->s_addr;
+ if (adr == INADDR_NONE) rv = 0;
+ else rv = 1; /*success*/
+ return(rv);
+}
+#elif defined(SOLARIS)
+int find_ifname(char *ifname)
+{ return(-1); }
+#else
+#include <ifaddrs.h>
+int find_ifname(char *ifname)
+{
+ struct ifaddrs *ifaddr, *ifa;
+ int rv = -1;
+ if (getifaddrs(&ifaddr) == -1) return(rv);
+ for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+ if (ifa->ifa_addr == NULL) continue;
+ if ((ifa->ifa_addr->sa_family != AF_INET) &&
+ (ifa->ifa_addr->sa_family != AF_INET6)) continue;
+ if (strcmp(ifa->ifa_name,"lo") == 0) continue;
+ /* if here, we have a valid ifname */
+ strcpy(ifname,ifa->ifa_name);
+ if (fdebug) printf("find_ifname: found %s\n",ifname);
+ rv = 0;
+ break;
+ }
+ freeifaddrs(ifaddr);
+ return(rv);
+}
+#endif
+
+int sock_init( char *_interface, char *_startIP, char *_endIP)
+{
+ int rv;
+ uchar *pb;
+ uchar val;
+
+#ifdef WIN32
+ DWORD rvl;
+ rvl = WSAStartup(0x0101,&lan_ws);
+ if (rvl != 0) {
+ printerr("init: WSAStartup(1.1) error %ld\n", rvl);
+ return((int)rvl);
+ }
+#else
+ char findif;
+#endif
+
+ if ((g_sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == SockInvalid) {
+ printerr("socket: %s\n", showlasterr());
+ return(-1);
+ }
+
+ memset(&_srcaddr, 0, sizeof(_srcaddr));
+ _srcaddr.sin_family = AF_INET;
+ _srcaddr.sin_port = htons(0);
+ _srcaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+#ifdef WIN32
+ {
+ int ret;
+ uchar osip[4];
+ uchar osmac[6];
+ uchar osname[64];
+ char ipstr[20];
+ char *temp_start;
+ if (fBroadcastOk && (g_startDest[0] == 0)) {
+ ret = GetFirstIP(osip,osmac,osname,fdebug); /*ilan.c*/
+ if (ret == 0) {
+ // osip[3] = 0xFF; /*255 for broadcast*/
+ sprintf(ipstr,"%d.%d.%d.255",osip[0],osip[1],osip[2]);
+ temp_start = ipstr;
+ strcpy(g_startDest,temp_start);
+ strcpy(g_endDest,temp_start);
+ } else { /*use some defaults*/
+ strcpy(g_startDest,"255.255.255.255");
+ strcpy(g_endDest,"255.255.255.255");
+ }
+ }
+ }
+#elif defined(HPUX)
+ { /*find the OS eth interface to use*/
+ char devname[INET_ADDRSTRLEN+1];
+ int i, n;
+ n = 0;
+ sprintf(devname,"lan%d",n);
+ }
+#else
+ { /*find the OS eth interface to use*/
+ struct sockaddr_in temp_sockaddr;
+ char *temp_start;
+ struct ifreq ifr;
+ char devname[INET_ADDRSTRLEN+1];
+ int i, n;
+ if (_interface == NULL) findif = 1;
+ else if (_interface[0] == 0) findif = 1;
+ else findif = 0;
+ if (findif) {
+ n = find_ifname(devname);
+ if (n >= 0) {
+ _interface = devname;
+ findif = 0;
+ }
+ }
+ if (findif)
+ { /* try again to find the first active ethN interface */
+ n = -1;
+ for (i = 0; (i < 16) && (n == -1); i++) {
+#ifdef SOLARIS
+ sprintf(devname,"e1000g%d",i);
+#elif BSD
+ sprintf(devname,"em%d",i);
+#else
+ sprintf(devname,"eth%d",i);
+#endif
+ strcpy(ifr.ifr_name, devname);
+ ifr.ifr_addr.sa_family = AF_INET;
+ if (ioctl(g_sockfd, SIOCGIFADDR, &ifr) >= 0) {
+ /* valid IP address, so active interface, use it */
+ temp_sockaddr = *((struct sockaddr_in *)&ifr.ifr_addr);
+ memcpy(&_srcaddr.sin_addr.s_addr, &temp_sockaddr.sin_addr.s_addr,
+ sizeof(_srcaddr.sin_addr.s_addr));
+ strcpy(g_interface, devname);
+ temp_start = inet_ntoa(temp_sockaddr.sin_addr);
+ if (temp_start == NULL) temp_start = "";
+ else if (fBroadcastOk && (g_startDest[0] == 0)) {
+ pb = (uchar *)&temp_sockaddr.sin_addr.s_addr;
+ pb[3] = 0xFF; /*255 for broadcast*/
+ temp_start = inet_ntoa(temp_sockaddr.sin_addr);
+ strcpy(g_startDest,temp_start);
+ strcpy(g_endDest,temp_start);
+ }
+ printf("sock_init: found %s with %s\n",devname,temp_start);
+ n = i;
+ break;
+ }
+ }
+ if (n < 0) rv = LAN_ERR_OTHER; /*-13*/
+ } else { /* valid _interface string */
+ if (strchr(_interface, '.') != NULL)
+ { /* assume it is an IP address*/
+ if ((rv = inet_pton(AF_INET, _interface, &_srcaddr.sin_addr)) < 0)
+ printerr("inet_pton: %s\n", showlasterr());
+ if (rv == 0)
+ printerr("invalid interface address\n");
+ return(rv);
+ }
+ else
+ { /* assume interface name, like eth0 */
+ strncpy(ifr.ifr_name, _interface, IFNAMSIZ);
+ ifr.ifr_addr.sa_family = AF_INET;
+ if (ioctl(g_sockfd, SIOCGIFADDR, &ifr) < 0) {
+ printerr("ioctl(%s): %s\n", _interface, showlasterr());
+ return(-1);
+ }
+
+ temp_sockaddr = *((struct sockaddr_in *)&ifr.ifr_addr);
+ memcpy(&_srcaddr.sin_addr.s_addr, &temp_sockaddr.sin_addr.s_addr,
+ sizeof(_srcaddr.sin_addr.s_addr));
+ if (fBroadcastOk && (g_startDest[0] == 0)) {
+ pb = (uchar *)&temp_sockaddr.sin_addr.s_addr;
+ pb[3] = 0xFF; /*255 for broadcast*/
+ temp_start = inet_ntoa(temp_sockaddr.sin_addr);
+ strcpy(g_startDest,temp_start);
+ strcpy(g_endDest,temp_start);
+ }
+ }
+ }
+ }
+#endif
+
+ if (fBroadcastOk) {
+ rv = setsockopt(g_sockfd, SOL_SOCKET, SO_BROADCAST,
+ (char *)&broadcast_pings, sizeof(broadcast_pings));
+ if (rv) {
+ printerr("setsockopt: %s\n", showlasterr());
+ return(-1);
+ }
+ }
+
+ if (bind(g_sockfd, (struct sockaddr *)&_srcaddr, sizeof(_srcaddr)) < 0) {
+ printerr("bind: %s\n", showlasterr());
+ return(-1);
+ }
+
+ rv = inet_aton(_startIP, &_startAddr);
+ if (rv ) {
+ _startAddr.s_addr = ntohl(_startAddr.s_addr);
+ if (fdebug) show_ip(_startAddr.s_addr);
+ pb = (unsigned char*)&_startAddr.s_addr;
+ if (pb[0] < 1)
+ printerr("Malformed begin IP: %s\n", _startIP);
+ else if (!fBroadcastOk && (pb[0] >254) )
+ printerr("Malformed begin IP: %s\n", _startIP);
+ else if (fBroadcastOk) {
+ val = pb[0] & 0x0f;
+ if (val == 0x0f) rv = 0;
+ else printerr("Malformed begin broadcast IP: %s\n", _startIP);
+ } else rv = 0;
+ } else {
+ printerr("Invalid begin IP: %s\n", _startIP);
+ }
+ if (rv) return(rv);
+
+ rv = inet_aton(_endIP, &_endAddr);
+ if (rv ) {
+ _endAddr.s_addr = ntohl(_endAddr.s_addr);
+ if (fdebug) show_ip(_endAddr.s_addr);
+ pb = (unsigned char*)&_endAddr.s_addr;
+ if (pb[0] < 1)
+ printerr("Malformed end IP: %s\n", _endIP);
+ else if (!fBroadcastOk && (pb[0] >254) )
+ printerr("Malformed end IP: %s\n", _endIP);
+ else rv = 0;
+ } else {
+ printerr("Invalid end IP: %s\n", _endIP);
+ }
+
+ /* calculate g_num_packets */
+ g_num_packets = ntoi(_endAddr.s_addr) - ntoi(_startAddr.s_addr) + 1;
+ if (fdebug) printerr("g_num_packets = %d\n",g_num_packets);
+ if (g_num_packets < 1) g_num_packets = 0;
+
+ return(rv);
+} /*end sock_init*/
+
+void *receiveThread(void *p)
+{
+ uchar buffer[IPMI_PING_MAX_LEN];
+ struct timeval tv;
+ fd_set rset;
+ int rv, len;
+ static int needlf = 0;
+ char host[200];
+ SockType sockrecv;
+ int nothers = 0;
+ int addr_type = AF_INET; /*or AF_INET6*/
+#ifndef WIN32
+ struct hostent *h_ent = NULL;
+ char serv[200];
+ int r;
+#endif
+
+ sockrecv = g_sockfd;
+ if (fraw) { /* opening SOCK_RAW requires admin/root privilege. */
+ if ((g_sockraw = socket(RAW_DOMAIN, SOCK_RAW,RAW_PROTO)) == SockInvalid)
+ {
+ printerr("raw socket: %s\n", showlasterr());
+ fraw = 0;
+ } else {
+ sockrecv = g_sockraw;
+ if (fdebug) printf("g_sockraw = %d\n",g_sockraw);
+ }
+ }
+
+ /* receive while loop */
+ do
+ {
+ tv.tv_sec = g_wait;
+ tv.tv_usec = 0;
+ FD_ZERO(&rset);
+ FD_SET(sockrecv, &rset);
+ g_recv_status = 0;
+
+ if (fdebug) printerr("waiting for ping %d response\n",g_npings);
+ if ((rv = select((int)(sockrecv+1), &rset, NULL, NULL, &tv)) < 0) {
+ printerr("select: %s\n", showlasterr());
+ cleanup();
+ exit(rv); // error, exit idiscover recv thread
+ }
+
+ if (fdebug) printerr("select rv = %d\n",rv);
+ if (rv > 0)
+ {
+ struct sockaddr_in from;
+ socklen_t fromlen;
+ char rstr[40];
+ char macstr[20];
+ struct in_addr from_ip;
+ char estr[40];
+
+ if (needlf) { printf("\n"); needlf = 0; }
+ g_recv_status = 1;
+ fromlen = sizeof(from);
+ len = ipmilan_recvfrom(sockrecv, buffer, IPMI_PING_MAX_LEN, 0,
+ (struct sockaddr *)&from, &fromlen);
+ if (fdebug) printerr("recvfrom rv = %d\n",rv);
+ if (len < 0) {
+ printerr("ipmilan_recvfrom: %s\n", showlasterr());
+ continue;
+ }
+ if (fdebug) {
+ /* can we get the MAC addr of the responder also? */
+ // dump_buf("from_addr",(uchar *)&from,fromlen,0);
+ dump_buf("recvfrom",buffer,len,0);
+ }
+ g_recv_status = 2;
+ g_npongs++;
+ macstr[0] = 0;
+ if (fraw) { /* Raw packet, include MAC address string */
+ /*
+ * Sample raw packet for UDP ping response
+ * dst_mac src_mac eth_p iphdr
+ * 0000: 00 07 e9 06 15 31 00 0e 0c 2b b5 81 08 00 45 00
+ * udp src_ip dst_ip
+ * 0010: 00 38 00 00 40 00 40 11 b6 01 c0 a8 01 c2 c0 a8
+ * rmcp
+ * 0020: 01 a1 02 6f 80 1e 00 24 0e d1 06 00 ff 06 00 00
+ * 0030: 11 be
+ */
+ if ((buffer[23] != 0x11) || (buffer[42] != 0x06)) {
+ /* [23]: 0x11==UDP, 0x06==TCP ; [42]: 0x06 ==RMCP */
+ if (nothers > g_limit) {
+ if (fdebug)
+ printf("got %d other packets, stop.\n",nothers);
+ break;
+ }
+ nothers++;
+ continue;
+ }
+ if (buffer[6] == 0xFF || buffer[26] == 0xFF) /*broadcast*/
+ continue;
+ sprintf(macstr,"%02x:%02x:%02x:%02x:%02x:%02x %c",
+ buffer[6], buffer[7], buffer[8], /*06=src_mac*/
+ buffer[9], buffer[10], buffer[11], bdelim);
+ memcpy(&from_ip,&buffer[26],4); /*26=src_ip*/
+ } else {
+ memcpy(&from_ip,&from.sin_addr,4);
+ }
+ host[0] = 0;
+#ifndef WIN32
+/* Linux, BSD, Solaris, MacOS */
+#if !defined(CROSS_COMPILE)
+ h_ent = gethostbyaddr((void *)&from_ip,4,addr_type);
+ if (h_ent != NULL) {
+ strncpy(host,h_ent->h_name,sizeof(host));
+ } else if (!fraw)
+#endif
+ {
+ r = getnameinfo((struct sockaddr *)&from, fromlen,
+ host, sizeof(host), serv, sizeof(serv), 0);
+ if (r) host[0] = 0;
+ else if (host[0] >= '0' && host[0] <= '9') host[0] = 0;
+ }
+#endif
+ // parse the received pong
+ rstr[0] = 0;
+ if (fping == 0 && len > 0) { /* -g and got rsp data */
+ /* parse GetChanAuthcap response into rstr */
+ /* 4 bytes RMCP, 10 bytes IPMI session, then msg */
+ /* 6 bytes msg hdr, then rsp data */
+ /* 20 = ccode, 21 = chan, 22 = auth type support */
+ if (buffer[20] != 0) /*ccode error*/
+ sprintf(rstr,"%c (ccode=0x%02x)",bdelim,buffer[20]);
+ else /*ccode is ok*/
+ sprintf(rstr,"%c (channel %d)",bdelim,buffer[21]);
+ }
+ if (fcanonical) {
+ estr[0] = 0;
+ rstr[0] = 0;
+ } else {
+ sprintf(estr,"response from %c ",bdelim);
+ }
+ /* &buffer[0] = source MAC, &buffer[6] = destination MAC */
+ printf("%.2d%c %s%s %s \t%c %s %s\n",
+ g_npongs,bdelim,estr,macstr,inet_ntoa(from_ip),
+ bdelim,host,rstr);
+ }
+ else { /*ping, no answer*/
+ if (!fBroadcastOk) {
+ printf("."); fflush(stdout); /*show progress*/
+ needlf = 1;
+ }
+ }
+ }
+#ifdef NO_THREADS
+ while(fBroadcastOk && rv > 0);
+#else
+ while(1);
+#endif
+ return(p);
+}
+
+/*
+ * send_ping_pkt:
+ * RMCP Ping buffer, sent as a UDP packet to port 0x026f.
+ * rmcp.ver = 0x06 // RMCP Version 1.0
+ * rmcp.resvd = 0x00 // RESERVED
+ * rmcp.seq = 0xff // no RMCP ACK
+ * rmcp.class = 0x06 // RMCP_CLASS_ASF
+ * asf.iana = 0x000011BE // ASF_RMCP_IANA (hi-lo)
+ * asf.type = 0x80 // ASF_TYPE_PING
+ * asf.tag = 0x00 // ASF sequence number
+ * asf.resvd = 0x00 // RESERVED
+ * asf.len = 0x00
+ */
+int send_ping_pkt(struct sockaddr_in *_daddr, uchar seq)
+{
+ uchar pingbuf[SZ_PING] = {06,0,0xFF,06,0x00,0x00,0x11,0xBE,0x80,0,0,0 };
+ int rv, len;
+
+ pingbuf[9] = seq;
+ len = sizeof(pingbuf);
+ if (fdebug) dump_buf("send_ping",pingbuf,len,0);
+ rv = ipmilan_sendto(g_sockfd, pingbuf, len, 0,
+ (struct sockaddr *)_daddr, sizeof(struct sockaddr_in));
+ return(rv);
+}
+
+static int send_poke1(struct sockaddr_in *_daddr)
+{
+ int rv;
+ uchar asfpkt[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x07, 0x20, 0x18, 0xc8, 0xc2, 0x01, 0x01, 0x3c };
+ if (fdebug) dump_buf("send_poke1",asfpkt,16,0);
+ rv = ipmilan_sendto(g_sockfd, asfpkt, 16, 0,
+ (struct sockaddr *)_daddr, sizeof(struct sockaddr_in));
+ return rv;
+}
+
+static uchar cksum(const uchar *buf, register int len)
+{
+ register uchar csum;
+ register int i;
+
+ /* 8-bit 2s compliment checksum */
+ csum = 0;
+ for (i = 0; i < len; i++)
+ csum = (csum + buf[i]) % 256;
+ csum = -csum;
+ return(csum);
+}
+
+static int send_getauth(struct sockaddr_in *_daddr, uchar seq)
+{
+ int rv, len;
+ // static uchar swseq = 0;
+ uchar getauthpkt[23] = { 0x06, 0x00, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x20, 0x18,
+ 0xc8, 0x81, 0x04, 0x38, 0x0e, 0x04, 0x31 };
+ /*
+ * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
+ * 06 00 ff 07 00 00 00 00 00 00 00 00 00 09 20 18 c8 81 04 38 0e 04 31
+ * [RMCP hdr ] [IPMI session hdr (len)] [IPMI msg ] [data]
+ */
+ // getauthpkt[8] = 0x00; /* seq always 00 for GetChanAuthCap */
+ getauthpkt[21] = 0x02; /*requested priv_level: 2=user, 4=admin*/
+ getauthpkt[22] = cksum(&getauthpkt[17],5);
+ len = sizeof(getauthpkt);
+ if (fdebug) dump_buf("send_getauth",getauthpkt,len,0);
+ rv = ipmilan_sendto(g_sockfd, getauthpkt, len, 0,
+ (struct sockaddr *)_daddr, sizeof(struct sockaddr_in));
+ if (fdebug)
+ printf("send_getauth: rv = %d\n",rv);
+ return rv;
+}
+
+int send_probe(struct sockaddr_in *_daddr, uchar seq)
+{
+ int rv;
+
+ if (fBroadcastOk) {
+ rv = setsockopt(g_sockfd, SOL_SOCKET, SO_BROADCAST,
+ (char *)&broadcast_pings, sizeof(broadcast_pings));
+ if (fdebug) {
+ char *estr;
+ if (rv) estr = showlasterr();
+ else estr = "";
+ printerr("setsockopt(broadcast): rv=%d %s\n", rv,estr);
+ }
+ }
+ if (fping)
+ rv = send_ping_pkt( _daddr, seq);
+ else
+ rv = send_getauth( _daddr, seq);
+ return(rv);
+}
+
+void *sendThread(void *p)
+{
+ int i, j, n;
+ // char _dest[MAXHOSTNAMELEN+1];
+ char _dest_ip[INET_ADDRSTRLEN+1];
+ struct sockaddr_in _destaddr;
+ uchar o[4];
+ uint ip;
+ uchar _seq;
+ int rv;
+
+ n = g_num_packets; /*num*/
+ ip = _startAddr.s_addr;
+
+ for (i = 0; i < n; i++)
+ {
+ split_ip(ip,o);
+ if (o[3] == 0) continue;
+ if (!fBroadcastOk && (o[3] == 255)) continue;
+ sprintf(_dest_ip,"%d.%d.%d.%d",o[0],o[1],o[2],o[3]);
+
+ /* set _destaddr */
+ _destaddr.sin_family = AF_INET;
+ _destaddr.sin_port = htons(g_port);
+ if ( !inet_aton( _dest_ip, &_destaddr.sin_addr)) {
+ printerr("inet_aton error %s\n",_dest_ip);
+ continue;
+ }
+
+ for (j=0; j<g_repeat; j++)
+ {
+ /* send ping buffer */
+ _seq = 0;
+ rv = send_probe(&_destaddr,_seq);
+ g_npings++;
+ if (fdebug) printerr("sendto[%d,%d] %s rv = %d\n",
+ g_npings,_seq,_dest_ip,rv);
+ if (rv < 0) { /*try to send again*/
+ rv = send_probe(&_destaddr,++_seq);
+ if (rv < 0) {
+ printerr("sendto[%d,%d] %s error %s\n",
+ g_npings,_seq,_dest_ip,showlasterr());
+ continue;
+ }
+ }
+
+#ifdef NO_THREADS
+ receiveThread(NULL);
+ if (g_recv_status == 0 && !fBroadcastOk) {
+ /* nothing returned, try again */
+ if (fping) {
+ rv = send_poke1(&_destaddr);
+ if (fdebug) printerr("sendto[%d,%d] %s poke rv = %d\n",
+ g_npings,_seq,_dest_ip,rv);
+ }
+ rv = send_probe(&_destaddr,++_seq);
+ if (fdebug) printerr("sendto[%d,%d] %s rv = %d\n",
+ g_npings,_seq,_dest_ip,rv);
+ if (rv >= 0) {
+ receiveThread(NULL);
+ }
+ }
+#endif
+
+ /* sleep an interval (g_delay usec) */
+ if (g_delay > 0) os_sleep(0,g_delay);
+ } /*end-for g_repeat*/
+
+ ip++; /* increment to next IP */
+ }
+ return(p);
+}
+
+#ifdef METACOMMAND
+int i_discover(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rv = 0;
+ int c;
+#ifndef NO_THREADS
+ char message[32];
+ pthread_t thread[2];
+ int iret[2];
+#endif
+
+#ifdef METACOMMAND
+ fpdbg = stdout;
+#endif
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"ab:ce:gi:l:mp:r:s:x?")) != EOF )
+ switch(c) {
+ case 'a': fBroadcastOk = 1; fping = 1;
+ break; /*all (broadcast ping)*/
+ case 'c': /*canonical, CSV*/
+ fcanonical = 1;
+ bdelim = BCOMMA;
+ break;
+ case 'm': /* show MAC address, use raw, requires root priv */
+ fBroadcastOk = 1; fping = 1; fraw = 1;
+ break; /*all (broadcast ping)*/
+ case 'l': g_limit = atoi(optarg); break;
+ case 'g': fping = 0; break; /*use get chan auth cap method */
+ case 'b': /*begin*/
+ strncpy(g_startDest,optarg,MAXHOSTNAMELEN);
+ break;
+ case 'e': /*end*/
+ strncpy(g_endDest,optarg,MAXHOSTNAMELEN);
+ break;
+ case 'i': /*interface*/
+ strncpy(g_interface,optarg,sizeof(g_interface));
+ break;
+ case 'p': /*port/socket*/
+ g_port = (ushort)atoi(optarg);
+ break;
+ case 'r': /*repeat N times*/
+ g_repeat = atoi(optarg);
+ break;
+ case 's': /*subnet*/
+ /* copy optarg from 10.243.42.0 or similar, to
+ * begin/end range. */
+ break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ default:
+ if (fdebug) printerr("getopt(%c) default\n",c);
+ show_usage();
+ rv = ERR_USAGE;
+ goto do_exit;
+ }
+#ifdef WIN32
+ /* Winsock inet_aton() does not like 255.255.255.255 */
+ if (!fBroadcastOk && (g_startDest[0] == 0) ) {
+ show_usage();
+ printerr("A beginning IP is required, using -b\n");
+ goto do_exit;
+ }
+#else
+ if (g_startDest[0] == 0) {
+ strcpy(g_startDest,"255.255.255.255"); /* INADDR_BROADCAST */
+ fBroadcastOk = 1;
+ }
+#endif
+ if (fraw == 1) {
+ if (frawok == 0) {
+ printf("Warning: SOCK_RAW not yet implemented on this OS\n");
+ }
+#ifdef LINUX
+ else {
+ c = geteuid();
+ if (c > 1) printf("Must be root/superuser to use SOCK_RAW\n");
+ }
+#endif
+ }
+ if (g_endDest[0] == 0 || fBroadcastOk)
+ strcpy(g_endDest,g_startDest); /*only one IP address*/
+ if (fdebug)
+ printerr("intf=%s begin=%s end=%s port=%d\n",
+ g_interface,g_startDest,g_endDest,g_port);
+
+ rv = sock_init(g_interface, g_startDest, g_endDest);
+ if (fdebug) printerr("sock_init rv = %d, sockfd = %d\n",rv,g_sockfd);
+ if (rv != 0) {
+ show_usage();
+ printerr("sock_init error %d\n",rv);
+ goto do_exit;
+ }
+
+ printf("Discovering IPMI Devices:\n");
+#ifdef NO_THREADS
+ sendThread(NULL);
+#else
+ iret[1] = pthread_create( &thread[1], NULL, receiveThread, (void*) message);
+ iret[0] = pthread_create( &thread[0], NULL, sendThread, (void*) message);
+ pthread_join( thread[0], NULL);
+ pthread_join( thread[1], NULL);
+#endif
+
+ // if (fdebug)
+ printf("\n%s: %d pings sent, %d responses\n",progname,g_npings,g_npongs);
+
+do_exit:
+ cleanup();
+ return(rv);
+} /* end main()*/
+
+/* end idiscover.c */
diff --git a/util/iekanalyzer.c b/util/iekanalyzer.c
new file mode 100644
index 0000000..ddeeba8
--- /dev/null
+++ b/util/iekanalyzer.c
@@ -0,0 +1,4131 @@
+/*
+ * iekanalyzer.c
+ * Handle FRU EKey Analyzer functions
+ *
+ * Change history:
+ * 09/08/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2007 Kontron Canada, Inc. All Rights Reserved.
+ *
+ * Base on code from
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifdef WIN32
+#include <windows.h>
+#include "getopt.h"
+#else
+#include <sys/types.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include "ipmicmd.h"
+#include "iekanalyzer.h"
+
+extern int verbose; /*ipmilanplus.c*/
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+extern void set_loglevel(int level);
+
+/* fseek wrapper for size_t/long compile warnings */
+static int fseek_(FILE *fp, size_t offset, int whence)
+{ return(fseek(fp, (long)offset, whence)); }
+
+/*****************************************************************
+* CONSTANT
+*****************************************************************/
+const int ERROR_STATUS = -1;
+const int OK_STATUS = 0;
+
+const char * STAR_LINE_LIMITER =
+ "*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*";
+const char * EQUAL_LINE_LIMITER =
+ "=================================================================";
+const int SIZE_OF_FILE_TYPE = 3;
+const unsigned char AMC_MODULE = 0x80;
+const int PICMG_ID_OFFSET = 3;
+#define MAX_ARGC (MAX_FILE_NUMBER+4) /*8+4=12*/
+#define COMPARE_CANDIDATE 2
+/*In AMC.0 or PICMG 3.0 specification offset start from 0 with 3 bytes of
+* Mfg.ID, 1 byte of Picmg record Id, and
+* 1 byte of format version, so the data offset start from 5
+*/
+#define LOWER_OEM_TYPE 0xf0
+#define UPPER_OEM_TYPE 0xfe
+const int START_DATA_OFFSET = 5;
+const unsigned char DISABLE_PORT = 0x1f;
+
+const struct valstr ipmi_ekanalyzer_module_type[] = {
+ { ON_CARRIER_FRU_FILE, "On-Carrier Device" },
+ { A1_AMC_FRU_FILE, "AMC slot A1" },
+ { A2_AMC_FRU_FILE, "AMC slot A2" },
+ { A3_AMC_FRU_FILE, "AMC slot A3" },
+ { A4_AMC_FRU_FILE, "AMC slot A4" },
+ { B1_AMC_FRU_FILE, "AMC slot B1" },
+ { B2_AMC_FRU_FILE, "AMC slot B2" },
+ { B3_AMC_FRU_FILE, "AMC slot B3" },
+ { B4_AMC_FRU_FILE, "AMC slot B4" },
+ { RTM_FRU_FILE, "RTM" }, /*This is OEM specific module*/
+ { CONFIG_FILE, "Configuration file" },
+ { SHELF_MANAGER_FRU_FILE, "Shelf Manager" },
+ { 0xffff , NULL },
+};
+
+const struct valstr ipmi_ekanalyzer_IPMBL_addr[] = {
+ { 0x72, "AMC slot A1" },
+ { 0x74, "AMC slot A2" },
+ { 0x76, "AMC slot A3" },
+ { 0x78, "AMC slot A4" },
+ { 0x7a, "AMC slot B1" },
+ { 0x7c, "AMC slot B2" },
+ { 0x7e, "AMC slot B3" },
+ { 0x80, "AMC slot B4" },
+ { 0x90, "RTM"}, /*This is OEM specific module*/
+ { 0xffff , NULL },
+};
+
+const struct valstr ipmi_ekanalyzer_link_type[] = {
+ { 0x00, "Reserved" },
+ { 0x01, "Reserved" },
+ { 0x02, "AMC.1 PCI Express" },
+ { 0x03, "AMC.1 PCI Express Advanced Switching" },
+ { 0x04, "AMC.1 PCI Express Advanced Switching" },
+ { 0x05, "AMC.2 Ethernet" },
+ { 0x06, "AMC.4 Serial RapidIO" },
+ { 0x07, "AMC.3 Storage" },
+ /*This is OEM specific module*/
+ { 0xf0, "OEM Type 0"},
+ { 0xf1, "OEM Type 1"},
+ { 0xf2, "OEM Type 2"},
+ { 0xf3, "OEM Type 3"},
+ { 0xf4, "OEM Type 4"},
+ { 0xf5, "OEM Type 5"},
+ { 0xf6, "OEM Type 6"},
+ { 0xf7, "OEM Type 7"},
+ { 0xf8, "OEM Type 8"},
+ { 0xf9, "OEM Type 9"},
+ { 0xfa, "OEM Type 10"},
+ { 0xfb, "OEM Type 11"},
+ { 0xfc, "OEM Type 12"},
+ { 0xfd, "OEM Type 13"},
+ { 0xfe, "OEM Type 14"},
+ { 0xff , "Reserved" },
+};
+
+/*Reference: AMC.1 specification*/
+const struct valstr ipmi_ekanalyzer_extension_PCIE[] = {
+ { 0x00, "Gen 1 capable - non SSC" },
+ { 0x01, "Gen 1 capable - SSC" },
+ { 0x02, "Gen 2 capable - non SSC" },
+ { 0x03, "Gen 3 capable - SSC" },
+ { 0x0f, "Reserved"},
+};
+/*Reference: AMC.2 specification*/
+const struct valstr ipmi_ekanalyzer_extension_ETHERNET[] = {
+ { 0x00, "1000BASE-BX (SerDES Gigabit) Ethernet link" },
+ { 0x01, "10GBASE-BX4 10 Gigabit Ethernet link" },
+};
+/*Reference: AMC.3 specification*/
+const struct valstr ipmi_ekanalyzer_extension_STORAGE[] = {
+ { 0x00, "Fibre Channel (FC)" },
+ { 0x01, "Serial ATA (SATA)" },
+ { 0x02, "Serial Attached SCSI (SAS/SATA)" },
+};
+
+const struct valstr ipmi_ekanalyzer_asym_PCIE[] = {
+ { 0x00, "exact match"},
+ { 0x01, "provides a Primary PCI Express Port" },
+ { 0x02, "provides a Secondary PCI Express Port" },
+};
+
+const struct valstr ipmi_ekanalyzer_asym_STORAGE[] = {
+ { 0x00, "FC or SAS interface {exact match}" },
+ { 0x01, "SATA Server interface" },
+ { 0x02, "SATA Client interface" },
+ { 0x03, "Reserved" },
+};
+
+const struct valstr ipmi_ekanalyzer_picmg_record_id[] = {
+ { 0x04, "Backplane Point to Point Connectivity Record" },
+ { 0x10, "Address Table Record" },
+ { 0x11, "Shelf Power Distribution Record" },
+ { 0x12, "Shelf Activation and Power Management Record" },
+ { 0x13, "Shelf Manager IP Connection Record" },
+ { 0x14, "Board Point to Point Connectivity Record" },
+ { 0x15, "Radial IPMB-0 Link Mapping Record" },
+ { 0x16, "Module Current Requirements Record" },
+ { 0x17, "Carrier Activation and Power Management Record" },
+ { 0x18, "Carrier Point-to-Point Connectivity Record" },
+ { 0x19, "AdvancedMC Point-to-Point Connectivity Record" },
+ { 0x1a, "Carrier Information Table" },
+ { 0x1b, "Shelf Fan Geography Record" },
+ { 0x2c, "Carrier Clock Point-to-Point Connectivity Record" },
+ { 0x2d, "Clock Configuration Record" },
+};
+
+struct ipmi_ek_multi_header {
+ struct fru_multirec_header header;
+ unsigned char * data;
+ struct ipmi_ek_multi_header * prev;
+ struct ipmi_ek_multi_header * next;
+};
+
+struct ipmi_ek_amc_p2p_connectivity_record{
+ unsigned char guid_count;
+ struct fru_picmgext_guid * oem_guid;
+ unsigned char rsc_id;
+ unsigned char ch_count;
+ struct fru_picmgext_amc_channel_desc_record * ch_desc;
+ unsigned char link_desc_count;
+ struct fru_picmgext_amc_link_desc_record * link_desc;
+ int * matching_result; /*For link descriptor comparision*/
+};
+
+/*****************************************************************************
+* Function prototype
+******************************************************************************/
+/* global variables */
+static char * progname = "iekanalyzer";
+static char * progver = "1.00";
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+#ifndef HAVE_LANPLUS
+/* define these routines in ipmilanplus.c if no lanplus/helper.c */
+extern const char * val2str(uint16_t val, const struct valstr *vs);
+#endif
+/****************************************************************************
+* command Functions
+*****************************************************************************/
+static int ipmi_ekanalyzer_print( int argc, char * opt,
+ char ** filename, int * file_type );
+
+static tboolean ipmi_ekanalyzer_ekeying_match( int argc, char * opt,
+ char ** filename, int * file_type );
+
+
+/****************************************************************************
+* Linked list Functions
+*****************************************************************************/
+static void ipmi_ek_add_record2list( struct ipmi_ek_multi_header ** record,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last );
+
+static void ipmi_ek_display_record( struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_multi_header * list_head,
+ struct ipmi_ek_multi_header * list_last );
+
+static void ipmi_ek_remove_record_from_list(
+ struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last );
+
+static int ipmi_ekanalyzer_fru_file2structure( char * filename,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_record,
+ struct ipmi_ek_multi_header ** list_last );
+
+/****************************************************************************
+* Ekeying match Functions
+*****************************************************************************/
+static int ipmi_ek_matching_process( int * file_type, int index1, int index2,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last, char * opt,
+ struct ipmi_ek_multi_header * pphysical );
+
+static int ipmi_ek_get_resource_descriptor( int port_count, int index,
+ struct fru_picmgext_carrier_p2p_descriptor * port_desc,
+ struct ipmi_ek_multi_header * record );
+
+static int ipmi_ek_create_amc_p2p_record( struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_amc_p2p_connectivity_record * amc_record );
+
+static int ipmi_ek_compare_link( struct ipmi_ek_multi_header * physic_record,
+ struct ipmi_ek_amc_p2p_connectivity_record record1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2,
+ char * opt, int file_type1, int file_type2 );
+
+static tboolean ipmi_ek_compare_channel_descriptor(
+ struct fru_picmgext_amc_channel_desc_record ch_desc1,
+ struct fru_picmgext_amc_channel_desc_record ch_desc2,
+ struct fru_picmgext_carrier_p2p_descriptor * port_desc,
+ int index_port, unsigned char rsc_id );
+
+static int ipmi_ek_compare_link_descriptor(
+ struct ipmi_ek_amc_p2p_connectivity_record record1, int index1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2, int index2 );
+
+static int ipmi_ek_compare_asym( unsigned char asym[COMPARE_CANDIDATE] );
+
+static int ipmi_ek_compare_number_of_enable_port(
+ struct fru_picmgext_amc_link_desc_record link_desc[COMPARE_CANDIDATE] );
+
+static int ipmi_ek_check_physical_connectivity(
+ struct ipmi_ek_amc_p2p_connectivity_record record1, int index1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2, int index2,
+ struct ipmi_ek_multi_header * record,
+ int filetype1, int filetype2, char * option );
+
+/****************************************************************************
+* Display Functions
+*****************************************************************************/
+static int ipmi_ek_display_fru_header( char * filename );
+
+static void ipmi_ek_display_fru_header_detail( char * filename );
+
+static void ipmi_ek_display_chassis_info_area( FILE * input_file, long offset );
+
+static size_t ipmi_ek_display_board_info_area( FILE * input_file,
+ char * board_type, unsigned int * board_length );
+
+static void ipmi_ek_display_product_info_area( FILE * input_file, long offset );
+
+static tboolean ipmi_ek_display_link_descriptor( int file_type,
+ unsigned char rsc_id, char * str,
+ struct fru_picmgext_amc_link_desc_record link_desc );
+
+static void ipmi_ek_display_oem_guid(
+ struct ipmi_ek_amc_p2p_connectivity_record amc_record1 );
+
+static int ipmi_ek_diplay_carrier_connectivity(
+ struct ipmi_ek_multi_header * record );
+
+static int ipmi_ek_display_power( int argc, char * opt,
+ char ** filename, int * file_type );
+
+static void ipmi_ek_display_current_descriptor(
+ struct fru_picmgext_carrier_activation_record car,
+ struct fru_picmgext_activation_record * cur_desc, char * filename );
+
+static void ipmi_ek_display_backplane_p2p_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_address_table_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_shelf_power_distribution_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_shelf_activation_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_shelf_ip_connection_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_board_p2p_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_radial_ipmb0_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_amc_current_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_amc_activation_record (
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_amc_p2p_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_amc_carrier_info_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_clock_carrier_p2p_record(
+ struct ipmi_ek_multi_header * record );
+
+static void ipmi_ek_display_clock_config_record(
+ struct ipmi_ek_multi_header * record );
+
+/**************************************************************************
+*
+* Function name: ipmi_ekanalyzer_usage
+*
+* Description : Print the usage (help menu) of ekeying analyzer tool
+*
+* Restriction : None
+*
+* Input : None
+*
+* Output : None
+*
+* Global : None
+*
+* Return : None
+*
+***************************************************************************/
+static void
+ipmi_ekanalyzer_usage( void )
+{
+ char * help_message =
+"Ekeying analyzer tool version 1.00 \r\n\
+ekanalyzer Commands: \r\n\
+ print [carrier | power | all] <oc=filename1> <b1=filename2>... \r\n\
+ frushow <b2=filename> \r\n\
+ summary [match | unmatch | all] <oc=filename1> <b1=filename2>... \r\n\
+";
+ printf("%s",help_message);
+ fflush(stdout);
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_get_file_type
+*
+* Description: this function takes an argument, then xtract the file type and
+* convert into module type (on carrier, AMC,...) value.
+*
+*
+* Restriction: None
+*
+* Input: argument: strings contain the type and the name of the file
+* together
+*
+* Output: None
+*
+* Global: None
+*
+* Return: Return value of module type: On carrier FRU file, A1 FRUM file...
+* if the file type is invalid, it return -1. See structure
+* ipmi_ekanalyzer_module_type for a list of valid type.
+***************************************************************************/
+static int
+ipmi_ek_get_file_type( char * argument )
+{
+ // int index_name=0;
+ int filetype = ERROR_STATUS;
+
+ if( strlen (argument) > MIN_ARGUMENT ){
+ if( strncmp( argument, "oc=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = ON_CARRIER_FRU_FILE;
+ }
+ else if( strncmp( argument, "a1=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = A1_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "a2=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = A2_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "a3=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = A3_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "a4=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = A4_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "b1=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = B1_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "b2=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = B2_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "b3=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = B3_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "b4=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = B4_AMC_FRU_FILE;
+ }
+ else if( strncmp( argument, "rt=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = RTM_FRU_FILE;
+ }
+ else if( strncmp( argument, "rc=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = CONFIG_FILE;
+ }
+ else if( strncmp( argument, "sm=", SIZE_OF_FILE_TYPE ) == 0 ) {
+ filetype = SHELF_MANAGER_FRU_FILE;
+ }
+ else{
+ filetype = ERROR_STATUS;
+ }
+ }
+ return filetype;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ekanalyzer_main
+*
+* Description: Main program of ekeying analyzer. It calls the appropriate
+* function according to the command received.
+*
+* Restriction: None
+*
+* Input: ipmi_intf * intf: ?
+* int argc : number of argument received
+* int ** argv: argument strings
+*
+* Output: None
+*
+* Global: None
+*
+* Return: OK_STATUS as success or ERROR_STATUS as error
+*
+***************************************************************************/
+int
+ipmi_ekanalyzer_main( void * intf, int argc, char ** argv )
+{
+ int rc = ERROR_STATUS;
+ int file_type[MAX_FILE_NUMBER];
+ char * filename[MAX_FILE_NUMBER];
+ unsigned int argument_offset = 0;
+ unsigned int type_offset = 0;
+ /*list des multi record*/
+ struct ipmi_ek_multi_header * list_head = NULL;
+ struct ipmi_ek_multi_header * list_record = NULL;
+ struct ipmi_ek_multi_header * list_last = NULL;
+
+ set_loglevel(LOG_NOTICE);
+ if ( (argc == 0) || ( (argc - 1) > MAX_FILE_NUMBER ) ){
+ lprintf(LOG_ERR, "Too few or too many arguments.");
+ ipmi_ekanalyzer_usage();
+ rc = ERR_BAD_PARAM;
+ }
+ else if ( strcmp(argv[argument_offset], "help") == 0) {
+ ipmi_ekanalyzer_usage();
+ rc = ERR_USAGE;
+ }
+ else if ( (strcmp(argv[argument_offset], "frushow") == 0)
+ && (argc > (MIN_ARGUMENT-1) )
+ ){
+ for ( type_offset = 0; (int)type_offset < (argc-1); type_offset++ ){
+ argument_offset++;
+ file_type[type_offset] = ipmi_ek_get_file_type (argv[argument_offset]);
+ if ( file_type[type_offset] != ERROR_STATUS ){
+ if ( file_type[type_offset] != CONFIG_FILE ){
+ /* because of strlen doesn't count '\0', we need to add 1 byte for
+ * this character to filename size
+ */
+ filename[type_offset] = malloc( strlen(argv[argument_offset]) + 1
+ - SIZE_OF_FILE_TYPE
+ );
+ if( filename[type_offset] != NULL ){
+ strcpy(filename[type_offset],
+ &argv[argument_offset][SIZE_OF_FILE_TYPE]);
+ printf("Start converting file '%s'...\n", filename[type_offset]);
+ /* Display FRU header offset */
+ rc = ipmi_ek_display_fru_header (filename[type_offset]);
+
+ if ( rc != ERROR_STATUS ){
+ /* Display FRU header info in detail record */
+ ipmi_ek_display_fru_header_detail (filename[type_offset]);
+ /* Convert from binary data into multi record structure */
+ rc = ipmi_ekanalyzer_fru_file2structure ( filename[type_offset],
+ &list_head, &list_record, &list_last );
+
+ ipmi_ek_display_record ( list_record, list_head, list_last );
+ /* Remove record of list */
+ while ( list_head != NULL ){
+ ipmi_ek_remove_record_from_list( list_head,
+ &list_head,&list_last );
+ if (verbose > 1)
+ printf("record has been removed!\n");
+ }
+ }
+ free (filename[type_offset]);
+ }
+ }
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid file type!");
+ lprintf(LOG_ERR, " ekanalyzer frushow <xx=frufile> ...");
+ }
+ }
+ }
+ else if ( (strcmp(argv[argument_offset], "print") == 0)
+ || (strcmp(argv[argument_offset], "summary") == 0)
+ ){
+ /*Display help of the correspond command if there is not enought argument
+ * passing in command line
+ */
+ if ( argc < MIN_ARGUMENT ){
+ printf("Too few argument! \n");
+ if ( strcmp(argv[argument_offset], "print") == 0 ){
+ lprintf(LOG_ERR, " ekanalyzer print [carrier/power/all]"
+ " <xx=frufile> <xx=frufile> [xx=frufile]"
+ );
+ }
+ else{
+ lprintf(LOG_ERR, " ekanalyzer summary [match/ unmatch/ all]"
+ " <xx=frufile> <xx=frufile> [xx=frufile]"
+ );
+ }
+ }
+ else{
+ char * option;
+ /*index=1 indicates start position of first file name in command line*/
+ int index = 1;
+ int filename_size=0;
+
+ argument_offset++;
+ if ( (strcmp(argv[argument_offset], "carrier") == 0)
+ || (strcmp(argv[argument_offset], "power") == 0)
+ || (strcmp(argv[argument_offset], "all") == 0)
+ ){
+ option = argv[argument_offset];
+ index ++;
+ argc--;
+ }
+ else if ( ( strcmp(argv[argument_offset], "match") == 0 )
+ || ( strcmp(argv[argument_offset], "unmatch") == 0 )
+ ){
+ option = argv[argument_offset];
+ index ++;
+ argc--;
+ }
+ /*since the command line must receive xx=filename, so the position of
+ * "=" sign is 2
+ */
+ else if ( strncmp(&argv[argument_offset][2], "=", 1) == 0 ){
+ option = "default";
+ /* Since there is no option from user, the first argument
+ * becomes first file type */
+ index = 1; /* index of argument */
+ }
+ else{
+ option = "invalid";
+ printf("Invalid option '%s'\n", argv[argument_offset]);
+ argument_offset--;
+ if (strcmp(argv[0], "print") == 0){
+ lprintf (LOG_ERR, " ekanalyzer print [carrier/power/all]"
+ " <xx=frufile> <xx=frufile> [xx=frufile]"
+ );
+ }
+ else{
+ lprintf (LOG_ERR, " ekanalyzer summary [match/ unmatch/ all]"
+ " <xx=frufile> <xx=frufile> [xx=frufile]"
+ );
+ }
+ rc = ERROR_STATUS;
+ }
+ if ( strcmp(option, "invalid") != 0 ){
+ int i=0;
+
+ for ( i = 0; i < (argc-1); i++){
+ file_type[i] = ipmi_ek_get_file_type (argv[index]);
+ if ( file_type[i] == ERROR_STATUS ){
+ /* display the first 2 charactors (file type) of argument */
+ lprintf(LOG_ERR, "Invalid file type: %c%c\n", argv[index][0],
+ argv[index][1]);
+ ipmi_ekanalyzer_usage();
+ rc = ERROR_STATUS;
+ break;
+ }
+ /*size is equal to string size minus 3 bytes of file type plus
+ * 1 byte of '\0' since the strlen doesn't count the '\0'
+ */
+ filename_size = strlen_( argv[index] ) - SIZE_OF_FILE_TYPE + 1;
+ if ( filename_size > 0 ){
+ filename[i] = malloc( filename_size );
+ if (filename[i] != NULL)
+ strcpy( filename[i], &argv[index][SIZE_OF_FILE_TYPE] );
+ }
+ rc = OK_STATUS;
+ index++;
+ }
+ if ( rc != ERROR_STATUS ){
+ if (verbose > 0){
+ for (i = 0; i < (argc-1); i++){
+ printf ("Type: %s, ",
+ val2str((uint16_t)file_type[i],
+ ipmi_ekanalyzer_module_type));
+ printf("file name: %s\n", filename[i]);
+ }
+ }
+ if (strcmp(argv[0], "print") == 0){
+ rc = ipmi_ekanalyzer_print(
+ (argc-1), option, filename, file_type);
+ }
+ else{
+ rc = ipmi_ekanalyzer_ekeying_match(
+ (argc-1), option, filename, file_type);
+ }
+ for (i = 0; i < (argc-1); i++){
+ if (filename[i] != NULL){
+ free (filename[i]);
+ }
+ }
+ } /* End of ERROR_STATUS */
+ } /* End of comparison of invalid option */
+ } /* End of else MIN_ARGUMENT */
+ } /* End of print or summary option */
+ else{
+ lprintf(LOG_ERR, "Invalid ekanalyzer command: %s", argv[0]);
+ ipmi_ekanalyzer_usage();
+ rc = ERROR_STATUS;
+ }
+
+ return rc;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ekanalyzer_print
+*
+* Description: this function will display the topology, power or both
+* information together according to the option that it received.
+*
+* Restriction: None
+*
+* Input: int argc: number of the argument received
+* char* opt: option string that will tell what to display
+* char** filename: strings that contained filename of FRU data binary file
+* int* file_type: a pointer that contain file type (on carrier file,
+* a1 file, b1 file...). See structure
+* ipmi_ekanalyzer_module_type for a list of valid type
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 as success and -1 as error.
+*
+***************************************************************************/
+static int
+ipmi_ekanalyzer_print( int argc,char * opt, char ** filename, int * file_type )
+{
+ int return_value = OK_STATUS;
+
+ /*Display carrier topology*/
+ if ( (strcmp(opt, "carrier") == 0) || (strcmp(opt, "default") == 0) ){
+ tboolean found_flag = FALSE;
+ int index = 0;
+ int index_name[MAX_ARGC];
+ int list = 0;
+ /*list of multi record*/
+ struct ipmi_ek_multi_header * list_head[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_record[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_last[MAX_ARGC];
+
+ for ( list=0; list < argc; list++ ){
+ list_head[list] = NULL;
+ list_record[list] = NULL;
+ list_last[list] = NULL;
+ }
+
+ list=0; /* reset list count */
+ for ( index = 0; index < argc; index++ ){
+ if ( file_type[index] == ON_CARRIER_FRU_FILE ){
+ index_name[list] = index;
+ return_value = ipmi_ekanalyzer_fru_file2structure( filename[index],
+ &list_head[list], &list_record[list], &list_last[list] );
+ list++;
+ found_flag = TRUE;
+ }
+ }
+ if ( !found_flag ){
+ printf("No carrier file has been found\n");
+ return_value = ERROR_STATUS;
+ }
+ else{
+ int i = 0;
+ for ( i = 0; i < argc; i++ ){
+ /*this is a flag to advoid displaying the same data multiple time*/
+ tboolean first_data = TRUE;
+ for ( list_record[i] = list_head[i];
+ list_record[i] != NULL;
+ list_record[i] = list_record[i]->next ){
+ if ( list_record[i]->data[PICMG_ID_OFFSET]
+ ==
+ FRU_AMC_CARRIER_P2P ){
+ if ( first_data ){
+ printf("%s\n", STAR_LINE_LIMITER);
+ printf("From Carrier file: %s\n", filename[index_name[i]]);
+ first_data = FALSE;
+ }
+ return_value = ipmi_ek_diplay_carrier_connectivity(
+ list_record[i] );
+ }
+ else if ( list_record[i]->data[PICMG_ID_OFFSET]
+ ==
+ FRU_AMC_CARRIER_INFO ){
+ /*See AMC.0 specification Table3-3 for mor detail*/
+ #define COUNT_OFFSET 6
+ if ( first_data ){
+ printf("From Carrier file: %s\n", filename[index_name[i]]);
+ first_data = FALSE;
+ }
+ printf(" Number of AMC bays supported by Carrier: %d\n",
+ list_record[i]->data[COUNT_OFFSET] );
+ }
+ }
+ }
+ /*Destroy the list of record*/
+ for ( i = 0; i < argc; i++ ){
+ while ( list_head[i] != NULL ){
+ ipmi_ek_remove_record_from_list( list_head[i],
+ &list_head[i], &list_last[i] );
+ }
+ /* display deleted result when we reach the last record */
+ if ( ( i == (list-1) ) && verbose )
+ printf("Record list has been removed successfully\n");
+ }
+ }
+ }
+ else if ( (strcmp(opt, "power") == 0) ){
+ printf("Print power information\n");
+ return_value = ipmi_ek_display_power(argc, opt, filename, file_type);
+ }
+ else if ( strcmp(opt, "all") == 0 ){
+ printf("Print all information\n");
+ return_value = ipmi_ek_display_power(argc, opt, filename, file_type);
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid option %s", opt);
+ return_value = ERROR_STATUS;
+ }
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_carrier_connectivity
+*
+* Description: Display the topology between a Carrier and all AMC modules by
+* using carrier p2p connectivity record
+*
+* Restriction: Ref: AMC.0 Specification: Table 3-13 and Table 3-14
+*
+* Input: struct ipmi_ek_multi_header* record: a pointer to the carrier p2p
+* connectivity record.
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 on success and -1 if the record doesn't exist.
+*
+***************************************************************************/
+static int
+ipmi_ek_diplay_carrier_connectivity( struct ipmi_ek_multi_header * record )
+{
+ int return_value = ERROR_STATUS;
+ struct fru_picmgext_carrier_p2p_record rsc_desc;
+ struct fru_picmgext_carrier_p2p_descriptor port_desc;
+
+ if ( record == NULL ){
+ lprintf(LOG_ERR, "P2P connectivity record is invalid\n");
+ return_value = ERROR_STATUS;
+ }
+ else{
+ int offset = START_DATA_OFFSET;
+ if ( verbose > 1 ){
+ int k = 0;
+ printf("Binary data of Carrier p2p connectivity"\
+ " record starting from mfg id\n");
+ for ( k = 0; k < ( record->header.len ); k++ ){
+ printf("%02x ", record->data[k]);
+ }
+ printf("\n");
+ }
+ while ( offset <= (record->header.len - START_DATA_OFFSET) ){
+ rsc_desc.resource_id = record->data[offset++];
+ rsc_desc.p2p_count = record->data[offset++];
+ if ( verbose > 0 ){
+ printf("resource id= %02x port count= %d\n",
+ rsc_desc.resource_id,rsc_desc.p2p_count);
+ }
+ /*check if it is an AMC Module*/
+ if ( ( (rsc_desc.resource_id & AMC_MODULE) ) == AMC_MODULE ) {
+ /*check if it is an RTM module*/
+ if (rsc_desc.resource_id == AMC_MODULE) {
+ printf(" %s topology:\n", val2str( RTM_IPMB_L,
+ ipmi_ekanalyzer_IPMBL_addr));
+ }
+ else{
+ /*The last four bits of resource ID represent site number
+ * (mask = 0x0f)
+ */
+ printf(" %s topology:\n",
+ val2str( (rsc_desc.resource_id & 0x0f),
+ ipmi_ekanalyzer_module_type));
+ }
+ }
+ else{
+ printf(" On Carrier Device ID %d topology: \n",
+ (rsc_desc.resource_id & 0x0f));
+ }
+ while ( rsc_desc.p2p_count > 0 ){
+ memcpy ( &port_desc, &record->data[offset],
+ sizeof ( struct fru_picmgext_carrier_p2p_descriptor ) );
+ offset += sizeof ( struct fru_picmgext_carrier_p2p_descriptor );
+ if ( (port_desc.remote_resource_id & AMC_MODULE) == AMC_MODULE ){
+ printf("\tPort %d =====> %s, Port %d\n", port_desc.local_port,
+ val2str( (port_desc.remote_resource_id & 0x0f),
+ ipmi_ekanalyzer_module_type), port_desc.remote_port );
+ }
+ else{
+ printf("\tPort %d =====> On Carrier Device ID %d, Port %d\n",
+ port_desc.local_port,(port_desc.remote_resource_id & 0x0f),
+ port_desc.remote_port );
+ }
+ rsc_desc.p2p_count--;
+ }
+ }
+ return_value = OK_STATUS;
+ }
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_power
+*
+* Description: Display the power management of the Carrier and AMC module by
+* using current management record. If the display option equal to all,
+* it will display power and carrier topology together.
+*
+* Restriction: Reference: AMC.0 Specification, Table 3-11
+*
+* Input: int argc: number of the argument received
+* char* opt: option string that will tell what to display
+* char** filename: strings that contained filename of FRU data binary file
+* int* file_type: a pointer that contain file type (on carrier file,
+* a1 file, b1 file...)
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 on success and -1 if the record doesn't exist.
+*
+***************************************************************************/
+static int
+ipmi_ek_display_power(int argc, char * opt, char ** filename, int * file_type)
+{
+ int num_file=0;
+ int return_value = ERROR_STATUS;
+ int index = 0;
+
+ /*list des multi record*/
+ struct ipmi_ek_multi_header * list_head[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_record[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_last[MAX_ARGC];
+
+ for ( num_file = 0; num_file < argc; num_file++ ){
+ list_head[num_file] = NULL;
+ list_record[num_file] = NULL;
+ list_last[num_file] = NULL;
+ }
+
+ for ( num_file = 0; num_file < argc; num_file++ ){
+ tboolean is_first_data = TRUE;
+ if ( file_type[num_file] == CONFIG_FILE ){
+ num_file++;
+ }
+
+ if ( is_first_data ){
+ printf("%s\n", STAR_LINE_LIMITER);
+ printf("\nFrom %s file '%s'\n",
+ val2str( (uint16_t)file_type[num_file],
+ ipmi_ekanalyzer_module_type),
+ filename[num_file]);
+ is_first_data = FALSE;
+ }
+
+ return_value = ipmi_ekanalyzer_fru_file2structure( filename[num_file],
+ &list_head[num_file], &list_record[num_file], &list_last[num_file]);
+
+ if ( list_head[num_file] != NULL ){
+ for ( list_record[num_file] = list_head[num_file];
+ list_record[num_file] != NULL;
+ list_record[num_file] = list_record[num_file]->next
+ ){
+ if ( ( strcmp(opt, "all") == 0 )
+ && ( file_type[num_file] == ON_CARRIER_FRU_FILE )
+ ){
+ if ( list_record[num_file]->data[PICMG_ID_OFFSET]
+ ==
+ FRU_AMC_CARRIER_P2P
+ ){
+ return_value = ipmi_ek_diplay_carrier_connectivity(
+ list_record[num_file] );
+ }
+ else if ( list_record[num_file]->data[PICMG_ID_OFFSET]
+ ==
+ FRU_AMC_CARRIER_INFO
+ ){
+ /*Ref: See AMC.0 Specification Table 3-3: Carrier Information
+ * Table about offset value
+ */
+ printf( " Number of AMC bays supported by Carrier: %d\n",
+ list_record[num_file]->data[START_DATA_OFFSET+1] );
+ }
+ }
+ /*Ref: AMC.0 Specification: Table 3-11
+ * Carrier Activation and Current Management Record
+ */
+ if ( list_record[num_file]->data[PICMG_ID_OFFSET]
+ ==
+ FRU_AMC_ACTIVATION
+ ){
+ int index_data = START_DATA_OFFSET;
+ struct fru_picmgext_carrier_activation_record car;
+ struct fru_picmgext_activation_record * cur_desc;
+
+ memcpy ( &car, &list_record[num_file]->data[index_data],
+ sizeof (struct fru_picmgext_carrier_activation_record) );
+ index_data +=
+ sizeof (struct fru_picmgext_carrier_activation_record);
+ cur_desc = malloc (car.module_activation_record_count * \
+ sizeof (struct fru_picmgext_activation_record) );
+ for(index=0; index<car.module_activation_record_count; index++){
+ memcpy( &cur_desc[index],
+ &list_record[num_file]->data[index_data],
+ sizeof (struct fru_picmgext_activation_record) );
+
+ index_data += sizeof (struct fru_picmgext_activation_record);
+ }
+ /*Display the current*/
+ ipmi_ek_display_current_descriptor( car,
+ cur_desc, filename[num_file] );
+ free (cur_desc);
+ }
+ /*Ref: AMC.0 specification, Table 3-10: Module Current Requirement*/
+ else if ( list_record[num_file]->data[PICMG_ID_OFFSET]
+ == FRU_AMC_CURRENT
+ ){
+ float power_in_watt = 0;
+ float current_in_amp = 0;
+
+ printf(" %s power required (Current Draw): ",
+ val2str ( (uint16_t)file_type[num_file], ipmi_ekanalyzer_module_type) );
+ current_in_amp =
+ (float)(list_record[num_file]->data[START_DATA_OFFSET]*0.1);
+ power_in_watt = current_in_amp * AMC_VOLTAGE;
+ printf("%.2f Watts (%.2f Amps)\n",power_in_watt, current_in_amp);
+ }
+ }
+ return_value = OK_STATUS;
+ /*Destroy the list of record*/
+ for ( index = 0; index < argc; index++ ){
+ while ( list_head[index] != NULL ){
+ ipmi_ek_remove_record_from_list ( list_head[index],
+ &list_head[index],&list_last[index] );
+ }
+ if ( verbose > 1 )
+ printf("Record list has been removed successfully\n");
+ }
+ }
+ }
+ printf("%s\n", STAR_LINE_LIMITER);
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_current_descriptor
+*
+* Description: Display the current descriptor under format xx Watts (xx Amps)
+*
+* Restriction: None
+*
+* Input: struct fru_picmgext_carrier_activation_record car: contain binary data
+* of carrier activation record
+* struct fru_picmgext_activation_record * cur_desc: contain current
+* descriptor
+* char* filename: strings that contained filename of FRU data binary file
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_current_descriptor(
+ struct fru_picmgext_carrier_activation_record car,
+ struct fru_picmgext_activation_record * cur_desc, char * filename )
+{
+ int index = 0;
+ float power_in_watt = 0.0;
+ float current_in_amp = 0.0;
+
+ for ( index = 0; index < car.module_activation_record_count; index++ ){
+ /*See AMC.0 specification, Table 3-12 for detail about calculation*/
+ current_in_amp = (float)(cur_desc[index].max_module_curr * 0.1);
+ power_in_watt = (float) current_in_amp * AMC_VOLTAGE;
+
+ printf(" Carrier AMC power available on %s:\n",
+ val2str( cur_desc[index].ibmb_addr, ipmi_ekanalyzer_IPMBL_addr ) );
+ printf("\t- Local IPMB Address \t: %02x\n", cur_desc[index].ibmb_addr);
+ printf("\t- Maximum module Current\t: %.2f Watts (%.2f Amps)\n",
+ power_in_watt, current_in_amp );
+ }
+ /*Display total power on Carrier*/
+ current_in_amp = (float)(car.max_internal_curr * 0.1);
+ power_in_watt = (float) current_in_amp * AMC_VOLTAGE;
+ printf(" Carrier AMC total power available for all bays from file '%s':",
+ filename);
+ printf(" %.2f Watts (%.2f Amps)\n", power_in_watt, current_in_amp );
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ekanalyzer_ekeying_match
+*
+* Description: Check for possible Ekeying match between two FRU files
+*
+* Restriction: None
+*
+* Input: argc: number of the argument received
+* opt: string that contains display option received from user.
+* filename: strings that contained filename of FRU data binary file
+* file_type: a pointer that contain file type (on carrier file,
+* a1 file, b1 file...)
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return TRUE on success and FALSE if the record doesn't exist.
+*
+***************************************************************************/
+static tboolean
+ipmi_ekanalyzer_ekeying_match( int argc, char * opt,
+ char ** filename, int * file_type )
+{
+ tboolean return_value = FALSE;
+
+ if ( (strcmp(opt, "carrier") == 0 ) || (strcmp(opt, "power") == 0) ){
+ lprintf(LOG_ERR, " ekanalyzer summary [match/ unmatch/ all]"\
+ " <xx=frufile> <xx=frufile> [xx=frufile]");
+ return_value = ERROR_STATUS;
+ }
+ else{
+ int num_file=0;
+ // int index_data = 0;
+ // int first_data = 1;
+ tboolean amc_file = FALSE; /*used to indicate the present of AMC file*/
+ tboolean oc_file = FALSE; /*used to indicate the present of Carrier file*/
+
+ /*Check for possible ekeying match between files*/
+ for ( num_file=0; num_file < argc; num_file++ ){
+ if ( ( file_type[num_file] == ON_CARRIER_FRU_FILE )
+ || ( file_type[num_file] == CONFIG_FILE )
+ || ( file_type[num_file] == SHELF_MANAGER_FRU_FILE )
+ ){
+ amc_file = FALSE;
+ }
+ else { /*there is an amc file*/
+ amc_file = TRUE;
+ break;
+ }
+ }
+ if ( amc_file == FALSE ){
+ printf("\nNo AMC FRU file is provided --->" \
+ " No possible ekeying match!\n");
+ return_value = ERROR_STATUS;
+ }
+ else{
+ /*If no carrier file is provided, return error*/
+ for ( num_file=0; num_file < argc; num_file++ ){
+ if ( (file_type[num_file] == ON_CARRIER_FRU_FILE )
+ || ( file_type[num_file] == CONFIG_FILE )
+ || ( file_type[num_file] == SHELF_MANAGER_FRU_FILE )
+ ){
+ oc_file = TRUE;
+ break;
+ }
+ }
+ if ( !oc_file ){
+ printf("\nNo Carrier FRU file is provided" \
+ " ---> No possible ekeying match!\n");
+ return_value = ERROR_STATUS;
+ }
+ else{
+ /*list des multi record*/
+ struct ipmi_ek_multi_header * list_head[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_record[MAX_ARGC];
+ struct ipmi_ek_multi_header * list_last[MAX_ARGC];
+ struct ipmi_ek_multi_header * pcarrier_p2p = NULL;
+ int list = 0;
+ int match_pair = 0;
+ // tboolean match_result = FALSE;
+
+ /*Create an empty list*/
+ for ( list=0; list<argc; list++ ){
+ list_head[list] = NULL;
+ list_record[list] = NULL;
+ list_last[list] = NULL;
+ }
+ list=0;
+
+ for ( num_file=0; num_file < argc; num_file++ ){
+ if (file_type[num_file] != CONFIG_FILE){
+ return_value = ipmi_ekanalyzer_fru_file2structure(
+ filename[num_file], &list_head[num_file],
+ &list_record[num_file], &list_last[num_file]);
+ }
+ }
+ /*Get Carrier p2p connectivity record for physical check*/
+ for (num_file=0; num_file < argc; num_file++){
+ if (file_type[num_file] == ON_CARRIER_FRU_FILE ){
+ for ( pcarrier_p2p=list_head[num_file];
+ pcarrier_p2p != NULL ;
+ pcarrier_p2p = pcarrier_p2p->next
+ ){
+ if ( pcarrier_p2p->data[PICMG_ID_OFFSET]
+ == FRU_AMC_CARRIER_P2P
+ ){
+ break;
+ }
+ }
+ break;
+ }
+ }
+ /*Determine the match making pair*/
+ while ( match_pair < argc ){
+ for ( num_file = (match_pair+1); num_file<argc; num_file++ ){
+ if ( ( file_type[match_pair] != CONFIG_FILE )
+ && ( file_type[num_file] != CONFIG_FILE )
+ ){
+ if ( ( file_type[match_pair] != ON_CARRIER_FRU_FILE )
+ || ( file_type[num_file] != ON_CARRIER_FRU_FILE )
+ ){
+ printf("%s vs %s\n",
+ val2str((uint16_t)file_type[match_pair],
+ ipmi_ekanalyzer_module_type),
+ val2str((uint16_t)file_type[num_file],
+ ipmi_ekanalyzer_module_type));
+ /*Ekeying match between 2 files*/
+ if (verbose>0){
+ printf("Start matching process\n");
+ }
+ return_value = ipmi_ek_matching_process( file_type,
+ match_pair, num_file, list_head,
+ list_last, opt, pcarrier_p2p);
+ }
+ }
+ }
+ match_pair ++;
+ }
+ for( num_file=0; num_file < argc; num_file++ ){
+ if (list_head[num_file] != NULL ){
+ ipmi_ek_remove_record_from_list( list_head[num_file],
+ &list_record[num_file], &list_last[num_file]);
+ }
+ if ( ( num_file == argc-1 ) && verbose )
+ printf("Record list has been removed successfully\n");
+ }
+ return_value = OK_STATUS;
+ }
+ }
+ }
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_matching_process
+*
+* Description: This function process the OEM check, Physical Connectivity check,
+* and Link Descriptor comparison to do Ekeying match
+*
+* Restriction: None
+*
+* Input: file_type: a pointer that contain file type (on carrier file,
+* a1 file, b1 file...)
+* index1: position of the first record in the list of the record
+* index2: position of the second record in the list of the record
+* ipmi_ek_multi_header ** list_head: pointer to the header of a
+* linked list that contain FRU multi record
+* ipmi_ek_multi_header ** list_last: pointer to the tale of a
+* linked list that contain FRU multi record
+* opt: string that contain display option such as "match", "unmatch", or
+* "all".
+* pphysical: a pointer that contain a carrier p2p connectivity record
+* to perform physical check
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return OK_STATUS on success and ERROR_STATUS if the record doesn't
+* exist.
+*
+***************************************************************************/
+static int ipmi_ek_matching_process( int * file_type, int index1, int index2,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last, char * opt,
+ struct ipmi_ek_multi_header * pphysical )
+{
+ int result = ERROR_STATUS;
+ struct ipmi_ek_multi_header * record;
+ int num_amc_record1 = 0;/*Number of AMC records in the first module*/
+ int num_amc_record2 = 0;/*Number of AMC records in the second module*/
+
+ /* Comparison between an On-Carrier and an AMC*/
+ if ( file_type[index2] == ON_CARRIER_FRU_FILE ){
+ int index_temp = 0;
+ index_temp = index1;
+ index1 = index2; /*index1 indicate on carrier*/
+ index2 = index_temp; /*index2 indcate an AMC*/
+ }
+ /*Calculate record size for Carrier file*/
+ for ( record=list_head[index1]; record != NULL;record = record->next ){
+ if ( record->data[PICMG_ID_OFFSET] == FRU_AMC_P2P ){
+ num_amc_record2++;
+ }
+ }
+ /*Calculate record size for amc file*/
+ for ( record=list_head[index2]; record != NULL;record = record->next){
+ if ( record->data[PICMG_ID_OFFSET] == FRU_AMC_P2P ){
+ num_amc_record1++;
+ }
+ }
+ if ( (num_amc_record1 > 0) && (num_amc_record2 > 0) ){
+ int index_record1 = 0;
+ int index_record2 = 0;
+ /* Multi records of AMC module */
+ struct ipmi_ek_amc_p2p_connectivity_record * amc_record1 = NULL;
+ /* Multi records of Carrier or an AMC module */
+ struct ipmi_ek_amc_p2p_connectivity_record * amc_record2 = NULL;
+
+ amc_record1 = malloc ( num_amc_record1 * \
+ sizeof(struct ipmi_ek_amc_p2p_connectivity_record));
+ amc_record2 = malloc ( num_amc_record2 * \
+ sizeof(struct ipmi_ek_amc_p2p_connectivity_record));
+
+ for (record=list_head[index2]; record != NULL;record = record->next){
+ if ( record->data[PICMG_ID_OFFSET] == FRU_AMC_P2P ){
+ result = ipmi_ek_create_amc_p2p_record( record,
+ &amc_record1[index_record1] );
+ if (result != ERROR_STATUS){
+ struct ipmi_ek_multi_header * current_record = NULL;
+
+ for ( current_record=list_head[index1];
+ current_record != NULL ;
+ current_record = current_record->next
+ ){
+ if ( current_record->data[PICMG_ID_OFFSET] == FRU_AMC_P2P ){
+ result = ipmi_ek_create_amc_p2p_record( current_record,
+ &amc_record2[index_record2] );
+ if ( result != ERROR_STATUS ){
+ if ( result == OK_STATUS ){
+ /*Compare Link descriptor*/
+ result = ipmi_ek_compare_link ( pphysical,
+ amc_record1[index_record1],
+ amc_record2[index_record2],
+ opt, file_type[index1], file_type[index2]);
+ }
+ index_record2++;
+ }
+ } /*end of FRU_AMC_P2P */
+ } /* end of for loop */
+ index_record1++;
+ }
+ }
+ }
+ free(amc_record1) ;
+ free(amc_record2) ;
+ }
+ else{
+ printf("No amc record is found!\n");
+ }
+
+ return result;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_check_physical_connectivity
+*
+* Description: This function check for point to point connectivity between
+* two modules by comparing each enable port in link descriptor
+* with local and remote ports of port descriptor in
+* carrier point-to-point connectivity record according to the
+* corresponding file type ( a1, b1, b2...).
+*
+* Restriction: In order to perform physical check connectivity, it needs to
+* compare between 2 AMC Modules, so the use of index ( 1 and 2 )
+* can facilitate the comparison in this case.
+*
+* Input: record1: is an AMC p2p record for an AMC module
+* record2 is an AMC p2p record for an On-Carrier record or an AMC module
+* char* opt: option string that will tell if a matching result, unmatched
+* result or all the results will be displayed.
+* file_type1: indicates type of the first module
+* file_type2: indicates type of the second module
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return OK_STATUS if both link are matched, otherwise
+* return ERROR_STATUS
+*
+***************************************************************************/
+static int
+ipmi_ek_check_physical_connectivity(
+ struct ipmi_ek_amc_p2p_connectivity_record record1, int index1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2, int index2,
+ struct ipmi_ek_multi_header * record,
+ int filetype1, int filetype2, char * option )
+{
+ int return_status = OK_STATUS;
+
+ if ( record == NULL ){
+ printf("NO Carrier p2p connectivity !\n");
+ return_status = ERROR_STATUS;
+ }
+ else{
+ #define INVALID_AMC_SITE_NUMBER -1
+ int index = START_DATA_OFFSET;
+ int amc_site = INVALID_AMC_SITE_NUMBER;
+ struct fru_picmgext_carrier_p2p_record rsc_desc;
+ struct fru_picmgext_carrier_p2p_descriptor * port_desc = NULL;
+
+ /* Get the physical connectivity record */
+ while ( index < record->header.len ) {
+ rsc_desc.resource_id = record->data[index++];
+ rsc_desc.p2p_count = record->data[index++];
+ /* carrier p2p record starts with on-carrier device */
+ if ( (rsc_desc.resource_id == record1.rsc_id)
+ ||
+ (rsc_desc.resource_id == record2.rsc_id)
+ ){
+ if (rsc_desc.p2p_count <= 0){
+ printf("No p2p count\n");
+ return_status = ERROR_STATUS;
+ }
+ else{
+ port_desc = malloc ( rsc_desc.p2p_count *
+ sizeof(struct fru_picmgext_carrier_p2p_descriptor) );
+ index = ipmi_ek_get_resource_descriptor( rsc_desc.p2p_count,
+ index, port_desc, record );
+ amc_site = INVALID_AMC_SITE_NUMBER;
+ break;
+ }
+ }
+ else{ /* carrier p2p record starts with AMC module */
+ if (rsc_desc.resource_id == AMC_MODULE){
+ if (filetype1 != ON_CARRIER_FRU_FILE){
+ amc_site = filetype1;
+ }
+ else{
+ amc_site = filetype2;
+ }
+ }
+ else{
+ amc_site = rsc_desc.resource_id & 0x0f;
+ }
+ if ( amc_site > 0 ){
+ if ( (amc_site == filetype1) || (amc_site == filetype2) ){
+ port_desc = malloc ( rsc_desc.p2p_count *
+ sizeof(struct fru_picmgext_carrier_p2p_descriptor) );
+ index = ipmi_ek_get_resource_descriptor( rsc_desc.p2p_count,
+ index, port_desc, record );
+ break;
+ }
+ }
+ else{
+ return_status = ERROR_STATUS;
+ }
+ }
+ /*If the record doesn't contain the same AMC site number in command
+ * line, go to the next record
+ */
+ index += ( sizeof(struct fru_picmgext_carrier_p2p_descriptor) *
+ rsc_desc.p2p_count );
+ }
+
+ if ( (port_desc != NULL) && (return_status != ERROR_STATUS) ){
+ int j=0;
+
+ for ( j = 0; j < rsc_desc.p2p_count; j++ ){
+ /* Compare only enable channel descriptor */
+ if ( record1.ch_desc[index1].lane0port != DISABLE_PORT ){
+ /* matching result from channel descriptor comparison */
+ tboolean match_lane = FALSE;
+
+ match_lane = ipmi_ek_compare_channel_descriptor (
+ record1.ch_desc[index1], record2.ch_desc[index2],
+ port_desc, j, rsc_desc.resource_id );
+
+ if ( match_lane ){
+ if ( filetype1 != ON_CARRIER_FRU_FILE ){
+ if ( (
+ (filetype1 == (rsc_desc.resource_id & 0x0f))
+ &&
+ (filetype2 ==(port_desc[j].remote_resource_id &0x0f))
+ )
+ ||
+ (
+ (filetype2 == (rsc_desc.resource_id & 0x0f))
+ &&
+ (filetype1 ==(port_desc[j].remote_resource_id &0x0f))
+ )
+ ){
+ if ( ! (strcmp(option, "unmatch") == 0) ){
+ printf("%s port %d ==> %s port %d\n",
+ val2str((uint16_t)filetype2, ipmi_ekanalyzer_module_type),
+ record1.ch_desc[index1].lane0port,
+ val2str((uint16_t)filetype1, ipmi_ekanalyzer_module_type),
+ record2.ch_desc[index2].lane0port);
+ }
+ return_status = OK_STATUS;
+
+ break;
+ }
+ else{
+ if (verbose >= 2){ //was == LOG_DEBUG)
+ printf("No point 2 point connectivity\n");
+ }
+ return_status = ERROR_STATUS;
+ }
+ }
+ else{
+ if ( (record2.rsc_id == (rsc_desc.resource_id) )
+ &&
+ (filetype2 == (port_desc[j].remote_resource_id & 0x0f))
+ ){
+ if ( ! (strcmp(option, "unmatch") == 0) ){
+ printf("%s port %d ==> %s port %d\n",
+ val2str((uint16_t)filetype2, ipmi_ekanalyzer_module_type),
+ record1.ch_desc[index1].lane0port,
+ val2str((uint16_t)filetype1, ipmi_ekanalyzer_module_type),
+ record2.ch_desc[index2].lane0port);
+ }
+ return_status = OK_STATUS;
+ break;
+ }
+ else if ( (filetype2 == (rsc_desc.resource_id & 0x0f) )
+ &&
+ (record2.rsc_id == (port_desc[j].remote_resource_id))
+ ){
+ if ( ! (strcmp(option, "unmatch") == 0) ){
+ printf("%s port %d ==> %s %x port %d\n",
+ val2str((uint16_t)filetype2, ipmi_ekanalyzer_module_type),
+ record1.ch_desc[index1].lane0port,
+ val2str((uint16_t)filetype1, ipmi_ekanalyzer_module_type),
+ record2.rsc_id,record2.ch_desc[index2].lane0port);
+ }
+ return_status = OK_STATUS;
+ break;
+ }
+ else{
+ if (verbose >= 2){ //was == LOG_DEBUG
+ printf("No point 2 point connectivity\n");
+ }
+ return_status = ERROR_STATUS;
+ }
+ }
+ }
+ else{
+ if (verbose >= 2){ //was == LOG_DEBUG
+ printf("No point 2 point connectivity\n");
+ }
+ return_status = ERROR_STATUS;
+ }
+ }
+ else{ /*If the link is disable, the result is always true*/
+ return_status = OK_STATUS;
+ }
+ }
+ }
+ else{
+ if (verbose >= 2) { //was == LOG_WARN
+ printf("Invalid Carrier p2p connectivity record\n");
+ }
+ return_status = ERROR_STATUS;
+ }
+ if (port_desc != NULL){
+ free (port_desc);
+ }
+ }
+ return return_status;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_compare_link
+*
+* Description: This function compares link grouping id of each
+* amc p2p connectiviy record
+*
+* Restriction: None
+*
+* Input: record1: is an AMC p2p record for an AMC module
+* record2 is an AMC p2p record for an On-Carrier record or an AMC module
+* char* opt: option string that will tell if a matching result, unmatched
+* result or all the results will be displayed.
+* file_type1: indicates type of the first module
+* file_type2: indicates type of the second module
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 if both link are matched, otherwise return -1
+*
+***************************************************************************/
+static int
+ipmi_ek_compare_link( struct ipmi_ek_multi_header * physic_record,
+ struct ipmi_ek_amc_p2p_connectivity_record record1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2, char * opt,
+ int file_type1, int file_type2 )
+{
+ int result = ERROR_STATUS;
+ int index1 = 0; /*index for AMC module*/
+ int index2 = 0; /*index for On-carrier type*/
+
+ record1.matching_result = malloc ( record1.link_desc_count * sizeof(int) );
+ record2.matching_result = malloc ( record2.link_desc_count * sizeof(int) );
+ /*Initialize all the matching_result to false*/
+ for( index2 = 0; index2 < record2.link_desc_count; index2++ ){
+ record2.matching_result[index2] = FALSE;
+ }
+ for( index1 = 0; index1 < record1.link_desc_count; index1++ ){
+ for( index2 = 0; index2 < record2.link_desc_count; index2++ ){
+ if( record1.link_desc[index1].group_id == 0 ){
+ if( record2.link_desc[index2].group_id == 0 ){
+ result = ipmi_ek_compare_link_descriptor(
+ record1, index1, record2, index2 );
+ if ( result == OK_STATUS ){
+ /*Calculate the index for Channel descriptor in function of
+ * link designator channel ID
+ */
+ /*first channel_id in the AMC Link descriptor of record1*/
+ static int flag_first_link1;
+ int index_ch_desc1; /*index of channel descriptor */
+ /*first channel_id in the AMC Link descriptor of record2*/
+ static int flag_first_link2;
+ int index_ch_desc2; /*index of channel descriptor*/
+
+ if (index1==0){ /*this indicate the first link is encounter*/
+ flag_first_link1 = record1.link_desc[index1].channel_id;
+ }
+ index_ch_desc1 = record1.link_desc[index1].channel_id -
+ flag_first_link1;
+ if (index2==0){
+ flag_first_link2 = record2.link_desc[index2].channel_id;
+ }
+ index_ch_desc2 = record2.link_desc[index2].channel_id -
+ flag_first_link2;
+ /*Check for physical connectivity for each link*/
+ result = ipmi_ek_check_physical_connectivity ( record1,
+ index_ch_desc1, record2, index_ch_desc2,
+ physic_record, file_type1, file_type2, opt );
+ if ( result == OK_STATUS ){
+ /*Display the result if option = match or all*/
+ if ( (strcmp( opt, "match" ) == 0)
+ || (strcmp( opt, "all" ) == 0)
+ || (strcmp( opt, "default" ) == 0)
+ ){
+ tboolean isOEMtype = FALSE;
+ printf(" Matching Result\n");
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type1,
+ record2.rsc_id,
+ "From", record2.link_desc[index2]);
+ if (isOEMtype){
+ ipmi_ek_display_oem_guid (record2);
+ }
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type2,
+ record1.rsc_id,
+ "To", record1.link_desc[index1] );
+ if (isOEMtype){
+ ipmi_ek_display_oem_guid (record1);
+ }
+ printf(" %s\n", STAR_LINE_LIMITER);
+ }
+ record2.matching_result[index2] = TRUE;
+ record1.matching_result[index1] = TRUE;
+ /*quit the fist loop since the match is found*/
+ index2 = record2.link_desc_count;
+ }
+ }
+ }
+ }
+ else { /*Link Grouping ID is non zero, Compare all link descriptor
+ * that has non-zero link grouping id together
+ */
+ if (record2.link_desc[index2].group_id != 0 ){
+ result = ipmi_ek_compare_link_descriptor(
+ record1, index1, record2, index2 );
+ if ( result == OK_STATUS ){
+ /*Calculate the index for Channel descriptor in function of
+ * link designator channel ID
+ */
+ /*first channel_id in the AMC Link descriptor of record1*/
+ static int flag_first_link1;
+ int index_ch_desc1; /*index of channel descriptor */
+ /*first channel_id in the AMC Link descriptor of record2*/
+ static int flag_first_link2;
+ int index_ch_desc2; /*index of channel descriptor*/
+
+ if (index1==0){ /*this indicate the first link is encounter*/
+ flag_first_link1 = record1.link_desc[index1].channel_id;
+ }
+ index_ch_desc1 = record1.link_desc[index1].channel_id -
+ flag_first_link1;
+ if (index2==0){
+ flag_first_link2 = record2.link_desc[index2].channel_id;
+ }
+ index_ch_desc2 = record2.link_desc[index2].channel_id -
+ flag_first_link2;
+ /*Check for physical connectivity for each link*/
+ result = ipmi_ek_check_physical_connectivity (
+ record1, index_ch_desc1, record2, index_ch_desc2,
+ physic_record, file_type1, file_type2, opt );
+ if ( result == OK_STATUS ){
+ if ( (strcmp( opt, "match" ) == 0)
+ || (strcmp( opt, "all" ) == 0)
+ || (strcmp( opt, "default" ) == 0)
+ ){
+ tboolean isOEMtype = FALSE;
+ printf(" Matching Result\n");
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type1,
+ record2.rsc_id,
+ "From", record2.link_desc[index2] );
+ if ( isOEMtype ){
+ ipmi_ek_display_oem_guid (record2);
+ }
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type2,
+ record1.rsc_id,
+ "To", record1.link_desc[index1] );
+ if (isOEMtype){
+ ipmi_ek_display_oem_guid (record1);
+ }
+ printf(" %s\n", STAR_LINE_LIMITER);
+ }
+ record2.matching_result[index2] = TRUE;
+ record1.matching_result[index1] = TRUE;
+ /*leave the fist loop since the match is found*/
+ index2 = record2.link_desc_count;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if ( (strcmp(opt, "unmatch") == 0) || (strcmp(opt, "all") == 0) ){
+ int isOEMtype = FALSE;
+ printf(" Unmatching result\n");
+ for (index1 = 0; index1 < record1.link_desc_count; index1++){
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type2,
+ record1.rsc_id, "", record1.link_desc[index1] );
+ if ( isOEMtype ){
+ ipmi_ek_display_oem_guid (record1);
+ }
+ printf(" %s\n", STAR_LINE_LIMITER);
+ }
+ for ( index2 = 0; index2 < record2.link_desc_count; index2++){
+ if ( !record2.matching_result[index2] ){
+ isOEMtype = ipmi_ek_display_link_descriptor( file_type1,
+ record2.rsc_id, "", record2.link_desc[index2] );
+ if ( isOEMtype ){
+ ipmi_ek_display_oem_guid (record2);
+ }
+ printf(" %s\n", STAR_LINE_LIMITER);
+ }
+ }
+ }
+
+ free (record1.matching_result);
+ free (record2.matching_result);
+
+ return result;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_compare_channel_descriptor
+*
+* Description: This function compares 2 channel descriptors of 2 AMC
+* point-to-point connectivity records with port descriptor of
+* carrier point-to-point connectivity record. The comparison is
+* made between each enable port only.
+*
+* Restriction: Reference: AMC.0 specification:
+* - Table 3-14 for port descriptor
+* - Table 3-17 for channel descriptor
+*
+* Input: ch_desc1: first channel descriptor
+* ch_desc2: second channel descriptor
+* port_desc: a pointer that contain a list of port descriptor
+* index_port: index of the port descriptor
+* rsc_id: resource id that represents as local resource id in the
+* resource descriptor table.
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return TRUE if both channel descriptor are matched,
+* or FALSE otherwise
+*
+***************************************************************************/
+static tboolean
+ipmi_ek_compare_channel_descriptor(
+ struct fru_picmgext_amc_channel_desc_record ch_desc1,
+ struct fru_picmgext_amc_channel_desc_record ch_desc2,
+ struct fru_picmgext_carrier_p2p_descriptor * port_desc,
+ int index_port, unsigned char rsc_id )
+{
+ tboolean match_lane = FALSE;
+
+ /* carrier p2p record start with AMC_MODULE as local port */
+ if ( (rsc_id & AMC_MODULE) == AMC_MODULE ){
+ if ( (ch_desc1.lane0port == port_desc[index_port].local_port)
+ &&
+ (ch_desc2.lane0port == port_desc[index_port].remote_port)
+ ){
+ /*check if the port is enable*/
+ if (ch_desc1.lane1port != DISABLE_PORT){
+ index_port ++;
+ if ( (ch_desc1.lane1port == port_desc[index_port].local_port)
+ &&
+ (ch_desc2.lane1port == port_desc[index_port].remote_port)
+ ){
+ if (ch_desc1.lane2port != DISABLE_PORT){
+ index_port++;
+ if ( (ch_desc1.lane2port == port_desc[index_port].local_port)
+ &&
+ (ch_desc2.lane2port == port_desc[index_port].remote_port)
+ ){
+ if (ch_desc1.lane3port != DISABLE_PORT){
+ index_port++;
+ if ( (ch_desc1.lane3port ==
+ port_desc[index_port].local_port)
+ &&
+ (ch_desc2.lane3port ==
+ port_desc[index_port].remote_port)
+ ){
+ match_lane = TRUE;
+ }
+ }
+ else{
+ match_lane = TRUE;
+ }
+ } /* end of if lane2port */
+ }
+ else{
+ match_lane = TRUE;
+ }
+ } /* end of if lane1port */
+ }
+ else{ /*if the port is disable, the compare result is always true*/
+ match_lane = TRUE;
+ }
+ }/* end of if lane0port */
+ }
+ /* carrier p2p record start with Carrier as local port */
+ else{
+ if ( (ch_desc1.lane0port == port_desc[index_port].remote_port)
+ &&
+ (ch_desc2.lane0port == port_desc[index_port].local_port)
+ ){
+ if (ch_desc1.lane1port != DISABLE_PORT){
+ index_port ++;
+ if ( (ch_desc1.lane1port == port_desc[index_port].remote_port)
+ &&
+ (ch_desc2.lane1port == port_desc[index_port].local_port)
+ ){
+ if (ch_desc1.lane2port != DISABLE_PORT){
+ index_port++;
+ if ( (ch_desc1.lane2port == port_desc[index_port].remote_port)
+ &&
+ (ch_desc2.lane2port == port_desc[index_port].local_port)
+ ){
+ if (ch_desc1.lane3port != DISABLE_PORT){
+ index_port++;
+ if ( (ch_desc1.lane3port ==
+ port_desc[index_port].remote_port)
+ &&
+ (ch_desc2.lane3port ==
+ port_desc[index_port].local_port)
+ ){
+ match_lane = TRUE;
+ }
+ }
+ else{
+ match_lane = TRUE;
+ }
+ } /* end of if lane2port */
+ }
+ else{
+ match_lane = TRUE;
+ }
+ } /* end of if lane1port */
+ }
+ else{
+ match_lane = TRUE;
+ }
+ } /* end of if lane0port */
+ }
+
+ return match_lane;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_compare_link_descriptor
+*
+* Description: This function compares 2 link descriptors of 2
+* amc p2p connectiviy record
+*
+* Restriction: None
+*
+* Input: record1: AMC p2p connectivity record of the 1rst AMC or Carrier Module
+* index1: index of AMC link descriptor in 1rst record
+* record2: AMC p2p connectivity record of the 2nd AMC or Carrier Module
+* index1: index of AMC link descriptor in 2nd record
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return OK_STATUS if both link are matched,
+* otherwise return ERROR_STATUS
+*
+***************************************************************************/
+static int
+ipmi_ek_compare_link_descriptor(
+ struct ipmi_ek_amc_p2p_connectivity_record record1, int index1,
+ struct ipmi_ek_amc_p2p_connectivity_record record2, int index2 )
+{
+ int result = ERROR_STATUS;
+
+ if (record1.link_desc[index1].type == record2.link_desc[index2].type){
+ /*if it is an OEM type, we compare the OEM GUID*/
+ if ( (record1.link_desc[index1].type >= LOWER_OEM_TYPE)
+ && (record1.link_desc[index1].type <= UPPER_OEM_TYPE)
+ ){
+ if ( (record1.guid_count == 0) && (record2.guid_count == 0) ){
+ /*there is no GUID for comparison, so the result is always OK*/
+ result = OK_STATUS;
+ }
+ else{
+ int i=0;
+ int j=0;
+
+ for( i=0; i<record1.guid_count; i++){
+ for( j=0; j < record2.guid_count; j++){
+ if( memcmp (&record1.oem_guid[i], &record2.oem_guid[j],
+ SIZE_OF_GUID )
+ == 0
+ ){
+ result = OK_STATUS;
+ break;
+ }
+ }
+ }
+ }
+ }
+ else{
+ result = OK_STATUS;
+ }
+ if (result == OK_STATUS){
+ if (record1.link_desc[index1].type_ext
+ == record2.link_desc[index2].type_ext
+ ){
+ unsigned char asym[COMPARE_CANDIDATE];
+ int offset = 0;
+
+ asym[offset++] = record1.link_desc[index1].asym_match;
+ asym[offset] = record2.link_desc[index2].asym_match;
+ result = ipmi_ek_compare_asym ( asym );
+ if (result == OK_STATUS){
+ struct fru_picmgext_amc_link_desc_record link[COMPARE_CANDIDATE];
+ int index = 0;
+
+ link[index++] = record1.link_desc[index1];
+ link[index] = record2.link_desc[index2];
+ result = ipmi_ek_compare_number_of_enable_port( link );
+ }
+ else{
+ result = ERROR_STATUS;
+ }
+ }
+ else{
+ result = ERROR_STATUS;
+ }
+ }
+ }
+ else{
+ result = ERROR_STATUS;
+ }
+
+ return result;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_compare_asym
+*
+* Description: This function compares 2 asymetric match of 2
+* amc link descriptors
+*
+* Restriction: None
+*
+* Input: asym[COMPARE_CANDIDATE]: Contain 2 asymetric match for comparison
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 if both asym. match are matched, otherwise return -1
+*
+***************************************************************************/
+
+static int
+ipmi_ek_compare_asym( unsigned char asym[COMPARE_CANDIDATE] )
+{
+ int return_value = ERROR_STATUS;
+ int first_index = 0;
+ int second_index = 1;
+
+ if ( (asym[first_index] == 0) && (asym[second_index] == 0) ){
+ return_value = OK_STATUS;
+ }
+ else if ( (asym[first_index] & asym[second_index]) == 0 ){
+ return_value = OK_STATUS;
+ }
+ else{
+ return_value = ERROR_STATUS;
+ }
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_compare_link_descriptor
+*
+* Description: This function compare number of enble port of Link designator
+*
+* Restriction: None
+*
+* Input: link_designator1: first link designator
+* link_designator2: second link designator
+*
+* Output: None
+*
+* Global: None
+*
+* Return: return 0 if both link are matched, otherwise return -1
+*
+***************************************************************************/
+static int
+ipmi_ek_compare_number_of_enable_port(
+ struct fru_picmgext_amc_link_desc_record link_desc[COMPARE_CANDIDATE] )
+{
+ int amc_port_count = 0;
+ int carrier_port_count = 0;
+ int return_value = ERROR_STATUS;
+ int index = 0;
+
+ if (link_desc[index].port_flag_0){ /*bit 0 indicates port 0*/
+ amc_port_count++;
+ }
+ if (link_desc[index].port_flag_1){ /*bit 1 indicates port 1*/
+ amc_port_count++;
+ }
+ if (link_desc[index].port_flag_2){ /*bit 2 indicates port 2*/
+ amc_port_count++;
+ }
+ if (link_desc[index++].port_flag_3){ /*bit 3 indicates port 3*/
+ amc_port_count++;
+ }
+
+ /*2nd link designator*/
+ if (link_desc[index].port_flag_0){ /*bit 0 indicates port 0*/
+ carrier_port_count++;
+ }
+ if (link_desc[index].port_flag_1){ /*bit 1 indicates port 1*/
+ carrier_port_count++;
+ }
+ if (link_desc[index].port_flag_2){ /*bit 2 indicates port 2*/
+ carrier_port_count++;
+ }
+ if (link_desc[index].port_flag_3){ /*bit 3 indicates port 3*/
+ carrier_port_count++;
+ }
+
+ if(carrier_port_count == amc_port_count){
+
+ return_value = OK_STATUS;
+ }
+ else{
+ return_value = ERROR_STATUS;
+ }
+
+ return return_value;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_link_descriptor
+*
+* Description: Display the link descriptor of an AMC p2p connectivity record
+*
+* Restriction: See AMC.0 or PICMG 3.0 specification for detail about bit masks
+*
+* Input: file_type: module type.
+* rsc_id: resource id
+* char* str: indicates if it is a source (its value= "From") or a
+* destination (its value = "To"). ( it is set to "" if it is not
+* a source nor destination
+* link_desc: AMC link descriptor
+* asym: asymetric match
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static tboolean
+ipmi_ek_display_link_descriptor( int file_type, unsigned char rsc_id,
+ char * str, struct fru_picmgext_amc_link_desc_record link_desc )
+{
+ tboolean isOEMtype = FALSE;
+
+ if (file_type == ON_CARRIER_FRU_FILE){
+ printf(" - %s On-Carrier Device ID %d\n", str, (rsc_id & 0x0f) );
+ }
+ else{
+ printf(" - %s %s\n", str,
+ val2str((uint16_t)file_type,ipmi_ekanalyzer_module_type));
+ }
+
+ printf(" - Channel ID %d || ", link_desc.channel_id );
+ printf("%s", link_desc.port_flag_0 ? "Lane 0: enable" : "");
+ printf("%s", link_desc.port_flag_1 ? ", Lane 1: enable" : "");
+ printf("%s", link_desc.port_flag_2 ? ", Lane 2: enable" : "");
+ printf("%s", link_desc.port_flag_3 ? ", Lane 3: enable" : "");
+
+ printf("\n");
+ printf(" - Link Type: %s \n",
+ val2str (link_desc.type, ipmi_ekanalyzer_link_type) );
+ switch ( link_desc.type ){
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE:
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS1:
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS2:
+ printf(" - Link Type extension: %s\n",
+ val2str (link_desc.type_ext, ipmi_ekanalyzer_extension_PCIE) );
+ printf(" - Link Group ID: %d || ", link_desc.group_id );
+ printf("Link Asym. Match: %s\n",
+ val2str (link_desc.asym_match, ipmi_ekanalyzer_asym_PCIE) );
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET:
+ printf(" - Link Type extension: %s\n",
+ val2str (link_desc.type_ext, ipmi_ekanalyzer_extension_ETHERNET) );
+ printf(" - Link Group ID: %d || ", link_desc.group_id );
+ printf("Link Asym. Match: %s\n",
+ val2str (link_desc.asym_match, ipmi_ekanalyzer_asym_PCIE) );
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE:
+ printf(" - Link Type extension: %s\n",
+ val2str (link_desc.type_ext, ipmi_ekanalyzer_extension_STORAGE) );
+ printf(" - Link Group ID: %d || ", link_desc.group_id );
+ printf("Link Asym. Match: %s\n",
+ val2str (link_desc.asym_match, ipmi_ekanalyzer_asym_STORAGE) );
+ break;
+ default:
+ printf(" - Link Type extension: %i\n", link_desc.type_ext );
+ printf(" - Link Group ID: %d || ", link_desc.group_id );
+ printf("Link Asym. Match: %i\n", link_desc.asym_match);
+ break;
+ }
+ /*return as OEM type if link type indicates OEM*/
+ if ( (link_desc.type >= LOWER_OEM_TYPE)
+ &&
+ (link_desc.type <= UPPER_OEM_TYPE)
+ ){
+ isOEMtype = TRUE;
+ }
+
+ return isOEMtype;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_oem_guid
+*
+* Description: Display the oem guid of an AMC p2p connectivity record
+*
+* Restriction: None
+*
+* Input: amc_record: AMC p2p connectivity record
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_oem_guid(
+ struct ipmi_ek_amc_p2p_connectivity_record amc_record )
+{
+ int index_oem = 0;
+ int index = 0;
+
+ if ( amc_record.guid_count == 0 ){
+ printf("\tThere is no OEM GUID for this module\n");
+ }
+ for (index_oem = 0; index_oem < amc_record.guid_count; index_oem++){
+ printf(" - GUID: ");
+ for(index = 0; index < SIZE_OF_GUID; index++){
+ printf("%02x", amc_record.oem_guid[index_oem].guid[index]);
+ /*For a better look: putting a "-" after displaying four bytes of GUID*/
+ if (!(index % 4)){
+ printf("-");
+ }
+ }
+ printf("\n");
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_create_amc_p2p_record
+*
+* Description: this function create an AMC point 2 point connectivity record
+* that contain link descriptor, channel descriptor, oem guid
+*
+* Restriction: Reference: AMC.0 Specification Table 3-16
+*
+* Input: record: a pointer to FRU multi record
+*
+* Output: amc_record: a pointer to the created AMC p2p record
+*
+* Global: None
+*
+* Return: Return OK_STATUS on success, or ERROR_STATUS if no record has been
+* created.
+*
+***************************************************************************/
+static int
+ipmi_ek_create_amc_p2p_record( struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_amc_p2p_connectivity_record * amc_record )
+{
+ int return_status = OK_STATUS;
+ int index_data = START_DATA_OFFSET;
+
+ amc_record->guid_count = record->data[index_data++];
+ if ( amc_record->guid_count > 0){
+ int index_oem = 0;
+ amc_record->oem_guid = malloc (amc_record->guid_count * \
+ sizeof(struct fru_picmgext_guid) );
+ for (index_oem = 0; index_oem < amc_record->guid_count; index_oem++){
+ memcpy ( &amc_record->oem_guid[index_oem].guid,
+ &record->data[index_data],
+ SIZE_OF_GUID );
+ index_data += (int)SIZE_OF_GUID;
+ }
+ amc_record->rsc_id = record->data[index_data++];
+ amc_record->ch_count = record->data[index_data++];
+ /*Calculate link descriptor count*/
+ amc_record->link_desc_count = ( (record->header.len) - 8 -
+ (SIZE_OF_GUID*amc_record->guid_count) -
+ ( sizeof(struct fru_picmgext_amc_channel_desc_record)*
+ amc_record->ch_count )
+ )/5 ;
+ }
+ else{
+ amc_record->rsc_id = record->data[index_data++];
+ amc_record->ch_count = record->data[index_data++];
+ /*Calculate link descriptor count see spec AMC.0 for detail*/
+ amc_record->link_desc_count = ( (record->header.len) - 8 -
+ ( sizeof(struct fru_picmgext_amc_channel_desc_record)*
+ amc_record->ch_count )
+ ) / 5;
+ }
+
+ if (amc_record->ch_count > 0){
+ int ch_index = 0;
+ amc_record->ch_desc = malloc ( (amc_record->ch_count) * \
+ sizeof(struct fru_picmgext_amc_channel_desc_record));
+ for (ch_index = 0; ch_index < amc_record->ch_count; ch_index++){
+ memcpy(&amc_record->ch_desc[ch_index], &record->data[index_data],
+ sizeof(struct fru_picmgext_amc_channel_desc_record) );
+
+ index_data += sizeof(struct fru_picmgext_amc_channel_desc_record) ;
+ }
+ }
+ if (amc_record->link_desc_count > 0){
+ int i=0;
+ amc_record->link_desc = malloc ( amc_record->link_desc_count *
+ sizeof(struct fru_picmgext_amc_link_desc_record) );
+ for (i = 0; i< amc_record->link_desc_count; i++ ){
+ memcpy (&amc_record->link_desc[i], &record->data[index_data],
+ sizeof(struct fru_picmgext_amc_link_desc_record) );
+ index_data += sizeof (struct fru_picmgext_amc_link_desc_record);
+ }
+ }
+ else{
+ return_status = ERROR_STATUS;
+ }
+
+ return return_status;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_get_resource_descriptor
+*
+* Description: this function create the resource descriptor of Carrier p2p
+* connectivity record.
+*
+* Restriction: None
+*
+* Input: port_count: number of port count
+* index: index to the position of data start offset
+* record: a pointer to FRU multi record
+*
+* Output: port_desc: a pointer to the created resource descriptor
+*
+* Global: None
+*
+* Return: Return index that indicates the current position of data in record.
+*
+***************************************************************************/
+static int
+ipmi_ek_get_resource_descriptor( int port_count, int index,
+ struct fru_picmgext_carrier_p2p_descriptor * port_desc,
+ struct ipmi_ek_multi_header * record )
+{
+ int num_port = 0;
+
+ while ( num_port < port_count ){
+ memcpy ( &port_desc[num_port], &record->data[index],
+ sizeof (struct fru_picmgext_carrier_p2p_descriptor) );
+ index += sizeof (struct fru_picmgext_carrier_p2p_descriptor);
+ num_port++;
+ }
+
+ return index;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_fru_header
+*
+* Description: this function display FRU header offset from a FRU binary file
+*
+* Restriction: Reference: IPMI Platform Management FRU Information Storage
+* Definition V1.0, Section 8
+*
+* Input: filename: name of FRU binary file
+*
+* Output: None
+*
+* Global: None
+*
+* Return: Return OK_STATUS on sucess, ERROR_STATUS on error
+*
+***************************************************************************/
+static int
+ipmi_ek_display_fru_header( char * filename )
+{
+ FILE * input_file;
+ /* this structure is declared in ipmi_fru.h */
+ struct fru_header header;
+ int return_status = ERROR_STATUS;
+
+ input_file = fopen ( filename, "r");
+ if ( input_file == NULL ){
+ lprintf(LOG_ERR, "file: '%s' is not found", filename);
+ return_status = ERROR_STATUS;
+ }
+ else{
+ if ( !feof (input_file) ){
+ fread ( &header, sizeof (struct fru_header), 1, input_file );
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("FRU Header Info\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("Format Version :0x%02x %s\n", (header.version & 0x0f),
+ ((header.version & 0x0f)==1) ? "" : "{unsupported}");
+ printf("Internal Use Offset :0x%02x\n", header.offset.internal);
+ printf("Chassis Info Offset :0x%02x\n", header.offset.chassis);
+ printf("Board Info Offset :0x%02x\n", header.offset.board);
+ printf("Product Info Offset :0x%02x\n", header.offset.product);
+ printf("MultiRecord Offset :0x%02x\n", header.offset.multi);
+ printf("Common header Checksum :0x%02x\n", header.checksum);
+
+ return_status = OK_STATUS;
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid FRU header!");
+ return_status = ERROR_STATUS;
+ }
+ fclose( input_file );
+ }
+ return return_status;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_fru_header_detail
+*
+* Description: this function display detail FRU header information
+* from a FRU binary file.
+
+*
+* Restriction: Reference: IPMI Platform Management FRU Information Storage
+* Definition V1.0, Section 8
+*
+* Input: filename: name of FRU binary file
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_fru_header_detail( char * filename )
+{
+ FILE * input_file;
+ struct fru_header header;
+
+ input_file = fopen ( filename, "r");
+ if ( input_file == NULL ){
+ lprintf(LOG_ERR, "file: '%s' is not found", filename);
+ }
+ else{
+ /* the offset in each fru is in multiple of 8 bytes
+ * See IPMI Platform Management FRU Information Storage Definition
+ * for detail
+ */
+ #define FACTOR_OFFSET 8
+
+ if ( !feof (input_file) ){
+ fread ( &header, sizeof( struct fru_header ), 1, input_file );
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid FRU header!");
+ }
+ /*** Display FRU Internal Use Info ***/
+ if ( !feof (input_file) ){
+ unsigned char format_version;
+ unsigned long len;
+
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("FRU Internal Use Info\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+
+ fread ( &format_version, 1, 1, input_file );
+ printf("Format Version: %d\n", (format_version & 0x0f) );
+
+ if ( header.offset.chassis > 0 ){
+ len = (header.offset.chassis * FACTOR_OFFSET)
+ - (header.offset.internal * FACTOR_OFFSET);
+ }
+ else{
+ len = (header.offset.board * FACTOR_OFFSET)
+ - (header.offset.internal * FACTOR_OFFSET);
+ }
+ printf("Length: %d\n", len);
+ printf("Data dump:\n");
+ while ( (len > 0) && ( !feof (input_file) ) ) {
+ unsigned char data;
+ fread ( &data, 1, 1, input_file );
+ printf("0x%02x ", data);
+ len --;
+ }
+ printf("\n");
+ }
+ /*** Chassis Info Area ***/
+ if (header.offset.chassis != 0){
+ long offset = 0;
+
+ offset = header.offset.chassis * FACTOR_OFFSET;
+ ipmi_ek_display_chassis_info_area (input_file, offset);
+ }
+ /*** Display FRU Board Info Area ***/
+ if (header.offset.board != 0){
+ fseek_( input_file, (header.offset.board * FACTOR_OFFSET), SEEK_SET);
+ if ( !feof(input_file) ){
+ unsigned char data;
+ unsigned int board_length;
+ size_t file_offset = ftell (input_file);
+
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("FRU Board Info Area\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+
+ fread ( &data, 1, 1, input_file ); /* Format version */
+ printf("Format Version: %d\n", (data & 0x0f));
+ if ( !feof(input_file) ){
+ fread ( &data, 1, 1, input_file ); /* Board Area Length */
+ board_length = (data * FACTOR_OFFSET);
+ printf("Area Length: %d\n", board_length);
+ /* Decrease the length of board area by 1 byte of format version
+ * and 1 byte for area length itself. the rest of this length will
+ * be used to check for additional custom mfg. byte
+ */
+ board_length -= 2;
+ }
+ if ( !feof(input_file) ){
+ unsigned char lan_code;
+ fread ( &lan_code, 1, 1, input_file ); /* Language Code */
+ printf("Language Code: %d\n", lan_code );
+ board_length --;
+ }
+ /* Board Mfg Date */
+ if ( !feof(input_file) ){
+ #define SIZE_MFG_DATE 3
+ time_t tval;
+ unsigned char mfg_date[SIZE_MFG_DATE];
+
+ fread ( mfg_date, SIZE_MFG_DATE, 1, input_file );
+ tval=((mfg_date[2] << 16) + (mfg_date[1] << 8) + (mfg_date[0]));
+ tval = tval * 60;
+ tval = (time_t)(tval + secs_from_1970_1996);
+ printf("Board Mfg Date: %ld, %s", tval,
+ asctime(localtime(&tval)));
+ board_length -= SIZE_MFG_DATE;
+
+ /* Board Mfg */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Board Manufacture Data", &board_length);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Board Product */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Board Product Name", &board_length);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Board Serial */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Board Serial Number", &board_length);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Board Part */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Board Part Number", &board_length);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* FRU file ID */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "FRU File ID", &board_length);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Additional Custom Mfg. */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Custom", &board_length);
+ }
+ }
+ }
+ /*** Product Info Area ***/
+ if ( header.offset.product ){
+ if ( !feof(input_file) ){
+ long offset = 0;
+ offset = header.offset.product * FACTOR_OFFSET;
+ ipmi_ek_display_product_info_area (input_file, offset);
+ }
+ }
+ fclose( input_file );
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_chassis_info_area
+*
+* Description: this function displays detail format of product info area record
+* into humain readable text format
+*
+* Restriction: Reference: IPMI Platform Management FRU Information Storage
+* Definition V1.0, Section 10
+*
+* Input: input_file: pointer to file stream
+* offset: start offset of chassis info area
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_chassis_info_area( FILE * input_file, long offset )
+{
+ if ( input_file != NULL ){
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("Chassis Info Area\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+
+ fseek_(input_file, offset, SEEK_SET);
+ if ( !feof(input_file) ){
+ unsigned char data = 0;
+ unsigned int len = 0;
+
+ fread (&data, 1, 1, input_file);
+ printf("Format Version Number: %d\n", (data & 0x0f) );
+ if ( !feof(input_file) ){
+ fread (&len, 1, 1, input_file);
+ /* len is in factor of 8 bytes */
+ len = len * 8;
+ printf("Area Length: %d\n", len);
+ len -= 2;
+ }
+ if ( !feof(input_file) ){
+ unsigned char ch_type = 0;
+ size_t file_offset = ftell (input_file);
+ /* Chassis Type*/
+ fread (&ch_type, 1, 1, input_file);
+ printf("Chassis Type: %d\n", ch_type);
+ len --;
+ /* Chassis Part Number*/
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Chassis Part Number", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Chassis Serial */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Chassis Serial Number", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Custom product info area */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Custom", &len);
+ }
+ }
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid Chassis Info Area!");
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_board_info_area
+*
+* Description: this function displays board info area depending on board type
+* that pass in argument. Board type can be:
+* Manufacturer, Serial, Product or Part...
+*
+* Restriction: IPMI Platform Management FRU Information Storage
+* Definition V1.0, Section 11
+*
+* Input: input_file: pointer to file stream
+* board_type: a string that contain board type
+* board_length: length of info area
+*
+* Output: None
+*
+* Global: None
+*
+* Return: the current position of input_file
+*
+***************************************************************************/
+static size_t
+ipmi_ek_display_board_info_area( FILE * input_file, char * board_type,
+ unsigned int * board_length )
+{
+ size_t file_offset = ftell (input_file);
+ unsigned char len = 0;
+ /* Board length*/
+ if ( !feof(input_file) ){
+ fread ( &len, 1, 1, input_file );
+ (*board_length)--;
+ }
+ /* Board Data */
+ if ( !feof(input_file) ){
+ unsigned int size_board = 0;
+
+ /*Bit 5:0 of Board Mfg type represent legnth*/
+ size_board = (len & 0x3f);
+ if (size_board > 0){
+ if ( strncmp( board_type, "Custom", 6 ) == 0 ){
+ #define NO_MORE_INFO_FIELD 0xc1
+ while ( !feof(input_file) && (*board_length > 0) ){
+ if (len != NO_MORE_INFO_FIELD){
+ printf("Additional Custom Mfg. length: 0x%02x\n", len);
+ if ( (size_board > 0) && (size_board < (*board_length)) ){
+ unsigned char * additional_data = NULL;
+ int i=0;
+ additional_data = malloc (size_board);
+ if (additional_data != NULL){
+ fread ( additional_data, size_board, 1, input_file );
+ printf("Additional Custom Mfg. Data: %02x",
+ additional_data[0]);
+ for ( i =1; i<(int)size_board; i++){
+ printf("-%02x", additional_data[i]);
+ }
+ printf("\n");
+ free (additional_data);
+ (*board_length) -= size_board;
+ }
+ }
+ else{
+ printf("No Additional Custom Mfg. %d\n", *board_length);
+ board_length = 0;
+ }
+ }
+ else{
+ unsigned char padding;
+ /*take the rest of data in the area minus 1 byte of checksum*/
+ printf("Additional Custom Mfg. length: 0x%02x\n", len);
+ padding = (*board_length) - 1;
+ /*we reach the end of the record, so its length is set to 0*/
+ board_length = 0;
+ if ( ( padding > 0 ) && ( !feof(input_file) ) ){
+ printf("Unused space: %d (bytes)\n", padding);
+ fseek_(input_file, padding, SEEK_CUR);
+ }
+ if ( !feof(input_file) ){
+ unsigned char checksum = 0;
+ fread ( &checksum, 1, 1, input_file );
+ printf("Checksum: 0x%02x\n", checksum);
+
+ }
+ }
+ }
+ }
+ else{
+ unsigned char * data;
+ unsigned int i=0;
+ #define TYPE_CODE 0xc0 /*Language code*/
+
+ data = malloc (size_board);
+ fread ( data, size_board, 1, input_file );
+ printf("%s type: 0x%02x\n", board_type, len);
+ printf("%s: ", board_type);
+ for ( i = 0; i < size_board; i++ ){
+ if ( (len & TYPE_CODE) == TYPE_CODE ){
+ printf("%c", data[i]);
+ }
+ /*other than language code (binary, BCD, ASCII 6 bit...) is not
+ * supported */
+ else{
+ printf("%02x", data[i]);
+ }
+ }
+ printf("\n");
+ free (data);
+ (*board_length) -= size_board;
+ file_offset = ftell (input_file);
+ }
+ }
+ else{
+ printf("%s: None\n", board_type);
+ file_offset = ftell (input_file);
+ }
+ }
+
+ return file_offset;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_product_info_area
+*
+* Description: this function displays detail format of product info area record
+* into humain readable text format
+*
+* Restriction: Reference: IPMI Platform Management FRU Information Storage
+* Definition V1.0, Section 12
+*
+* Input: input_file: pointer to file stream
+* offset: start offset of product info area
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_product_info_area( FILE * input_file, long offset )
+{
+ if ( input_file != NULL ){
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("Product Info Area\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+
+ fseek_(input_file, offset, SEEK_SET);
+ if ( !feof(input_file) ){
+ unsigned char data = 0;
+ unsigned int len = 0;
+
+ fread (&data, 1, 1, input_file);
+ printf("Format Version Number: %d\n", (data & 0x0f) );
+ if ( !feof(input_file) ){
+ fread (&len, 1, 1, input_file);
+ /* length is in factor of 8 bytes */
+ len = len * 8;
+ printf("Area Length: %d\n", len);
+ len -= 2; /* -1 byte of format version and -1 byte itself */
+ }
+ if ( !feof(input_file) ){
+ size_t file_offset = ftell (input_file);
+
+ fread (&data, 1, 1, input_file);
+ printf("Language Code: %d\n", data);
+ len --;
+ /* Product Mfg */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Product Manufacture Data", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Product Name */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Product Name", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Product Part */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Product Part/Model Number", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Product Version */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Product Version", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Product Serial */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Product Serial Number", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Product Asset Tag */
+ file_offset = ipmi_ek_display_board_info_area ( input_file,
+ "Asset Tag", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* FRU file ID */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "FRU File ID", &len);
+ fseek_(input_file, file_offset, SEEK_SET);
+ /* Custom product info area */
+ file_offset = ipmi_ek_display_board_info_area (
+ input_file, "Custom", &len);
+ }
+ }
+ }
+ else{
+ lprintf(LOG_ERR, "Invalid Product Info Area!");
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_record
+*
+* Description: this function displays FRU multi record information.
+*
+* Restriction: None
+*
+* Input: record: a pointer to current record
+* list_head: a pointer to header of the list
+* list_last: a pointer to tale of the list
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_record( struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_multi_header * list_head,
+ struct ipmi_ek_multi_header * list_last )
+{
+ if ( list_head == NULL ){
+ printf("***empty list***\n");
+ }
+ else{
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ printf("FRU Multi Info area\n");
+ printf("%s\n", EQUAL_LINE_LIMITER);
+ for ( record = list_head; record != NULL; record = record->next ){
+ printf("Record Type ID: 0x%02x\n", record->header.type);
+ printf("Record Format version: 0x%02x\n", record->header.format);
+ if (record->header.len > PICMG_ID_OFFSET){
+ /* In picmg3.0 specification, picmg record id lower than 4 or
+ * greater than 0x2d is not supported
+ */
+ #define PICMG_ID_LOWER_LIMIT 0x04
+ #define PICMG_ID_UPPER_LIMIT 0x2d
+ unsigned char picmg_id;
+
+ picmg_id = record->data[PICMG_ID_OFFSET];
+ printf("Manufacturer ID: %02x%02x%02x h\n", record->data[2],
+ record->data[1], record->data[0] );
+ if( ( picmg_id < PICMG_ID_LOWER_LIMIT )
+ ||
+ ( picmg_id > PICMG_ID_UPPER_LIMIT ) ){
+ printf("Picmg record ID: Unsupported {0x%02x}\n", picmg_id );
+ }
+ else{
+ printf("Picmg record ID: %s {0x%02x}\n",
+ val2str(picmg_id, ipmi_ekanalyzer_picmg_record_id),
+ picmg_id );
+ }
+ switch (picmg_id){
+ case FRU_PICMG_BACKPLANE_P2P: /*0x04*/
+ ipmi_ek_display_backplane_p2p_record (record);
+ break;
+ case FRU_PICMG_ADDRESS_TABLE: /*0x10*/
+ ipmi_ek_display_address_table_record (record);
+ break;
+ case FRU_PICMG_SHELF_POWER_DIST: /*0x11*/
+ ipmi_ek_display_shelf_power_distribution_record (record);
+ break;
+ case FRU_PICMG_SHELF_ACTIVATION: /*/0x12*/
+ ipmi_ek_display_shelf_activation_record (record);
+ break;
+ case FRU_PICMG_SHMC_IP_CONN: /*0x13*/
+ ipmi_ek_display_shelf_ip_connection_record (record);
+ break;
+ case FRU_PICMG_BOARD_P2P: /*0x14*/
+ ipmi_ek_display_board_p2p_record (record);
+ break;
+ case FRU_RADIAL_IPMB0_LINK_MAPPING: /*0x15*/
+ ipmi_ek_display_radial_ipmb0_record (record);
+ break;
+ case FRU_AMC_CURRENT: /*0x16*/
+ ipmi_ek_display_amc_current_record (record);
+ break;
+ case FRU_AMC_ACTIVATION: /*0x17*/
+ ipmi_ek_display_amc_activation_record (record);
+ break;
+ case FRU_AMC_CARRIER_P2P: /*0x18*/
+ ipmi_ek_diplay_carrier_connectivity (record);
+ break;
+ case FRU_AMC_P2P: /*0x19*/
+ ipmi_ek_display_amc_p2p_record (record);
+ break;
+ case FRU_AMC_CARRIER_INFO: /*0x1a*/
+ ipmi_ek_display_amc_carrier_info_record (record);
+ break;
+ case FRU_PICMG_CLK_CARRIER_P2P: /*0x2c*/
+ ipmi_ek_display_clock_carrier_p2p_record (record);
+ break;
+ case FRU_PICMG_CLK_CONFIG: /*0x2d*/
+ ipmi_ek_display_clock_config_record (record);
+ break;
+ default:
+ if (verbose > 0){
+ int i;
+ printf("%02x %02x %02x %02x %02x ", record->header.type,
+ record->header.format, record->header.len,
+ record->header.record_checksum,
+ record->header.header_checksum );
+ for ( i = 0; i < record->header.len; i++ ){
+ printf("%02x ", record->data[i]);
+ }
+ printf("\n");
+ }
+ break;
+ }
+ printf("%s\n", STAR_LINE_LIMITER);
+ }
+ }
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_backplane_p2p_record
+*
+* Description: this function displays backplane p2p record.
+*
+* Restriction: Reference: PICMG 3.0 Specification Table 3-40
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_backplane_p2p_record( struct ipmi_ek_multi_header * record )
+{
+ uint8_t index;
+ int offset = START_DATA_OFFSET;
+ struct fru_picmgext_slot_desc * slot_d
+ = (struct fru_picmgext_slot_desc*) &record->data[offset];
+
+ offset += sizeof(struct fru_picmgext_slot_desc);
+
+ while ( offset <= record->header.len ) {
+ printf(" Channel Type: ");
+ switch ( slot_d -> chan_type )
+ {
+ case 0x00:
+ case 0x07:
+ printf("PICMG 2.9\n");
+ break;
+ case 0x08:
+ printf("Single Port Fabric IF\n");
+ break;
+ case 0x09:
+ printf("Double Port Fabric IF\n");
+ break;
+ case 0x0a:
+ printf("Full Channel Fabric IF\n");
+ break;
+ case 0x0b:
+ printf("Base IF\n");
+ break;
+ case 0x0c:
+ printf("Update Channel IF\n");
+ break;
+ default:
+ printf("Unknown IF\n");
+ break;
+ }
+ printf(" Slot Address: %02x\n", slot_d -> slot_addr);
+ printf(" Channel Count: %i\n", slot_d -> chn_count);
+
+ for ( index = 0; index < (slot_d -> chn_count); index++ ) {
+ struct fru_picmgext_chn_desc * d
+ = (struct fru_picmgext_chn_desc *) &record->data[offset];
+
+ if ( verbose ){
+ printf( "\t"
+ "Chn: %02x --> "
+ "Chn: %02x in "
+ "Slot: %02x\n",
+ d->local_chn, d->remote_chn, d->remote_slot
+ );
+ }
+ offset += sizeof(struct fru_picmgext_chn_desc);
+ }
+ slot_d = (struct fru_picmgext_slot_desc*) &record->data[offset];
+ offset += sizeof(struct fru_picmgext_slot_desc);
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_address_table_record
+*
+* Description: this function displays address table record.
+*
+* Restriction: Reference: PICMG 3.0 Specification Table 3-6
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_address_table_record( struct ipmi_ek_multi_header * record )
+{
+ unsigned char entries = 0;
+ unsigned char i;
+ int offset = START_DATA_OFFSET;
+ #define SIZE_SHELF_ADDRESS_BYTE 20
+
+ printf(" Type/Len: 0x%02x\n", record->data[offset++]);
+ printf(" Shelf Addr: ");
+ for ( i = 0; i < SIZE_SHELF_ADDRESS_BYTE; i++ ){
+ printf("0x%02x ", record->data[offset++]);
+ }
+ printf("\n");
+
+ entries = record->data[offset++];
+ printf(" Addr Table Entries count: 0x%02x\n", entries);
+
+ for ( i = 0; i < entries; i++ ){
+ printf("\tHWAddr: 0x%02x - SiteNum: 0x%02x - SiteType: 0x%02x \n",
+ record->data[offset+0],
+ record->data[offset+1],
+ record->data[offset+2]);
+ offset += 3;
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_shelf_power_distribution_record
+*
+* Description: this function displays shelf power distribution record.
+*
+* Restriction: Reference: PICMG 3.0 Specification Table 3-70
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_shelf_power_distribution_record(
+ struct ipmi_ek_multi_header * record )
+{
+ int offset = START_DATA_OFFSET;
+ unsigned char i,j;
+ unsigned char feeds = 0;
+
+ feeds = record->data[offset++];
+ printf(" Number of Power Feeds: 0x%02x\n", feeds);
+
+ for (i=0; i<feeds; i++) {
+ unsigned char entries;
+ unsigned long max_ext = 0;
+ unsigned long max_int = 0;
+ max_ext = record->data[offset+0] | (record->data[offset+1]<<8);
+ printf(" Max External Available Current: %ld Amps\n", (max_ext*10) );
+
+ offset += 2;
+
+ max_int = record->data[offset+0] | (record->data[offset+1]<<8);
+ printf(" Max Internal Current:\t %ld Amps\n", (max_int*10));
+ offset += 2;
+ printf(" Min Expected Operating Voltage: %ld Volts\n",
+ (record->data[offset++]/2));
+ entries = record->data[offset++];
+ printf(" Feed to FRU count: 0x%02x\n", entries);
+ for (j=0; j<entries; j++) {
+ printf("\tHW: 0x%02x", record->data[offset++]);
+ printf("\tFRU ID: 0x%02x\n", record->data[offset++]);
+ }
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_shelf_activation_record
+*
+* Description: this function displays shelf activation record.
+*
+* Restriction: Reference: PICMG 3.0 Specification Table 3-73
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_shelf_activation_record(
+ struct ipmi_ek_multi_header * record )
+{
+ unsigned char count = 0;
+ int offset = START_DATA_OFFSET;
+
+ printf(" Allowance for FRU Act Readiness: 0x%02x\n",
+ record->data[offset++]);
+ count = record->data[offset++];
+ printf(" FRU activation and Power Desc Cnt: 0x%02x\n", count);
+
+ while ( count > 0 ) {
+ printf(" FRU activation and Power descriptor:\n");
+ printf("\tHardware Address:\t\t0x%02x\n", record->data[offset++]);
+ printf("\tFRU Device ID:\t\t\t0x%02x\n", record->data[offset++]);
+ printf("\tMax FRU Power Capability:\t0x%04x Watts\n",
+ ( record->data[offset+0] | (record->data[offset+1]<<8) ));
+ offset += 2;
+ printf("\tConfiguration parameter:\t0x%02x\n", record->data[offset++]);
+ count --;
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_shelf_ip_connection_record
+*
+* Description: this function displays shelf ip connection record.
+*
+* Restriction: Fix me: Don't test yet
+* Reference: PICMG 3.0 Specification Table 3-31
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_shelf_ip_connection_record(
+ struct ipmi_ek_multi_header * record )
+{
+ int ioffset = START_DATA_OFFSET;
+ if (ioffset > record->header.len){
+ printf(" Shelf Manager IP Address: %d.%d.%d.%d\n",
+ record->data[ioffset+0], record->data[ioffset+1],
+ record->data[ioffset+2], record->data[ioffset+3]);
+ ioffset += 4;
+ }
+ if (ioffset > record->header.len){
+ printf(" Default Gateway Address: %d.%d.%d.%d\n",
+ record->data[ioffset+0], record->data[ioffset+1],
+ record->data[ioffset+2], record->data[ioffset+3]);
+ ioffset += 4;
+ }
+ if (ioffset > record->header.len){
+ printf(" Subnet Mask: %d.%d.%d.%d\n",
+ record->data[ioffset+0], record->data[ioffset+1],
+ record->data[ioffset+2], record->data[ioffset+3]);
+ ioffset += 4;
+ }
+}
+
+#ifdef NOT_USED
+static void ipmi_ek_display_shelf_fan_geography_record(
+ struct ipmi_ek_multi_header * record );
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_shelf_fan_geography_record
+*
+* Description: this function displays shelf fan geography record.
+*
+* Restriction: Fix me: Don't test yet
+* Reference: PICMG 3.0 Specification Table 3-75
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_shelf_fan_geography_record(
+ struct ipmi_ek_multi_header * record )
+{
+ int ioffset = START_DATA_OFFSET;
+ unsigned char fan_count = 0;
+
+ fan_count = record->data[ioffset];
+ ioffset ++;
+ printf(" Fan-to-FRU Entry Count: 0x%02x\n", fan_count);
+
+ while ( (fan_count > 0) && (ioffset <= record->header.len) ){
+ printf(" Fan-to-FRU Mapping Entry: {%2x%2x%2x%2x}\n",
+ record->data[ioffset], record->data[ioffset+1],
+ record->data[ioffset+2], record->data[ioffset+3]
+ );
+ printf(" Hardware Address: 0x%02x\n", record->data[ioffset++]);
+ printf(" FRU device ID: 0x%02x\n", record->data[ioffset++]);
+ printf(" Site Number: 0x%02x\n", record->data[ioffset++]);
+ printf(" Site Type: 0x%02x\n", record->data[ioffset++]);
+ fan_count --;
+ }
+
+}
+#endif
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_board_p2p_record
+*
+* Description: this function displays board pont-to-point record.
+*
+* Restriction: Reference: PICMG 3.0 Specification Table 3-44
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_board_p2p_record( struct ipmi_ek_multi_header * record )
+{
+ unsigned char guid_count;
+ int offset = START_DATA_OFFSET;
+ int i = 0;
+
+ guid_count = record->data[offset++];
+ printf(" GUID count: %2d\n", guid_count);
+
+ for (i = 0 ; i < guid_count; i++ ) {
+ int j;
+ printf("\tGUID: ");
+ for (j=0; j < sizeof(struct fru_picmgext_guid); j++) {
+ printf("%02x", record->data[offset+j]);
+ }
+ printf("\n");
+ offset += sizeof(struct fru_picmgext_guid);
+ }
+
+ for ( /*offset set above*/ ;
+ offset < record->header.len;
+ offset += sizeof(struct fru_picmgext_link_desc)
+ ) {
+ /* to solve little endian /big endian problem */
+ unsigned long data;
+ struct fru_picmgext_link_desc * d;
+
+ data = (record->data[offset+0]) | (record->data[offset+1] << 8)\
+ | (record->data[offset+2] << 16)\
+ | (record->data[offset+3] << 24);
+
+ d = (struct fru_picmgext_link_desc *) &data;
+
+ printf(" Link Descriptor\n");
+ printf("\tLink Grouping ID:\t0x%02x\n", d->grouping);
+ printf("\tLink Type Extension:\t0x%02x - ", d->ext);
+
+ if (d->type == FRU_PICMGEXT_LINK_TYPE_BASE){
+ switch (d->ext){
+ case 0:
+ printf("10/100/1000BASE-T Link (four-pair)\n");
+ break;
+ case 1:
+ printf("ShMC Cross-connect (two-pair)\n");
+ break;
+ default:
+ printf("Unknwon\n");
+ break;
+ }
+ }
+ else if (d->type == FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET){
+ switch (d->ext){
+ case 0:
+ printf("Fixed 1000Base-BX\n");
+ break;
+ case 1:
+ printf("Fixed 10GBASE-BX4 [XAUI]\n");
+ break;
+ case 2:
+ printf("FC-PI\n");
+ break;
+ default:
+ printf("Unknwon\n");
+ break;
+ }
+ }
+ else if (d->type == FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND){
+ printf("Unknwon\n");
+ }
+ else if (d->type == FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR){
+ printf("Unknwon\n");
+ }
+ else if (d->type == FRU_PICMGEXT_LINK_TYPE_PCIE){
+ printf("Unknwon\n");
+ }
+ else{
+ printf("Unknwon\n");
+ }
+
+ printf("\tLink Type:\t\t0x%02x - ",d->type);
+ if (d->type == 0 || d->type == 0xff){
+ printf("Reserved\n");
+ }
+ else if (d->type >= 0x06 && d->type <= 0xef) {
+ printf("Reserved\n");
+ }
+ else if (d->type >= LOWER_OEM_TYPE && d->type <= UPPER_OEM_TYPE) {
+ printf("OEM GUID Definition\n");
+ }
+ else {
+ switch (d->type){
+ case FRU_PICMGEXT_LINK_TYPE_BASE:
+ printf("PICMG 3.0 Base Interface 10/100/1000\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET:
+ printf("PICMG 3.1 Ethernet Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND:
+ printf("PICMG 3.2 Infiniband Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR:
+ printf("PICMG 3.3 Star Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_PCIE:
+ printf("PICMG 3.4 PCI Express Fabric Interface\n");
+ break;
+ default:
+ printf("Invalid\n");
+ break;
+ }
+ }
+ printf("\tLink Designator: \n");
+ printf("\t Port 0 Flag: %s\n",
+ (d->desig_port & 0x01) ? "enable" : "disable");
+ printf("\t Port 1 Flag: %s\n",
+ (d->desig_port & 0x02) ? "enable" : "disable");
+ printf("\t Port 2 Flag: %s\n",
+ (d->desig_port & 0x04) ? "enable" : "disable");
+ printf("\t Port 3 Flag: %s\n",
+ (d->desig_port & 0x08) ? "enable" : "disable");
+
+ printf("\t Interface: 0x%02x - ", d->desig_if);
+ switch (d->desig_if){
+ case FRU_PICMGEXT_DESIGN_IF_BASE:
+ printf("Base Interface\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_FABRIC:
+ printf("Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL:
+ printf("Update Channel\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_RESERVED:
+ printf("Reserved\n");
+ break;
+ default:
+ printf("Invalid");
+ break;
+ }
+ printf("\t Channel Number: 0x%02x\n", d->desig_channel);
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_radial_ipmb0_record
+*
+* Description: this function displays radial IPMB-0 record.
+*
+* Restriction: Fix me: Don't test yet
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_radial_ipmb0_record( struct ipmi_ek_multi_header * record )
+{
+ int offset = START_DATA_OFFSET;
+ #define SIZE_OF_CONNECTOR_DEFINER 3; /*bytes*/
+
+ /*Ref: PICMG 3.0 Specification Revision 2.0, Table 3-59*/
+ printf(" IPMB-0 Connector Definer: ");
+ #ifndef WORDS_BIGENDIAN
+ printf("%02x %02x %02x h\n", record->data[offset],
+ record->data[offset+1], record->data[offset+2]);
+ #else
+ printf("%02x %02x %02x h\n", record->data[offset+2],
+ record->data[offset+1], record->data[offset]);
+ #endif
+ /*3 bytes of connector definer was used*/
+ offset += SIZE_OF_CONNECTOR_DEFINER;
+
+ printf (" IPMB-0 Connector version ID: ");
+ #ifndef WORDS_BIGENDIAN
+ printf("%02x %02x h\n", record->data[offset], record->data[offset+1]);
+ #else
+ printf("%02x %02x h\n", record->data[offset+1], record->data[offset]);
+ #endif
+ offset += 2;
+
+ printf(" IPMB-0 Hub Descriptor Count: 0x%02x", record->data[offset++]);
+ if (record->data[offset] > 0){
+ for (/*offset*/; offset < record->header.len;){
+ unsigned char entry_count = 0;
+ printf(" IPMB-0 Hub Descriptor\n");
+ printf("\tHardware Address: 0x%02x\n", record->data[offset++]);
+ printf("\tHub Info {0x%02x}: ", record->data[offset]);
+ /* Bit mask specified in Table 3-59 of PICMG 3.0 Specification */
+ if ( (record->data[offset] & 0x01) == 0x01 ){
+ printf("IPMB-A only\n");
+ }
+ else if ( (record->data[offset] & 0x02) == 0x02 ){
+ printf("IPMB-B only\n");
+ }
+ else if ( (record->data[offset] & 0x03) == 0x03 ){
+ printf("IPMB-A and IPMB-B\n");
+ }
+ else{
+ printf("Reserved.\n");
+ }
+ offset ++;
+
+ entry_count = record->data[offset++];
+ printf("\tAddress Entry count: 0x%02x", entry_count);
+ while (entry_count > 0){
+ printf("\t Hardware Address: 0x%02x\n", record->data[offset++]);
+ printf("\t IPMB-0 Link Entry: 0x%02x\n",record->data[offset++]);
+ entry_count --;
+ }
+ }
+ }
+
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_amc_current_record
+*
+* Description: this function displays AMC current record.
+*
+* Restriction: None
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_amc_current_record( struct ipmi_ek_multi_header * record )
+{
+ unsigned char current;
+ current = record->data[START_DATA_OFFSET];
+ printf(" Current draw: %.1f A @ 12V => %.2f Watt\n",
+ (float) current/10.0, ((float)current/10.0)*12.0 );
+ printf("\n");
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_amc_activation_record
+*
+* Description: this function displays carrier activation and current management
+* record.
+*
+* Restriction: Reference: AMC.0 Specification Table 3-11 and Table 3-12
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_amc_activation_record( struct ipmi_ek_multi_header * record )
+{
+ uint16_t max_current;
+ int offset = START_DATA_OFFSET;
+
+ max_current = record->data[offset];
+ max_current |= record->data[++offset] << 8;
+ printf(" Maximum Internal Current(@12V): %.2f A [ %.2f Watt ]\n",
+ (float) max_current / 10,
+ (float) max_current / 10 * 12);
+ printf(" Module Activation Readiness: %i sec.\n",
+ record->data[++offset]);
+
+ printf(" Descriptor Count: %i\n", record->data[++offset]);
+ for(++offset; (offset < record->header.len); offset += 3 )
+ {
+ struct fru_picmgext_activation_record * a =
+ (struct fru_picmgext_activation_record *) &record->data[offset];
+
+ printf("\tIPMB-Address:\t\t0x%x\n", a->ibmb_addr);
+ printf("\tMax. Module Current:\t%.2f A\n", (float)a->max_module_curr/10);
+ printf("\n");
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_amc_p2p_record
+*
+* Description: this function display amc p2p connectivity record in humain
+* readable text format
+*
+* Restriction: Reference: AMC.0 Specification Table 3-16
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_amc_p2p_record( struct ipmi_ek_multi_header * record )
+{
+ int index_data = START_DATA_OFFSET;
+ int oem_count = 0;
+ int ch_count = 0;
+ int index=0;
+
+ oem_count = record->data[index_data++];
+ printf("OEM GUID count: %02x\n", oem_count);
+
+ if ( oem_count > 0 ){
+ while ( oem_count > 0 ){
+ printf("OEM GUID: ");
+ for ( index = 1; index <= SIZE_OF_GUID; index++ ){
+ printf("%02x", record->data[index_data++]);
+ /* For a better look, display a "-" character after each 5 bytes
+ * of OEM GUID */
+ if ( !(index % 5) ){
+ printf("-");
+ }
+ }
+ printf("\n");
+ oem_count--;
+ }
+ }
+ if ( ( record->data[index_data] & AMC_MODULE ) == AMC_MODULE ){
+ printf("AMC module connection\n");
+ }
+ else{
+ printf("On-Carrier Device %02x h\n", ( record->data[index_data] & 0x0f ));
+ }
+ index_data ++;
+ ch_count = record->data[index_data++];
+ printf("AMC Channel Descriptor count: %02x h\n", ch_count);
+
+ if ( ch_count > 0 ){
+ for ( index = 0; index < ch_count; index++ ){
+ struct fru_picmgext_amc_channel_desc_record * ch_desc;
+ printf(" AMC Channel Descriptor {%02x%02x%02x}\n",
+ record->data[index_data+2], record->data[index_data+1],
+ record->data[index_data]
+ );
+ /*Warning: For gcc version between 4.0 and 4.3 this code doesnt work*/
+ ch_desc = ( struct fru_picmgext_amc_channel_desc_record * )\
+ &record->data[index_data];
+ printf(" Lane 0 Port: 0x%02x\n", ch_desc->lane0port);
+ printf(" Lane 1 Port: 0x%02x\n", ch_desc->lane1port);
+ printf(" Lane 2 Port: 0x%02x\n", ch_desc->lane2port);
+ printf(" Lane 3 Port: 0x%02x\n\n", ch_desc->lane3port);
+ index_data += sizeof (struct fru_picmgext_amc_channel_desc_record) ;
+ }
+ }
+ while ( index_data < record->header.len ){
+ /*Warning: For gcc version between 4.0 and 4.3 this code doesnt work*/
+ struct fru_picmgext_amc_link_desc_record * link_desc =
+ (struct fru_picmgext_amc_link_desc_record *)&record->data[index_data];
+
+ printf(" AMC Link Descriptor:\n" );
+
+ printf("\t- Link Type: %s \n",
+ val2str (link_desc->type, ipmi_ekanalyzer_link_type));
+ switch ( link_desc->type ){
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE:
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS1:
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS2:
+ printf("\t- Link Type extension: %s\n",
+ val2str (link_desc->type_ext, ipmi_ekanalyzer_extension_PCIE));
+ printf("\t- Link Group ID: %d\n ", link_desc->group_id );
+ printf("\t- Link Asym. Match: %s\n",
+ val2str (link_desc->asym_match, ipmi_ekanalyzer_asym_PCIE));
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET:
+ printf("\t- Link Type extension: %s\n",
+ val2str (link_desc->type_ext,
+ ipmi_ekanalyzer_extension_ETHERNET));
+ printf("\t- Link Group ID: %d \n", link_desc->group_id );
+ printf("\t- Link Asym. Match: %s\n",
+ val2str (link_desc->asym_match, ipmi_ekanalyzer_asym_PCIE));
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE:
+ printf("\t- Link Type extension: %s\n",
+ val2str (link_desc->type_ext,
+ ipmi_ekanalyzer_extension_STORAGE));
+ printf("\t- Link Group ID: %d \n", link_desc->group_id );
+ printf("\t- Link Asym. Match: %s\n",
+ val2str (link_desc->asym_match, ipmi_ekanalyzer_asym_STORAGE));
+ break;
+ default:
+ printf("\t- Link Type extension: %i\n", link_desc->type_ext );
+ printf("\t- Link Group ID: %d \n", link_desc->group_id );
+ printf("\t- Link Asym. Match: %i\n", link_desc->asym_match);
+ break;
+ }
+ printf("\t- AMC Link Designator:\n");
+ printf("\t Channel ID: %i\n", link_desc->channel_id);
+ printf("\t\t Lane 0: %s\n", (link_desc->port_flag_0)?"enable":"disable");
+ printf("\t\t Lane 1: %s\n", (link_desc->port_flag_1)?"enable":"disable");
+ printf("\t\t Lane 2: %s\n", (link_desc->port_flag_2)?"enable":"disable");
+ printf("\t\t Lane 3: %s\n", (link_desc->port_flag_3)?"enable":"disable");
+ index_data += sizeof (struct fru_picmgext_amc_link_desc_record);
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_amc_carrier_info_record
+*
+* Description: this function displays Carrier information table.
+*
+* Restriction: Reference: AMC.0 Specification Table 3-3
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: START_DATA_OFFSET
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_amc_carrier_info_record( struct ipmi_ek_multi_header * record )
+{
+ unsigned char extVersion;
+ unsigned char siteCount;
+ int offset = START_DATA_OFFSET;
+
+ extVersion = record->data[offset++];
+ siteCount = record->data[offset++];
+
+ printf(" AMC.0 extension version: R%d.%d\n", (extVersion >> 0)& 0x0F,
+ (extVersion >> 4)& 0x0F );
+ printf(" Carrier Sie Number Count: %d\n", siteCount);
+
+ while (siteCount > 0){
+ printf("\tSite ID (%d): %s \n", record->data[offset],
+ val2str(record->data[offset], ipmi_ekanalyzer_module_type) );
+ offset++;
+ siteCount--;
+ }
+ printf("\n");
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_clock_carrier_p2p_record
+*
+* Description: this function displays Carrier clock point-to-pont
+* connectivity record.
+*
+* Restriction: the following code is copy from ipmi_fru.c with modification in
+* reference to AMC.0 Specification Table 3-29
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_display_clock_carrier_p2p_record(
+ struct ipmi_ek_multi_header * record )
+{
+ unsigned char desc_count;
+ int i,j;
+ int offset = START_DATA_OFFSET;
+
+ desc_count = record->data[offset++];
+
+ for(i=0; i<desc_count; i++){
+ unsigned char resource_id;
+ unsigned char channel_count;
+
+ resource_id = record->data[offset++];
+ channel_count = record->data[offset++];
+
+ printf(" Clock Resource ID: 0x%02x\n", resource_id);
+ printf(" Type: ");
+ if((resource_id & 0xC0)>>6 == 0) {
+ printf("On-Carrier-Device\n");
+ }
+ else if((resource_id & 0xC0)>>6 == 1) {
+ printf("AMC slot\n");
+ }
+ else if((resource_id & 0xC0)>>6 == 2) {
+ printf("Backplane\n");
+ }
+ else{
+ printf("reserved\n");
+ }
+ printf(" Channel Count: 0x%02x\n", channel_count);
+
+ for(j=0; j<channel_count; j++){
+ unsigned char loc_channel, rem_channel, rem_resource;
+
+ loc_channel = record->data[offset++];
+ rem_channel = record->data[offset++];
+ rem_resource = record->data[offset++];
+
+ printf("\tCLK-ID: 0x%02x ---> ", loc_channel);
+ printf(" remote CLKID: 0x%02x ", rem_channel);
+ if((rem_resource & 0xC0)>>6 == 0) {
+ printf("[ Carrier-Dev");
+ }
+ else if((rem_resource & 0xC0)>>6 == 1) {
+ printf("[ AMC slot ");
+ }
+ else if((rem_resource & 0xC0)>>6 == 2) {
+ printf("[ Backplane ");
+ }
+ else{
+ printf("reserved ");
+ }
+ printf(" 0x%02x ]\n", rem_resource&0xF);
+ }
+ }
+ printf("\n");
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_display_clock_config_record
+*
+* Description: this function displays clock configuration record.
+*
+* Restriction: the following codes are copy from ipmi_fru.c with modification
+* in reference to AMC.0 Specification Table 3-35 and Table 3-36
+*
+* Input: record: a pointer to current record to be displayed
+*
+* Output: None
+*
+* Global: START_DATA_OFFSET
+*
+* Return: None
+*
+***************************************************************************/
+void
+ipmi_ek_display_clock_config_record( struct ipmi_ek_multi_header * record )
+{
+ unsigned char resource_id, descr_count;
+ int i;
+ int offset = START_DATA_OFFSET;
+
+ resource_id = record->data[offset++];
+ descr_count = record->data[offset++];
+ printf(" Clock Resource ID: 0x%02x\n", resource_id);
+ printf(" Clock Configuration Descriptor Count: 0x%02x\n", descr_count);
+
+ for(i=0; i<descr_count; i++){
+ unsigned char channel_id, control;
+ unsigned char indirect_cnt, direct_cnt;
+ int j=0;
+
+ channel_id = record->data[offset++];
+ control = record->data[offset++];
+ printf("\tCLK-ID: 0x%02x - ", channel_id);
+ printf("CTRL 0x%02x [ %12s ]\n", control,
+ ((control&0x1)==0)?"Carrier IPMC":"Application");
+
+ indirect_cnt = record->data[offset++];
+ direct_cnt = record->data[offset++];
+ printf("\t Count: Indirect 0x%02x / Direct 0x%02x\n", indirect_cnt,
+ direct_cnt );
+
+ /* indirect desc */
+ for(j=0; j<indirect_cnt; j++){
+ unsigned char feature;
+ unsigned char dep_chn_id;
+
+ feature = record->data[offset++];
+ dep_chn_id = record->data[offset++];
+ printf("\t\tFeature: 0x%02x [%8s] - ", feature,
+ (feature&0x1)==1?"Source":"Receiver");
+ printf(" Dep. CLK-ID: 0x%02x\n", dep_chn_id);
+ }
+
+ /* direct desc */
+ for(j=0; j<direct_cnt; j++){
+ unsigned char feature, family, accuracy;
+ unsigned long freq, min_freq, max_freq;
+
+ feature = record->data[offset++];
+ family = record->data[offset++];
+ accuracy = record->data[offset++];
+ freq = (record->data[offset+0] << 0 )
+ | (record->data[offset+1] << 8 )
+ | (record->data[offset+2] << 16)
+ | (record->data[offset+3] << 24);
+ offset += 4;
+ min_freq = (record->data[offset+0] << 0 )
+ | (record->data[offset+1] << 8 )
+ | (record->data[offset+2] << 16)
+ | (record->data[offset+3] << 24);
+ offset += 4;
+ max_freq = (record->data[offset+0] << 0 )
+ | (record->data[offset+1] << 8 )
+ | (record->data[offset+2] << 16)
+ | (record->data[offset+3] << 24);
+ offset += 4;
+
+ printf("\t- Feature: 0x%02x - PLL: %x / Asym: %s\n",
+ feature,
+ (feature > 1) & 1,
+ (feature&1)?"Source":"Receiver");
+ printf("\tFamily: 0x%02x - AccLVL: 0x%02x\n", family, accuracy);
+ printf("\tFRQ: %-9d - min: %-9d - max: %-9d\n",
+ freq, min_freq, max_freq);
+ }
+ printf("\n");
+ }
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ekanalyzer_fru_file2structure
+*
+* Description: this function convert a FRU binary file into a linked list of
+* FRU multi record
+*
+* Restriction: None
+*
+* Input/Ouput: filename1: name of the file that contain FRU binary data
+* record: a pointer to current record
+* list_head: a pointer to header of the list
+* list_last: a pointer to tale of the list
+*
+* Global: None
+*
+* Return: return -1 as Error status, and 0 as Ok status
+*
+***************************************************************************/
+static int
+ipmi_ekanalyzer_fru_file2structure( char * filename,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_record,
+ struct ipmi_ek_multi_header ** list_last )
+{
+ int return_status = ERROR_STATUS;
+ FILE * input_file;
+
+
+ input_file = fopen ( filename, "r");
+ if ( input_file == NULL ){
+ lprintf(LOG_ERR, "File: '%s' is not found", filename);
+ return_status = ERROR_STATUS;
+ }
+ else{
+ long multi_offset = 0;
+ fseek_( input_file, START_DATA_OFFSET, SEEK_SET );
+ fread ( &multi_offset, 1, 1, input_file );
+ if ( multi_offset <= 0 ){
+ lprintf(LOG_NOTICE, "There is no multi record in the file %s\n",
+ filename);
+ }
+ else{
+ int record_count = 0;
+
+ if ( verbose >= 2) { // was == LOG_DEBUG
+ printf( "start multi offset = 0x%02x\n", multi_offset );
+ }
+ /*the offset value is in multiple of 8 bytes.*/
+ multi_offset = multi_offset * 8;
+ fseek_( input_file, multi_offset, SEEK_SET );
+ while ( !feof( input_file ) ){
+ *list_record = malloc ( sizeof (struct ipmi_ek_multi_header) );
+ fread ( &(*list_record)->header, START_DATA_OFFSET, 1, input_file);
+ if ( (*list_record)->header.len > 0 ){
+ (*list_record)->data =
+ malloc ((*list_record)->header.len);
+ if ( (*list_record)->data == NULL ){
+ lprintf(LOG_ERR, "Lack of memory");
+ }
+ else{
+ unsigned char last_record = 0;
+
+ fread ( (*list_record)->data,
+ ((*list_record)->header.len), 1, input_file);
+ if ( verbose > 0 )
+ printf("Record %d has length = %02x\n", record_count,
+ (*list_record)->header.len);
+ if ( verbose > 1 ){
+ int i;
+ printf("%02x\t", (*list_record)->header.type);
+ for ( i = 0; i < ( (*list_record)->header.len ); i++ ){
+ printf("%02x\t", (*list_record)->data[i]);
+ }
+ printf("\n");
+ }
+ ipmi_ek_add_record2list ( list_record, list_head, list_last );
+ /*mask the 8th bits to see if it is the last record*/
+ last_record = ((*list_record)->header.format) & 0x80;
+ if ( last_record ){
+ break;
+ }
+ }
+ }
+ record_count++;
+ }
+ }
+ fclose( input_file );
+ return_status = OK_STATUS;
+ }
+ return return_status;
+}
+
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_add_record2list
+*
+* Description: this function adds a sigle FRU multi record to a linked list of
+* FRU multi record.
+*
+* Restriction: None
+*
+* Input/Output: record: a pointer to current record
+* list_head: a pointer to header of the list
+* list_last: a pointer to tale of the list
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_add_record2list( struct ipmi_ek_multi_header ** record,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last )
+{
+ if (*list_head == NULL) {
+ *list_head = *record;
+ (*record)->prev = NULL;
+ if (verbose > 2)
+ printf("Adding first record to list\n");
+ }
+ else {
+ (*list_last)->next = *record;
+ (*record)->prev = *list_last;
+ if (verbose > 2)
+ printf("Add 1 record to list\n");
+ }
+ *list_last = *record;
+ (*record)->next = NULL;
+}
+
+/**************************************************************************
+*
+* Function name: ipmi_ek_remove_record_from_list
+*
+* Description: this function removes a sigle FRU multi record from a linked
+* list of FRU multi record.
+*
+* Restriction: None
+*
+* Input/Output: record: a pointer to record to be deleted
+* list_head: a pointer to header of the list
+* list_last: a pointer to tale of the list
+*
+* Global: None
+*
+* Return: None
+*
+***************************************************************************/
+static void
+ipmi_ek_remove_record_from_list( struct ipmi_ek_multi_header * record,
+ struct ipmi_ek_multi_header ** list_head,
+ struct ipmi_ek_multi_header ** list_last )
+{
+ if (record->prev == NULL)
+ *list_head = record->next;
+ else
+ record->prev->next = record->next;
+ if ( record->next == NULL )
+ (*list_last) = record->prev;
+ else
+ record->next->prev = record->prev;
+ free (record);
+}
+
+#ifdef METACOMMAND
+int i_ekanalyzer(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"m:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 1; verbose = 2;
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ ipmi_ekanalyzer_usage();
+ return ERR_USAGE;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rc = ipmi_ekanalyzer_main(intf, argc, argv);
+
+ ipmi_close_();
+ return rc;
+}
+
+/*end iekanalyzer.c*/
diff --git a/util/iekanalyzer.h b/util/iekanalyzer.h
new file mode 100644
index 0000000..452b935
--- /dev/null
+++ b/util/iekanalyzer.h
@@ -0,0 +1,521 @@
+/*
+ * Copyright (c) 2007 Kontron Canada, Inc. All Rights Reserved.
+ *
+ * Base on code from
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_EKANALYZER_H
+#define IPMI_EKANALYZER_H
+
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+#if __WORDSIZE == 64
+#define uint64_t unsigned long int
+#else
+#define uint64_t unsigned long long
+#endif
+#define TRUE 1
+#define FALSE 0
+#ifndef tboolean
+#define tboolean int
+#endif
+// struct ipmi_intf;
+
+#define RTM_FRU_FILE 0x00
+#define A1_AMC_FRU_FILE 0x01
+#define A2_AMC_FRU_FILE 0x02
+#define A3_AMC_FRU_FILE 0x03
+#define A4_AMC_FRU_FILE 0x04
+#define B1_AMC_FRU_FILE 0x05
+#define B2_AMC_FRU_FILE 0x06
+#define B3_AMC_FRU_FILE 0x07
+#define B4_AMC_FRU_FILE 0x08
+#define ON_CARRIER_FRU_FILE 0x09
+#define CONFIG_FILE 0x0A
+#define SHELF_MANAGER_FRU_FILE 0x0B
+
+#define MIN_ARGUMENT 0x02
+#define RTM_IPMB_L 0x90
+
+#define MAX_FILE_NUMBER 8
+/* this voltag is specified in AMC.0 specification Table 3-10 */
+#define AMC_VOLTAGE 12 /*volts*/
+
+#define SIZE_OF_GUID 16
+#define FRU_RADIAL_IPMB0_LINK_MAPPING 0x15
+
+//struct valstr {
+ // uint16_t val;
+ // const char * str;
+//};
+//const char * val2str(ushort val, const struct valstr *vs);
+
+#ifndef OEM_FRU_H
+#define OEM_FRU_H
+
+#define GET_FRU_INFO 0x10
+#define GET_FRU_DATA 0x11
+#define SET_FRU_DATA 0x12
+
+enum {
+ FRU_CHASSIS_PARTNO,
+ FRU_CHASSIS_SERIAL,
+ FRU_BOARD_MANUF,
+ FRU_BOARD_PRODUCT,
+ FRU_BOARD_SERIAL,
+ FRU_BOARD_PARTNO,
+ FRU_PRODUCT_MANUF,
+ FRU_PRODUCT_NAME,
+ FRU_PRODUCT_PARTNO,
+ FRU_PRODUCT_VERSION,
+ FRU_PRODUCT_SERIAL,
+ FRU_PRODUCT_ASSET,
+};
+
+struct fru_area_chassis {
+ uint8_t area_ver;
+ uint8_t type;
+ uint16_t area_len;
+ char * part;
+ char * serial;
+};
+
+struct fru_area_board {
+ uint8_t area_ver;
+ uint8_t lang;
+ uint16_t area_len;
+ uint32_t mfg_date_time;
+ char * mfg;
+ char * prod;
+ char * serial;
+ char * part;
+ char * fru;
+};
+
+struct fru_area_product {
+ uint8_t area_ver;
+ uint8_t lang;
+ uint16_t area_len;
+ char * mfg;
+ char * name;
+ char * part;
+ char * version;
+ char * serial;
+ char * asset;
+ char * fru;
+};
+
+#pragma pack(1)
+struct fru_info {
+ uint16_t size;
+ uint8_t access:1;
+}; //__attribute__ ((packed));
+
+struct fru_header {
+ uint8_t version;
+ struct {
+ uint8_t internal;
+ uint8_t chassis;
+ uint8_t board;
+ uint8_t product;
+ uint8_t multi;
+ } offset;
+ uint8_t pad;
+ uint8_t checksum;
+}; //__attribute__ ((packed));
+
+struct fru_multirec_header {
+#define FRU_RECORD_TYPE_POWER_SUPPLY_INFORMATION 0x00
+#define FRU_RECORD_TYPE_DC_OUTPUT 0x01
+#define FRU_RECORD_TYPE_DC_LOAD 0x02
+#define FRU_RECORD_TYPE_MANAGEMENT_ACCESS 0x03
+#define FRU_RECORD_TYPE_BASE_COMPATIBILITY 0x04
+#define FRU_RECORD_TYPE_EXTENDED_COMPATIBILITY 0x05
+#define FRU_RECORD_TYPE_OEM_EXTENSION 0xc0
+ uint8_t type;
+ uint8_t format;
+ uint8_t len;
+ uint8_t record_checksum;
+ uint8_t header_checksum;
+}; //__attribute__ ((packed));
+
+struct fru_multirec_powersupply {
+#if WORDS_BIGENDIAN
+ uint16_t capacity;
+#else
+ uint16_t capacity:12;
+ uint16_t __reserved1:4;
+#endif
+ uint16_t peak_va;
+ uint8_t inrush_current;
+ uint8_t inrush_interval;
+ uint16_t lowend_input1;
+ uint16_t highend_input1;
+ uint16_t lowend_input2;
+ uint16_t highend_input2;
+ uint8_t lowend_freq;
+ uint8_t highend_freq;
+ uint8_t dropout_tolerance;
+#if WORDS_BIGENDIAN
+ uint8_t __reserved2:3;
+ uint8_t tach:1;
+ uint8_t hotswap:1;
+ uint8_t autoswitch:1;
+ uint8_t pfc:1;
+ uint8_t predictive_fail:1;
+#else
+ uint8_t predictive_fail:1;
+ uint8_t pfc:1;
+ uint8_t autoswitch:1;
+ uint8_t hotswap:1;
+ uint8_t tach:1;
+ uint8_t __reserved2:3;
+#endif
+ uint16_t peak_cap_ht;
+#if WORDS_BIGENDIAN
+ uint8_t combined_voltage1:4;
+ uint8_t combined_voltage2:4;
+#else
+ uint8_t combined_voltage2:4;
+ uint8_t combined_voltage1:4;
+#endif
+ uint16_t combined_capacity;
+ uint8_t rps_threshold;
+}; //__attribute__ ((packed));
+
+struct fru_multirec_dcoutput {
+#if WORDS_BIGENDIAN
+ uint8_t standby:1;
+ uint8_t __reserved:3;
+ uint8_t output_number:4;
+#else
+ uint8_t output_number:4;
+ uint8_t __reserved:3;
+ uint8_t standby:1;
+#endif
+ short nominal_voltage;
+ short max_neg_dev;
+ short max_pos_dev;
+ uint16_t ripple_and_noise;
+ uint16_t min_current;
+ uint16_t max_current;
+}; //__attribute__ ((packed));
+
+struct fru_multirec_dcload {
+#if WORDS_BIGENDIAN
+ uint8_t __reserved:4;
+ uint8_t output_number:4;
+#else
+ uint8_t output_number:4;
+ uint8_t __reserved:4;
+#endif
+ short nominal_voltage;
+ short min_voltage;
+ short max_voltage;
+ uint16_t ripple_and_noise;
+ uint16_t min_current;
+ uint16_t max_current;
+}; //__attribute__ ((packed));
+
+struct fru_multirec_oem_header {
+ unsigned char mfg_id[3];
+#define FRU_PICMG_BACKPLANE_P2P 0x04
+#define FRU_PICMG_ADDRESS_TABLE 0x10
+#define FRU_PICMG_SHELF_POWER_DIST 0x11
+#define FRU_PICMG_SHELF_ACTIVATION 0x12
+#define FRU_PICMG_SHMC_IP_CONN 0x13
+#define FRU_PICMG_BOARD_P2P 0x14
+#define FRU_AMC_CURRENT 0x16
+#define FRU_AMC_ACTIVATION 0x17
+#define FRU_AMC_CARRIER_P2P 0x18
+#define FRU_AMC_P2P 0x19
+#define FRU_AMC_CARRIER_INFO 0x1a
+#define FRU_UTCA_FRU_INFO_TABLE 0x20
+#define FRU_UTCA_CARRIER_MNG_IP 0x21
+#define FRU_UTCA_CARRIER_INFO 0x22
+#define FRU_UTCA_CARRIER_LOCATION 0x23
+#define FRU_UTCA_SHMC_IP_LINK 0x24
+#define FRU_UTCA_POWER_POLICY 0x25
+#define FRU_UTCA_ACTIVATION 0x26
+#define FRU_UTCA_PM_CAPABILTY 0x27
+#define FRU_UTCA_FAN_GEOGRAPHY 0x28
+#define FRU_UTCA_CLOCK_MAPPING 0x29
+#define FRU_UTCA_MSG_BRIDGE_POLICY 0x2A
+#define FRU_UTCA_OEM_MODULE_DESC 0x2B
+#define FRU_PICMG_CLK_CARRIER_P2P 0x2C
+#define FRU_PICMG_CLK_CONFIG 0x2D
+ unsigned char record_id;
+ unsigned char record_version;
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_guid {
+ unsigned char guid[16];
+}; //__attribute__ ((packed));
+
+#ifndef HAVE_FRU_PICMG_EXT
+#define HAVE_FRU_PICMG_EXT
+struct fru_picmgext_link_desc {
+#ifndef WORDS_BIGENDIAN
+ unsigned int desig_channel:6;
+ unsigned int desig_if:2;
+ unsigned int desig_port:4;
+#define FRU_PICMGEXT_LINK_TYPE_BASE 0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET 0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND 0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR 0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE 0x05
+ unsigned int type:8;
+ unsigned int ext:4;
+ unsigned int grouping:8;
+#else
+ unsigned int grouping:8;
+ unsigned int ext:4;
+#define FRU_PICMGEXT_LINK_TYPE_BASE 0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET 0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND 0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR 0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE 0x05
+ unsigned int type:8;
+ unsigned int desig_port:4;
+ unsigned int desig_if:2;
+ unsigned int desig_channel:6;
+#endif
+}; //__attribute__ ((packed));
+
+
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED 0x00
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED1 0x01
+#define FRU_PICMGEXT_AMC_LINK_TYPE_PCI_EXPRESS 0x02
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING1 0x03
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING2 0x04
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET 0x05
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO 0x06
+#define FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE 0x07
+
+/* This is used in command, not in FRU */
+struct fru_picmgext_amc_link_info {
+ unsigned char linkInfo[3];
+}; //__attribute__ ((packed));
+
+#endif
+
+struct fru_picmgext_amc_link_desc_core {
+#ifndef WORDS_BIGENDIAN
+ unsigned int designator:12;
+ unsigned int type:8;
+ unsigned int ext:4;
+ unsigned int grouping:8;
+#else
+ unsigned int grouping:8;
+ unsigned int ext:4;
+ unsigned int type:8;
+ unsigned int designator:12;
+#endif
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_amc_link_desc_extra {
+#ifndef WORDS_BIGENDIAN
+ unsigned char asymetricMatch:2;
+ unsigned char reserved:6;
+#else
+ unsigned char reserved:6;
+ unsigned char asymetricMatch:2;
+#endif
+}; //__attribute__ ((packed));
+
+
+struct fru_picmgext_amc_link_desc {
+#ifndef WORDS_BIGENDIAN
+ struct fru_picmgext_amc_link_desc_core core;/* lsb */
+ struct fru_picmgext_amc_link_desc_extra extra;
+#else
+ struct fru_picmgext_amc_link_desc_extra extra;
+ struct fru_picmgext_amc_link_desc_core core;/* lsb */
+#endif
+}; //__attribute__ ((packed));
+
+
+#define FRU_PICMGEXT_OEM_SWFW 0x03
+#define OEM_SWFW_NBLOCK_OFFSET 0x05
+#define OEM_SWFW_FIELD_START_OFFSET 0x06
+
+
+struct fru_picmgext_chn_desc {
+#ifndef WORDS_BIGENDIAN
+ unsigned char remote_slot:8;
+ unsigned char remote_chn:5;
+ unsigned char local_chn:5;
+ unsigned char:6;
+#else
+ unsigned char:6;
+ unsigned char local_chn:5;
+ unsigned char remote_chn:5;
+ unsigned char remote_slot:8;
+#endif
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_slot_desc {
+ unsigned char chan_type;
+ unsigned char slot_addr;
+ unsigned char chn_count;
+}; //__attribute__ ((packed));
+
+#define FRU_PICMGEXT_DESIGN_IF_BASE 0x00
+#define FRU_PICMGEXT_DESIGN_IF_FABRIC 0x01
+#define FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL 0x02
+#define FRU_PICMGEXT_DESIGN_IF_RESERVED 0x03
+
+struct fru_picmgext_carrier_activation_record {
+ unsigned short max_internal_curr;
+ unsigned char allowance_for_readiness;
+ unsigned char module_activation_record_count;
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_activation_record {
+ unsigned char ibmb_addr;
+ unsigned char max_module_curr;
+ unsigned char reserved;
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_carrier_p2p_record {
+ unsigned char resource_id;
+ unsigned char p2p_count;
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_carrier_p2p_descriptor {
+#ifndef WORDS_BIGENDIAN
+ unsigned char remote_resource_id;
+ unsigned short remote_port:5;
+ unsigned short local_port:5;
+ unsigned short reserved:6;
+#else
+ unsigned short reserved:6;
+ unsigned short local_port:5;
+ unsigned short remote_port:5;
+ unsigned char remote_resource_id;
+#endif
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_amc_p2p_record {
+#ifndef WORDS_BIGENDIAN
+ unsigned char resource_id :4;
+ unsigned char /* reserved */ :3;
+ unsigned char record_type :1;
+#else
+ unsigned char record_type :1;
+ unsigned char /* reserved */ :3;
+ unsigned char resource_id :4;
+#endif
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_amc_channel_desc_record {
+#ifndef WORDS_BIGENDIAN
+ unsigned char lane0port :5;
+ unsigned char lane1port :5;
+ unsigned char lane2port :5;
+ unsigned char lane3port :5;
+ unsigned char /*reserved */ :4;
+#else
+ unsigned char /*reserved */ :4;
+ unsigned char lane3port :5;
+ unsigned char lane2port :5;
+ unsigned char lane1port :5;
+ unsigned char lane0port :5;
+#endif
+}; //__attribute__ ((packed));
+
+struct fru_picmgext_amc_link_desc_record {
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE 0x02
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS1 0x03
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS2 0x04
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET 0x05
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO 0x06
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE 0x07
+
+ #define AMC_LINK_TYPE_EXT_PCIE_G1_NSSC 0x00
+ #define AMC_LINK_TYPE_EXT_PCIE_G1_SSC 0x01
+ #define AMC_LINK_TYPE_EXT_PCIE_G2_NSSC 0x02
+ #define AMC_LINK_TYPE_EXT_PCIE_G2_SSC 0x03
+
+ #define AMC_LINK_TYPE_EXT_ETH_1000_BX 0x00
+ #define AMC_LINK_TYPE_EXT_ETH_10G_XAUI 0x01
+
+ #define AMC_LINK_TYPE_EXT_STORAGE_FC 0x00
+ #define AMC_LINK_TYPE_EXT_STORAGE_SATA 0x01
+ #define AMC_LINK_TYPE_EXT_STORAGE_SAS 0x02
+#ifndef WORDS_BIGENDIAN
+ unsigned short channel_id :8;
+ unsigned short port_flag_0 :1;
+ unsigned short port_flag_1 :1;
+ unsigned short port_flag_2 :1;
+ unsigned short port_flag_3 :1;
+ unsigned short type :8;
+ unsigned short type_ext :4;
+ unsigned short group_id :8;
+ unsigned char asym_match :2;
+ unsigned char /* reserved */ :6;
+#else
+ unsigned char /* reserved */ :6;
+ unsigned char asym_match :2;
+ unsigned short group_id :8;
+ unsigned short type_ext :4;
+ unsigned short type :8;
+ unsigned short port_flag_3 :1;
+ unsigned short port_flag_2 :1;
+ unsigned short port_flag_1 :1;
+ unsigned short port_flag_0 :1;
+ unsigned short channel_id :8;
+#endif
+}; //__attribute__ ((packed));
+#pragma pack()
+
+/* FRU Board manufacturing date */
+static const uint64_t secs_from_1970_1996 = 820450800;
+
+#ifdef NOT_USED
+static const char * combined_voltage_desc[] = { //__attribute__((unused))
+"12 V", "-12 V", "5 V", "3.3 V"};
+static const char * chassis_type_desc[] = { //__attribute__((unused))
+ "Unspecified", "Other", "Unknown",
+ "Desktop", "Low Profile Desktop", "Pizza Box",
+ "Mini Tower", "Tower",
+ "Portable", "LapTop", "Notebook", "Hand Held",
+ "Docking Station", "All in One", "Sub Notebook",
+ "Space-saving", "Lunch Box", "Main Server Chassis",
+ "Expansion Chassis", "SubChassis", "Bus Expansion Chassis",
+ "Peripheral Chassis", "RAID Chassis", "Rack Mount Chassis"};
+#endif
+
+#endif /* OEM_FRU_H */
+
+#endif /* IPMI_EKANALYZER_H */
diff --git a/util/ievents.c b/util/ievents.c
new file mode 100644
index 0000000..72c0b24
--- /dev/null
+++ b/util/ievents.c
@@ -0,0 +1,2505 @@
+/*
+ * ievents.c
+ *
+ * This file decodes the IPMI event into a readable string.
+ * It is used by showsel.c and getevent.c.
+ *
+ * ievents.c compile flags:
+ * METACOMMAND - defined if building for ipmiutil meta-command binary
+ * ALONE - defined if building for ievents standalone binary
+ * else it could be compiled with libipmiutil.a
+ * LINUX, BSD, WIN32, DOS - defined for that OS
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * Copyright (c) 2009 Kontron America, Inc.
+ * Copyright (c) 2006 Intel Corporation.
+ *
+ * 05/26/05 Andy Cress - created from showsel.c (see there for history)
+ * 06/20/05 Andy Cress - changed PowerSupply present/not to Inserted/Removed
+ * 08/01/05 Andy Cress - added more Power Unit & Battery descriptions
+ * 03/02/06 Andy Cress - more decoding for Power Unit 0b vs. 6f
+ * 04/11/07 Andy Cress - added events -p decoding for PET data
+ * 10/03/07 Andy Cress - added file_grep for -p in Windows
+ * 03/03/08 Andy Cress - added -f to interpret raw SEL file
+ */
+/*M*
+Copyright (c) 2009 Kontron America, Inc.
+Copyright (c) 2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#ifdef WIN32
+#include <windows.h>
+#include <stdlib.h>
+#include <string.h>
+#elif defined(DOS)
+#include <dos.h>
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <syslog.h>
+#endif
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "ievents.h"
+
+#define SELprintf printf
+#define SMS_SA 0x41
+#define SMI_SA 0x21
+static char *progver = "2.93";
+static char *progname = "ievents";
+static char fsensdesc = 0; /* 1= get extended sensor descriptions*/
+static char fcanonical = 0; /* 1= show canonical, delimited output*/
+static char fgetdevid = 0; /* 1= get device ID */
+static char fnewevt = 0; /* 1= generate New event */
+static char futc = 0; /* 1= raw UTC time */
+static uchar thr_sa = SMS_SA; /* 0x41 (Sms) used by ipmitool PlarformEvents */
+static void *sdrcache = NULL;
+static int pet_guid = 8; /*bytes in the input data for the GUID*/
+static char bcomma = ',';
+static char bdelim = BDELIM; /* '|' */
+#ifdef ALONE
+ char fdebug = 0; /* 1= debug output, standalone*/
+static char fsm_debug = 0;
+#else
+extern char fdebug; /* 1= debug output, from ipmicmd.c*/
+extern char fsm_debug; /*mem_if.c*/
+#endif
+#define SDR_SZ 80
+
+#pragma pack(1)
+typedef struct
+{
+ ushort record_id;
+ uchar record_type;
+ uint timestamp;
+ ushort generator_id; /*slave_addr/channel*/
+ uchar evm_rev; //event message revision
+ uchar sensor_type;
+ uchar sensor_number;
+ uchar event_trigger;
+ uchar event_data1;
+ uchar event_data2;
+ uchar event_data3;
+} SEL_RECORD;
+#pragma pack()
+
+#ifdef WIN32
+ static char sensfil[80] = "sensor_out.txt";
+ static char sensfil2[80] = "%ipmiutildir%\\sensor_out.txt";
+ // static char outfil[64] = "stype.tmp";
+#else
+ static char sensfil[80] = "/var/lib/ipmiutil/sensor_out.txt";
+ static char sensfil2[80] = "/usr/share/ipmiutil/sensor_out.txt";
+ // static char outfil[] = "/tmp/stype.tmp";
+#endif
+ static char rawfil[80] = "";
+
+char *evt_hdr = "RecId Date/Time_______ SEV Src_ Evt_Type___ Sens# Evt_detail - Trig [Evt_data]\n";
+char *evt_hdr2 = "RecId | Date/Time | SEV | Src | Evt_Type | Sensor | Evt_detail \n";
+#ifdef MOVED
+/* moved SEV_* to ipmicmd.h */
+#define SEV_INFO 0
+#define SEV_MIN 1
+#define SEV_MAJ 2
+#define SEV_CRIT 3
+#endif
+#define NSEV 4
+char *sev_str[NSEV] = {
+ /*0*/ "INF",
+ /*1*/ "MIN",
+ /*2*/ "MAJ",
+ /*3*/ "CRT" };
+
+/* sensor_types: See IPMI 1.5 Table 36-3, IPMI 2.0 Table 42-3 */
+#define NSTYPES 0x2F
+static const char *sensor_types[NSTYPES] = {
+/* 00h */ "reserved",
+/* 01h */ "Temperature",
+/* 02h */ "Voltage",
+/* 03h */ "Current",
+/* 04h */ "Fan",
+/* 05h */ "Platform Security",
+/* 06h */ "Security Violation",
+/* 07h */ "Processor",
+/* 08h */ "Power Supply",
+/* 09h */ "Power Unit",
+/* 0Ah */ "Cooling Device",
+/* 0Bh */ "FRU Sensor",
+/* 0Ch */ "Memory",
+/* 0Dh */ "Drive Slot",
+/* 0Eh */ "POST Memory Resize",
+/* 0Fh */ "System Firmware", /*incl POST code errors*/
+/* 10h */ "Event Log", /*SEL Disabled or Cleared */
+/* 11h */ "Watchdog_1",
+/* 12h */ "System Event", /* offset 0,1,2 */
+/* 13h */ "Critical Interrupt", /* offset 0,1,2 */
+/* 14h */ "Button", /* offset 0,1,2 */
+/* 15h */ "Board",
+/* 16h */ "Microcontroller",
+/* 17h */ "Add-in Card",
+/* 18h */ "Chassis",
+/* 19h */ "Chip Set",
+/* 1Ah */ "Other FRU",
+/* 1Bh */ "Cable/Interconnect",
+/* 1Ch */ "Terminator",
+/* 1Dh */ "System Boot Initiated",
+/* 1Eh */ "Boot Error",
+/* 1Fh */ "OS Boot",
+/* 20h */ "OS Critical Stop",
+/* 21h */ "Slot/Connector",
+/* 22h */ "ACPI Power State",
+/* 23h */ "Watchdog_2",
+/* 24h */ "Platform Alert",
+/* 25h */ "Entity Presence",
+/* 26h */ "Monitor ASIC",
+/* 27h */ "LAN",
+/* 28h */ "Management Subsystem Health",
+/* 29h */ "Battery",
+/* 2Ah */ "SessionAudit",
+/* 2Bh */ "Version Change",
+/* 2Ch */ "FRU State",
+/* 2Dh */ "SMI Timeout", /* 0xF3 == OEM SMI Timeout */
+/* 2Eh */ "ME" /* 0xDC == ME Node Manager */
+};
+
+#define NFWERRS 15
+static struct { /* See Table 36-3, type 0Fh, offset 00h */
+ int code; char *msg;
+ } fwerrs[NFWERRS] = {
+ { 0x00, "Unspecified"},
+ { 0x01, "No system memory"},
+ { 0x02, "No usable memory"},
+ { 0x03, "Unrecovered Hard Disk"},
+ { 0x04, "Unrecovered System Board"},
+ { 0x05, "Unrecovered Diskette"},
+ { 0x06, "Unrecovered Hard Disk Ctlr"},
+ { 0x07, "Unrecovered PS2 USB"},
+ { 0x08, "Boot media not found"},
+ { 0x09, "Unrecovered video controller"},
+ { 0x0A, "No video device"},
+ { 0x0B, "Firmware ROM corruption"},
+ { 0x0C, "CPU voltage mismatch"},
+ { 0x0D, "CPU speed mismatch"},
+ { 0x0E, "Reserved" }
+};
+
+#define NFWSTAT 27
+static struct { /* See Table 36-3, type 0Fh, offset 01h & 02h */
+ int code; char *msg;
+ } fwstat[NFWSTAT] = {
+ { 0x00, "Unspecified"},
+ { 0x01, "Memory init"},
+ { 0x02, "Hard disk init"},
+ { 0x03, "Secondary processor"},
+ { 0x04, "User authentication"},
+ { 0x05, "User-init sys setup"},
+ { 0x06, "USB configuration"},
+ { 0x07, "PCI configuration"},
+ { 0x08, "Option ROM init"},
+ { 0x09, "Video init"},
+ { 0x0a, "Cache init"},
+ { 0x0b, "SM Bus init"},
+ { 0x0c, "Keyboard init"},
+ { 0x0d, "Mgt controller"},
+ { 0x0e, "Docking attach"},
+ { 0x0f, "Enabling docking"},
+ { 0x10, "Docking eject"},
+ { 0x11, "Disabling docking"},
+ { 0x12, "OS wake-up"},
+ { 0x13, "Starting OS boot"},
+ { 0x14, "Baseboard init"},
+ { 0x15, "reserved"},
+ { 0x16, "Floppy init"},
+ { 0x17, "Keyboard test"},
+ { 0x18, "Mouse test"},
+ { 0x19, "Primary processor"},
+ { 0x1A, "Reserved"}
+};
+
+#define NGDESC 12
+static struct {
+ ushort g_id;
+ const char desc[8];
+} gen_desc[NGDESC] = { /*empirical, format defined in IPMI 1.5 Table 23-5 */
+ { 0x0000, "IPMB"},
+ { 0x0001, "EFI "},
+ { 0x0003, "BIOS"}, /* BIOS POST */
+ { BMC_SA, "BMC "}, /* 0x0020==BMC_SA*/
+ { SMI_SA, "SMI "}, /* 0x0021==SMI_SA, platform events */
+ { 0x0028, "CHAS"}, /* Chassis Bridge Controller */
+ { 0x0031, "mSMI"}, /* BIOS SMI/POST errors on miniBMC or ia64 */
+ { 0x0033, "Bios"}, /* BIOS SMI (runtime), usually for memory errors */
+ { SMS_SA, "Sms "}, /* 0x0041==SmsOs for MS Win2008 Boot, ipmitool event */
+ { 0x002C, "ME "}, /* ME Node Manager for S5500 */
+ { 0x602C, "ME "}, /* ME Node Manager for S5500/i7 bus=0x6, sa=0x2C */
+ { HSC_SA, "HSC "} /* 0x00C0==HSC_SA for SAF-TE Hot-Swap Controller*/
+};
+
+#define NCRITS 10
+char * crit_int_str[NCRITS] = { /* Critical Interrupt descriptions */
+ /*00*/ "FP NMI ", /* Front Panel NMI */
+ /*01*/ "Bus Timout",
+ /*02*/ "IOch NMI ", /* IO channel check NMI */
+ /*03*/ "Soft NMI ",
+ /*04*/ "PCI PERR ",
+ /*05*/ "PCI SERR ",
+ /*06*/ "EISA Timout",
+ /*07*/ "Bus Warn ", /* Bus Correctable Error */
+ /*08*/ "Bus Error", /* Bus Uncorrectable Error */
+ /*09*/ "Fatal NMI" };
+
+#define NBOOTI 8
+char * boot_init_str[NBOOTI] = { /* System Boot Initiated */
+ /*00*/ "Power Up ",
+ /*01*/ "Hard Reset",
+ /*02*/ "Warm Reset",
+ /*03*/ "PXE Boot ",
+ /*04*/ "Diag Boot ",
+ /*05*/ "SW Hard Reset",
+ /*06*/ "SW Warm Reset",
+ /*07*/ "RestartCause" };
+
+#define NOSBOOT 8
+char * osboot_str[NOSBOOT] = { /* OS Boot */
+ /*00*/ "A: boot completed",
+ /*01*/ "C: boot completed",
+ /*02*/ "PXE boot completed",
+ /*03*/ "Diag boot completed",
+ /*04*/ "CDROM boot completed",
+ /*05*/ "ROM boot completed",
+ /*06*/ "Other boot completed" };
+
+#define NSLOTC 9
+char * slot_str[NSLOTC] = { /* Slot/Connector descriptions */
+ /*00*/ "Fault ",
+ /*01*/ "Identify",
+ /*02*/ "Inserted",
+ /*03*/ "InsReady",
+ /*04*/ "RemReady",
+ /*05*/ "PowerOff",
+ /*06*/ "RemRequest",
+ /*07*/ "Interlock",
+ /*08*/ "Disabled" };
+
+#define NBATT 3
+char * batt_str[NBATT] = { /* Battery assert descriptions */
+ /*00*/ "Low",
+ /*01*/ "Failed",
+ /*02*/ "Present" };
+char * batt_clr[NBATT] = { /* Battery deassert descriptions */
+ /*00*/ "Low OK",
+ /*01*/ "Failed OK",
+ /*02*/ "Absent" };
+
+#define N_NMH 6
+char * nmh_str[N_NMH] = { /* ME Node Manager Health (73) descriptions */
+ /*10*/ "Policy Misconfig",
+ /*11*/ "Power Sensor Err",
+ /*12*/ "Inlet Temp Sensor Err",
+ /*13*/ "Host Comm Err",
+ /*14*/ "RTC Sync Err" ,
+ /*15*/ "Plat Shutdown" };
+
+#define N_NMFW 6
+char * nmfw_str[N_NMFW] = { /* ME Firmware Health (75) descriptions */
+ /*00*/ "Forced GPIO Recov",
+ /*01*/ "Image Exec Fail",
+ /*02*/ "Flash Erase Error",
+ /*03*/ "Flash Corrupt" ,
+ /*04*/ "Internal Watchdog Timeout", // FW Watchdog Timeout, need to flash ME
+ /*05*/ "BMC Comm Error" };
+
+#define N_NM 4
+char * nm_str[N_NM] = { /* Node Manager descriptions */
+ /*72*/ "NM Exception", /*or NM Alert Threshold*/
+ /*73*/ "NM Health",
+ /*74*/ "NM Capabilities",
+ /*75*/ "FW Health" };
+
+#define NPROC 11
+char * proc_str[NPROC] = { /* Processor descriptions */
+ /*00*/ "IERR",
+ /*01*/ "Thermal Trip",
+ /*02*/ "FRB1/BIST failure",
+ /*03*/ "FRB2 timeout",
+ /*04*/ "FRB3 Proc error",
+ /*05*/ "Config error",
+ /*06*/ "SMBIOS CPU error",
+ /*07*/ "Present",
+ /*08*/ "Disabled",
+ /*09*/ "Terminator",
+ /*0A*/ "Throttled" };
+
+#define NACPIP 15
+char * acpip_str[NACPIP] = { /* ACPI Power State descriptions */
+ /*00*/ "S0/G0 Working",
+ /*01*/ "S1 sleeping, proc/hw context maintained",
+ /*02*/ "S2 sleeping, proc context lost",
+ /*03*/ "S3 sleeping, proc/hw context lost, mem ok", /*42 chars*/
+ /*04*/ "S4 non-volatile sleep/suspend",
+ /*05*/ "S5/G2 soft-off",
+ /*06*/ "S4/S5 soft-off, no specific state",
+ /*07*/ "G3/Mechanical off",
+ /*08*/ "Sleeping in an S1/S2/S3 state",
+ /*09*/ "G1 sleeping",
+ /*0A*/ "S5 entered by override",
+ /*0B*/ "Legacy ON state",
+ /*0C*/ "Legacy OFF state",
+ /*0D*/ "Unknown",
+ /*0E*/ "Unknown" };
+
+#define NAUDIT 2
+char * audit_str[NAUDIT] = { /* Session Audit descriptions */
+ /*00*/ "Activated",
+ /*01*/ "Deactivated"};
+
+#define N_AVAIL 9
+char * avail_str[N_AVAIL] = { /* Discrete Availability, evtype 0x0A */
+ /*00*/ "chg to Running",
+ /*01*/ "chg to In Test",
+ /*02*/ "chg to Power Off",
+ /*03*/ "chg to On Line",
+ /*04*/ "chg to Off Line",
+ /*05*/ "chg to Off Duty",
+ /*06*/ "chg to Degraded",
+ /*07*/ "chg to Power Save",
+ /*08*/ "Install Error"};
+
+
+#define NSDESC 87
+struct {
+ ushort genid; /* generator id: BIOS, BMC, etc. (slave_addr/channel) */
+ uchar s_typ; /* 1=temp,2=voltage,4=fan,... */
+ uchar s_num;
+ uchar evtrg; /* event trigger/type, see IPMI 1.5 table 36.1 & 36.2 */
+ uchar data1;
+ uchar data2;
+ uchar data3;
+ uchar sev; /* 0=SEV_INFO, 1=SEV_MIN, 2=SEV_MAJ, 3=SEV_CRIT */
+ const char desc[40];
+} sens_desc[NSDESC] = { /* if value is 0xff, matches any value */
+{0xffff,0x05, 0xff, 0x6f, 0x40,0xff,0xff, 1,"Chassis Intrusion"}, /*chassis*/
+{0xffff,0x05, 0xff, 0xef, 0x40,0xff,0xff, 0,"Chassis OK"}, /*chassis*/
+{0xffff,0x05, 0xff, 0x6f, 0x44,0xff,0xff, 1,"LAN unplugged"}, /*chassis*/
+{0xffff,0x05, 0xff, 0xef, 0x44,0xff,0xff, 0,"LAN restored "}, /*chassis*/
+{0xffff,0x06, 0xff, 0xff, 0x45,0xff,0xff, 0,"Password"}, /*security*/
+{0xffff,0x07, 0xff, 0xff, 0x41,0xff,0xff, 3,"Thermal trip"}, /*processor*/
+{0xffff,0x08, 0xff, 0x6f, 0x40,0xff,0xff, 0,"Inserted"}, /*PowerSupply*/
+{0xffff,0x08, 0xff, 0x6f, 0x41,0xff,0xff, 2,"Failure detected"},/*PowerSupply*/
+{0xffff,0x08, 0xff, 0x6f, 0x42,0xff,0xff, 1,"Predictive failure"},
+{0xffff,0x08, 0xff, 0x6f, 0x43,0xff,0xff, 0,"AC Lost"},
+{0xffff,0x08, 0xff, 0x6f, 0x46,0xff,0xff, 2,"Config Error"},
+{0xffff,0x08, 0xff, 0xef, 0x40,0xff,0xff, 1,"Removed"}, /*PowerSupply*/
+{0xffff,0x08, 0xff, 0xef, 0x41,0xff,0xff, 0,"is OK "}, /*PowerSupply*/
+{0xffff,0x08, 0xff, 0xef, 0x42,0xff,0xff, 0,"Predictive OK"},
+{0xffff,0x08, 0xff, 0xef, 0x43,0xff,0xff, 0,"AC Regained"}, /*PowerSupply*/
+{0xffff,0x08, 0xff, 0xef, 0x46,0xff,0xff, 0,"Config OK now"},
+{0xffff,0x0c, 0xff, 0xff, 0x00,0xff,0xff, 1,"Correctable ECC"}, /*memory*/
+{0xffff,0x0f, 0x06, 0xff, 0xff,0xff,0xff, 2,"POST Code"},
+{0xffff,0x10, 0x09, 0xff, 0x42,0x0f,0xff, 0,"Log Cleared"},
+{0xffff,0x10, 0xff, 0xff, 0x02,0xff,0xff, 0,"Log Cleared"},
+{0xffff,0x10, 0xff, 0xff, 0xc0,0x03,0xff, 1,"ECC Memory Errors"},
+ /* Often see these 3 Boot records with reboot:
+ * 0003 12 83 6f 05 00 ff = System/SEL ClockSync_1 (start of POST)
+ * 0003 12 83 6f 05 80 ff = System/SEL ClockSync_2 (end of POST)
+ * 0003 12 83 6f 01 ff ff = OEM System Boot Event (after POST, loader), or
+ * 0003 12 83 6f 41 0f ff = OEM System Boot Event (same w 01 & 41)
+ * can be either 0003 (BIOS) or 0001 (EFI)
+ */
+{0xffff,0x12, 0xfe, 0xff, 0xc5,0x00,0xff, 0,"Boot: ClockSync_1"},
+{0xffff,0x12, 0xfe, 0xff, 0xc5,0x80,0xff, 0,"Boot: ClockSync_2"},
+{0xffff,0x12, 0x83, 0xff, 0x05,0x00,0xff, 0,"Boot: ClockSync_1"},
+{0xffff,0x12, 0x83, 0xff, 0x05,0x80,0xff, 0,"Boot: ClockSync_2"},
+{0xffff,0x12, 0x83, 0xff, 0x01,0xff,0xff, 0,"OEM System Booted"},
+{0x0001,0x12, 0x08, 0xff, 0x01,0xff,0xff, 0,"OEM System Booted"}, /*ia64*/
+{0xffff,0x12, 0x01, 0x6f, 0x01,0xff,0xff, 0,"OEM System Booted"}, /*S5000*/
+{0xffff,0x12, 0x38, 0x6f, 0x00,0xff,0xff, 0,"OEM System Booted"}, /*KTC*/
+{0xffff,0x12, 0x38, 0xef, 0x00,0xff,0xff, 0,"OEM System Booted"}, /*KTC*/
+{0x0031,0x12, 0x00, 0x6f, 0xc3,0xff,0xff, 0,"PEF Action"}, /*ia64*/
+{BMC_SA,0x12, 0x83, 0x6f, 0x80,0xff,0xff, 0,"System Reconfigured"}, /*BMC*/
+{BMC_SA,0x12, 0x83, 0x0b, 0x80,0xff,0xff, 0,"System Reconfigured"}, /*BMC*/
+{BMC_SA,0x12, 0x0b, 0x6f, 0x80,0xff,0xff, 0,"System Reconfigured"}, /*BMC*/
+{BMC_SA,0x12, 0x83, 0xff, 0x41,0xff,0xff, 0,"OEM System Boot"}, /*BMC*/
+{BMC_SA,0x12, 0x83, 0x6f, 0x42,0xff,0xff, 2,"System HW failure"}, /*BMC*/
+{BMC_SA,0x12, 0x83, 0x6f, 0x04,0xff,0xff, 0,"PEF Action"}, /*BMC*/
+{HSC_SA,0x0d, 0xff, 0x08, 0x00,0xff,0xff, 1,"Device Removed"}, /*HSC*/
+{HSC_SA,0x0d, 0xff, 0x08, 0x01,0xff,0xff, 0,"Device Inserted"}, /*HSC*/
+{0xffff,0x0d, 0xff, 0x6f, 0x00,0xff,0xff, 0,"Drive present"}, /*Romley BMC*/
+{0xffff,0x0d, 0xff, 0xef, 0x00,0xff,0xff, 0,"Drive removed"}, /*BMC*/
+{0xffff,0x0d, 0xff, 0x6f, 0x01,0xff,0xff, 2,"Drive fault"},
+{0xffff,0x0d, 0xff, 0xef, 0x01,0xff,0xff, 0,"Drive fault OK"},
+{0xffff,0x0d, 0xff, 0x6f, 0x02,0xff,0xff, 1,"Drive predict fail"},
+{0xffff,0x0d, 0xff, 0x6f, 0x07,0xff,0xff, 0,"Rebuild in progress"},
+{0xffff,0x0d, 0xff, 0xef, 0x07,0xff,0xff, 0,"Rebuild complete"},
+{0xffff,0x14, 0xff, 0xff, 0x42,0xff,0xff, 1,"Reset Button pressed"},
+{0xffff,0x14, 0xff, 0xff, 0x40,0xff,0xff, 1,"Power Button pressed"},
+{0xffff,0x14, 0xff, 0xff, 0x01,0xff,0xff, 0,"ID Button pressed"},
+{0xffff,0x23, 0xff, 0xff, 0x40,0xff,0xff, 2,"Expired, no action"},/*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x41,0xff,0xff, 3,"Hard Reset action"}, /*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x42,0xff,0xff, 3,"Power down action"}, /*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x43,0xff,0xff, 3,"Power cycle action"},/*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x48,0xff,0xff, 2,"Timer interrupt"}, /*watchdog2*/
+{0xffff,0xf3, 0xff, 0x83, 0x41,0xff,0xff, 0,"SMI de-asserted"},
+{0xffff,0xf3, 0xff, 0x03, 0x41,0xff,0xff, 3,"SMI asserted"},
+{0xffff,0x20, 0x00, 0xff, 0xff,0xff,0xff, 3,"OS Kernel Panic"},
+{0xffff,0x01, 0xff, 0x03, 0x01,0xff,0xff, 2,"Temp Asserted"}, /*Discrete temp*/
+{0xffff,0x01, 0xff, 0x83, 0x01,0xff,0xff, 0,"Temp OK"}, /*Discrete ok*/
+{0xffff,0x01, 0xff, 0x05, 0x01,0xff,0xff, 2,"Temp Asserted"}, /*CPU Hot */
+{0xffff,0x01, 0xff, 0x85, 0x01,0xff,0xff, 0,"Temp OK"}, /*CPU Hot ok*/
+{0xffff,0x01, 0xff, 0x07, 0x01,0xff,0xff, 2,"Temp Asserted"}, /*Discrete temp*/
+{0xffff,0x01, 0xff, 0x87, 0x01,0xff,0xff, 0,"Temp OK"}, /*Discrete ok*/
+ /*Thresholds apply to sensor types 1=temp, 2=voltage, 3=current, 4=fan*/
+ /*Note that last 2 bytes usu show actual & threshold values*/
+ /*evtrg: 0x01=thresh, 0x81=restored/deasserted */
+{0xffff,0xff, 0xff, 0x01, 0x50,0xff,0xff, 1,"Lo Noncrit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x51,0xff,0xff, 0,"Lo NoncritH OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x52,0xff,0xff, 2,"Lo Crit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x53,0xff,0xff, 0,"Lo CritHi OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x54,0xff,0xff, 3,"Lo Unrec thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x55,0xff,0xff, 0,"Lo UnrecH OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x56,0xff,0xff, 0,"Hi NoncritL OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x57,0xff,0xff, 1,"Hi Noncrit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x58,0xff,0xff, 0,"Hi CritLo OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x59,0xff,0xff, 2,"Hi Crit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x5A,0xff,0xff, 0,"Hi UnrecL OK now"},
+{0xffff,0xff, 0xff, 0x01, 0x5B,0xff,0xff, 3,"Hi Unrec thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x50,0xff,0xff, 0,"LoN thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x51,0xff,0xff, 1,"LoNoncrit thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x52,0xff,0xff, 0,"LoC thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x53,0xff,0xff, 2,"LoCritHi thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x54,0xff,0xff, 0,"LoU thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x55,0xff,0xff, 3,"LoUnrecH thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x56,0xff,0xff, 1,"HiNoncrit thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x57,0xff,0xff, 0,"HiN thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x58,0xff,0xff, 2,"HiCritLo thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x59,0xff,0xff, 0,"HiC thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x5A,0xff,0xff, 3,"HiURecLo thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x5B,0xff,0xff, 0,"HiU thresh OK now"}
+};
+
+#define NENTID 53
+static struct { char * str; uchar styp; } entitymap[NENTID] = {
+/* 00 */ { "unspecified", 0x00 },
+/* 01 */ { "other", 0x00 },
+/* 02 */ { "unknown", 0x00 },
+/* 03 */ { "Processor", 0x07 },
+/* 04 */ { "Disk", 0x00 },
+/* 05 */ { "Peripheral bay", 0x0D },
+/* 06 */ { "Management module", 0x00 },
+/* 07 */ { "System board", 0x00 },
+/* 08 */ { "Memory module", 0x00 },
+/* 09 */ { "Processor module", 0x00 },
+/* 10 */ { "Power supply", 0x08 },
+/* 11 */ { "Add-in card", 0x00 },
+/* 12 */ { "Front panel bd", 0x00 },
+/* 13 */ { "Back panel board", 0x00 },
+/* 14 */ { "Power system bd", 0x00 },
+/* 15 */ { "Drive backplane", 0x00 },
+/* 16 */ { "Expansion board", 0x00 },
+/* 17 */ { "Other system board", 0x15 },
+/* 18 */ { "Processor board", 0x15 },
+/* 19 */ { "Power unit", 0x09 },
+/* 20 */ { "Power module", 0x08 },
+/* 21 */ { "Power distr board", 0x09 },
+/* 22 */ { "Chassis back panel bd", 0x00 },
+/* 23 */ { "System Chassis", 0x00 },
+/* 24 */ { "Sub-chassis", 0x00 },
+/* 25 */ { "Other chassis board", 0x15 },
+/* 26 */ { "Disk Drive Bay", 0x0D },
+/* 27 */ { "Peripheral Bay", 0x00 },
+/* 28 */ { "Device Bay", 0x00 },
+/* 29 */ { "Fan", 0x04 },
+/* 30 */ { "Cooling unit", 0x0A },
+/* 31 */ { "Cable/interconnect", 0x1B },
+/* 32 */ { "Memory device ", 0x0C },
+/* 33 */ { "System Mgt Software", 0x28 },
+/* 34 */ { "BIOS", 0x00 },
+/* 35 */ { "Operating System", 0x1F },
+/* 36 */ { "System bus", 0x00 },
+/* 37 */ { "Group", 0x00 },
+/* 38 */ { "Remote Mgt Comm Device", 0x00 },
+/* 39 */ { "External Environment", 0x00 },
+/* 40 */ { "battery", 0x29 },
+/* 41 */ { "Processing blade", 0x00 },
+/* 43 */ { "Processor/memory module", 0x0C },
+/* 44 */ { "I/O module", 0x15 },
+/* 45 */ { "Processor/IO module", 0x00 },
+/* 46 */ { "Mgt Controller Firmware", 0x0F },
+/* 47 */ { "IPMI Channel", 0x00 },
+/* 48 */ { "PCI Bus", 0x00 },
+/* 49 */ { "PCI Express Bus", 0x00 },
+/* 50 */ { "SCSI Bus", 0x00 },
+/* 51 */ { "SATA/SAS bus", 0x00, },
+/* 52 */ { "Processor FSB", 0x00 }
+};
+
+char *decode_entity_id(int id)
+{
+ char *str = NULL;
+ if (id < 0) id = 0;
+ if (id > NENTID) {
+ if (id >= 0x90 && id < 0xB0) str = "Chassis-specific";
+ else if (id >= 0xB0 && id < 0xD0) str = "Board-specific";
+ else if (id >= 0xD0 && id <= 0xFF) str = "OEM-specific";
+ else str = "invalid";
+ } else str = entitymap[id].str;
+ return(str);
+}
+
+uchar entity2sensor_type(uchar ent)
+{
+ uchar stype = 0x12;
+ uchar b;
+ if (ent < NENTID) {
+ b = entitymap[ent].styp;
+ if (fdebug) printf("entity2sensor_type(%x,%s), stype=%x\n",ent,
+ entitymap[ent].str,b);
+ if (b != 0) stype = b;
+ }
+ return(stype);
+}
+
+
+static char *mem_str(int off)
+{
+ char *pstr;
+ switch(off) {
+ case 0x00: pstr = "Correctable ECC"; break;
+ case 0x01: pstr = "Uncorrectable ECC"; break;
+ case 0x02: pstr = "Parity"; break;
+ case 0x03: pstr = "Memory Scrub Failed"; break;
+ case 0x04: pstr = "Memory Device Disabled"; break;
+ case 0x05: pstr = "ECC limit reached" ; break;
+ case 0x07: pstr = "SMI Link Lane Fail Over"; break; /*Quanta QSSC_S4R*/
+ default: pstr = "Other Memory Error"; break;
+ }
+ return(pstr);
+}
+
+
+#if defined(METACOMMAND)
+/* METACOMMAND is defined for ipmiutil meta-command build. */
+/* These can only be external if linked with non-core objects. */
+extern int GetSDR(int recid, int *recnext, uchar *sdr, int szsdr, int *slen);
+extern double RawToFloat(uchar raw, uchar *psdr);
+extern char *get_unit_type(uchar iunit, uchar ibase, uchar imod, int flg);
+extern int find_sdr_by_snum(uchar *psdr,uchar *pcache, uchar snum, uchar sa);
+extern int GetSensorType(int snum, uchar *stype, uchar *rtype);
+extern char * get_mfg_str(uchar *rgmfg, int *pmfg); /*from ihealth.c*/
+extern int decode_post_intel(int prod, ushort code, char *outbuf,int szbuf);
+extern int decode_sel_kontron(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_kontron.c*/
+extern int decode_sel_fujitsu(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_fujitsu.c*/
+extern int decode_sel_intel(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_intel.c*/
+extern int decode_sel_supermicro(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_supermicro.c*/
+extern int decode_sel_quanta(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_quanta.c*/
+extern int decode_sel_newisys(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_newisys.c*/
+extern int decode_sel_dell(uchar *evt, char *obuf,int sz,char fdesc,char fdbg); /*oem_dell.c*/
+extern int decode_mem_intel(int prod, uchar b2, uchar b3, char *desc, int *psz); /*oem_intel.c*/
+extern int decode_mem_supermicro(int prod, uchar b2, uchar b3, char *desc, int *psz); /*oem_intel.c*/
+#else
+/* else it could be ALONE or for a libipmiutil.a build */
+static int default_mem_desc(uchar b2, uchar b3, char *desc, int *psz)
+{
+ int array, dimm, n;
+ uchar bdata;
+ if (desc == NULL || psz == NULL) return -1;
+ if (b3 == 0xff) bdata = b2; /*ff is reserved*/
+ else bdata = b3; /* normal case */
+ array = (bdata & 0xc0) >> 6;
+ dimm = bdata & 0x3f;
+ n = sprintf(desc,"DIMM[%d]",dimm);
+ *psz = n;
+ return(0);
+}
+static int decode_mem_intel(int prod, uchar b2, uchar b3, char *desc, int *psz)
+{ return(default_mem_desc(b2,b3,desc,psz)); }
+static int decode_mem_supermicro(int prod, uchar b2, uchar b3, char *desc, int *psz)
+{ return(default_mem_desc(b2,b3,desc,psz)); }
+static char * get_mfg_str(uchar *rgmfg, int *pmfg)
+{ /* standalone routine here for minimal set of strings*/
+ char *mfgstr;
+ int mfg;
+ mfg = rgmfg[0] + (rgmfg[1] << 8) + (rgmfg[2] << 16);
+ if (pmfg != NULL) *pmfg = mfg;
+ if (mfg == VENDOR_INTEL) mfgstr = "Intel";
+ else if (mfg == VENDOR_MICROSOFT) mfgstr = "Microsoft";
+ else if (mfg == VENDOR_KONTRON) mfgstr = "Kontron";
+ else if (mfg == VENDOR_SUPERMICROX) mfgstr = "SuperMicro";
+ else if (mfg == VENDOR_SUPERMICRO) mfgstr = "SuperMicro";
+ else mfgstr = " ";
+ return (mfgstr);
+}
+#ifdef SENSORS_OK
+extern int GetSDR(int recid, int *recnext, uchar *sdr, int szsdr, int *slen);
+extern double RawToFloat(uchar raw, uchar *psdr);
+extern char *get_unit_type(uchar iunit, uchar ibase, uchar imod, int flg);
+extern int find_sdr_by_snum(uchar *psdr,uchar *pcache, uchar snum, uchar sa);
+extern int GetSensorType(int snum, uchar *stype, uchar *rtype);
+#else
+static int GetSDR(int recid, int *recnext, uchar *sdr, int szsdr, int *slen)
+{ return(-1); }
+static double RawToFloat(uchar raw, uchar *psdr)
+{ return((double)raw); }
+static char *get_unit_type(uchar iunit, uchar ibase, uchar imod, int flg)
+{ return(""); };
+static int find_sdr_by_snum(uchar *psdr,uchar *pcache, uchar snum, uchar sa)
+{ return(-1); }
+static int GetSensorType(int snum, uchar *stype, uchar *rtype)
+{ return(-1); }
+#endif
+#endif
+
+#if defined(ALONE)
+/* ALONE is defined for ievents standalone build. */
+/* IPMI Spec says that this is an index into the DIMMs.
+ * Walking through the SDRs dynamically would be too slow,
+ * but isel -e has an SDR cache which could be leveraged,
+ * however not all platforms have DIMM slot SDRs.
+ * The BIOS references the DIMM Locator descriptors from
+ * SMBIOS type 17, and the descriptions vary for each baseboard.
+ * We'll just show the index here by default.
+ * Do the SMBIOS lookup if not standalone build. */
+
+int strlen_(const char *s) { return((int)strlen(s)); }
+// char * get_iana_str(int vend) { return(""); } *from subs.c*/
+void set_iana(int vend) { return; }
+int get_MemDesc(int array, int idimm, char *desc, int *psz)
+{
+ /* standalone, so use the default method for the DIMM index */
+ return(default_mem_desc(array,idimm,desc,psz));
+}
+
+void get_mfgid(int *vend, int *prod)
+{
+ if ((vend == NULL) || (prod == NULL)) return;
+ *vend = VENDOR_INTEL; /*assume a default of Intel*/
+ *prod = 0;
+}
+char is_remote(void)
+{ return(1); /* act as if remote with standalone utility */ }
+char * decode_rv(int rv)
+{
+ static char mystr[30];
+ char *pstr;
+ switch(rv) {
+ case 0: pstr = "completed successfully"; break;
+ case ERR_BAD_PARAM: pstr = "invalid parameter"; break;
+ case ERR_USAGE: pstr = "usage or help requested"; break;
+ case ERR_FILE_OPEN: pstr = "cannot open file"; break;
+ case ERR_NOT_FOUND: pstr = "item not found"; break;
+ default: sprintf(mystr,"error = %d",rv); pstr = mystr; break;
+ }
+ return(pstr);
+}
+void dump_buf(char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+ char *stag;
+ FILE *fpdbg1;
+
+ fpdbg1 = stdout;
+ if (tag == NULL) stag = "dump_buf"; /*safety valve*/
+ else stag = tag;
+ fprintf(fpdbg1,"%s (len=%d): ", stag,sz);
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ if (sz < 0) { fprintf(fpdbg1,"\n"); return; } /*safety valve*/
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) {
+ line[j] = 0;
+ j = 0;
+ fprintf(fpdbg1,"%s\n %04x: ",line,i);
+ }
+ if (fshowascii) {
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ }
+ fprintf(fpdbg1,"%02x ",pbuf[i]);
+ }
+ if (fshowascii) {
+ if ((j > 0) && (j < 16)) {
+ /* space over the remaining number of hex bytes */
+ for (i = 0; i < (16-j); i++) fprintf(fpdbg1," ");
+ }
+ else j = 16;
+ line[j] = 0;
+ }
+ fprintf(fpdbg1,"%s\n",line);
+ return;
+}
+int ipmi_cmdraw(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{ return(-9); }
+#else
+/* ipmicmd.h has ipmi_cmdraw() */
+extern int get_MemDesc(int array, int dimm, char *desc, int *psz); /*mem_if.c*/
+extern void get_mfgid(int *vend, int *prod); /*from ipmicmd.c*/
+extern char is_remote(void); /*from ipmicmd.c*/
+extern char * decode_rv(int rv); /*from ipmilan.c*/
+extern void dump_buf(char *tag, uchar *pbuf, int sz, char fshowascii);
+#endif
+
+int new_event(uchar *buf, int len)
+{
+ int rlen, rv;
+ uchar idata[8];
+ uchar rdata[4];
+ uchar cc;
+ /*
+ Platform Event Message command, inputs:
+ offset
+ 0 = GeneratorID, 0x20 for BMC, 0x21 for SMI/kernel, 0x33 for BIOS
+ 1 = EVM Rev, 3=IPMI10, 4=IPMI15
+ 2 = Sensor Type
+ 3 = Sensor Number
+ 4 = Event Type (0x6f = sensor specific)
+ 5 = data1
+ 6 = data2
+ 7 = data3
+ */
+ idata[0] = buf[0]; /*GenID on input is two bytes, but one byte here*/
+ idata[1] = buf[2];
+ idata[2] = buf[3];
+ idata[3] = buf[4];
+ idata[4] = buf[5];
+ idata[5] = buf[6];
+ idata[6] = buf[7];
+ idata[7] = buf[8];
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x02, NETFN_SEVT, BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata,8, rdata,&rlen,&cc, fdebug);
+ if (fdebug) printf("platform_event: rv = %d, cc = %02x\n",rv,cc);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ return(rv);
+}
+
+char *get_sensor_type_desc(uchar stype)
+{
+ int i;
+ static char stype_desc[25];
+ char *pstr;
+ if (stype == 0xF3) i = 0x2D; /*OEM SMI*/
+ else if (stype == 0xDC) i = 0x2E; /*NM*/
+ else if (stype == SMI_SA) i = BMC_SA; /*SMI -> BMC*/
+ else if (stype >= NSTYPES) i = 0;
+ else i = stype;
+ if (i == 0) { /* reserved, show the raw sensor_type also */
+ if (stype == 0xCF)
+ strncpy(stype_desc,"OEM Board Reset", sizeof(stype_desc));
+ else if (stype >= 0xC0)
+ sprintf(stype_desc,"OEM(%02x)",stype);
+ else sprintf(stype_desc,"%s(%02x)",sensor_types[i],stype); /*reserved*/
+ pstr = (char *)stype_desc;
+ } else {
+ pstr = (char *)sensor_types[i];
+ }
+ return(pstr);
+}
+
+/*------------------------------------------------------------------------
+ * get_misc_desc
+ * Uses the sens_desc array to decode misc entries not otherwise handled.
+ * Called by decode_sel_entry
+ *------------------------------------------------------------------------*/
+char *
+get_misc_desc(ushort genid, uchar type, uchar num, uchar trig,
+ uchar data1, uchar data2, uchar data3, uchar *sev)
+{
+ int i;
+ char *pstr = NULL;
+
+ /* Use sens_desc array for other misc descriptions */
+ data1 &= 0x0f; /*ignore top half of sensor offset for matching */
+ for (i = 0; i < NSDESC; i++) {
+ if ((sens_desc[i].s_typ == 0xff) ||
+ (sens_desc[i].s_typ == type)) {
+ if (sens_desc[i].s_num != 0xff &&
+ sens_desc[i].s_num != num)
+ continue;
+ if (sens_desc[i].genid != 0xffff &&
+ sens_desc[i].genid != genid)
+ continue;
+ if (sens_desc[i].evtrg != 0xff &&
+ sens_desc[i].evtrg != trig)
+ continue;
+ if (sens_desc[i].data1 != 0xff &&
+ (sens_desc[i].data1 & 0x0f) != (data1 & 0x0f))
+ continue;
+ if (sens_desc[i].data2 != 0xff &&
+ sens_desc[i].data2 != data2)
+ continue;
+ if (sens_desc[i].data3 != 0xff &&
+ sens_desc[i].data3 != data3)
+ continue;
+ /* have a match, use description */
+ pstr = (char *)sens_desc[i].desc;
+ if (sev != NULL) *sev = sens_desc[i].sev;
+ break;
+ }
+ } /*end for*/
+ return(pstr);
+} /* end get_misc_desc() */
+
+time_t utc2local(time_t t)
+{
+ struct tm * tm_tmp;
+ int gt_year,gt_yday,gt_hour,lt_year,lt_yday,lt_hour;
+ int delta_hour;
+ time_t lt;
+ // convert UTC time to local time
+ // i.e. number of seconds from 1/1/70 0:0:0 1970 GMT
+ tm_tmp=gmtime(&t);
+ gt_year=tm_tmp->tm_year;
+ gt_yday=tm_tmp->tm_yday;
+ gt_hour=tm_tmp->tm_hour;
+ tm_tmp=localtime(&t);
+ lt_year=tm_tmp->tm_year;
+ lt_yday=tm_tmp->tm_yday;
+ lt_hour=tm_tmp->tm_hour;
+ delta_hour=lt_hour - gt_hour;
+ if ( (lt_year > gt_year) || ((lt_year == gt_year) && (lt_yday > gt_yday)) )
+ delta_hour += 24;
+ if ( (lt_year < gt_year) || ((lt_year == gt_year) && (lt_yday < gt_yday)) )
+ delta_hour -= 24;
+ if (fdebug) printf("utc2local: delta_hour = %d\n",delta_hour);
+ lt = t + (delta_hour * 60 * 60);
+ return(lt);
+}
+
+void fmt_time(time_t etime, char *buf, int bufsz)
+{
+ time_t t;
+ if (bufsz < 18) printf("fmt_time: buffer size should be >= 18\n");
+ if (futc) t = etime;
+ else t = utc2local(etime); /*assume input time is UTC*/
+ strncpy(buf,"00/00/00 00:00:00",bufsz);
+ strftime(buf,bufsz, "%x %H:%M:%S", gmtime(&t)); /*or "%x %T"*/
+ return;
+}
+
+/*
+ * findmatch
+ * Finds a matching pattern within a string buffer.
+ * returns offset of the match if found, or -1 if not found.
+ */
+int
+findmatch(char *buffer, int sbuf, char *pattern, int spattern, char figncase)
+{
+ int c, i, j, imatch;
+
+ j = 0;
+ imatch = 0;
+ for (j = 0; j < sbuf; j++) {
+ if ((sbuf - j) < spattern && imatch == 0) return(-1);
+ c = buffer[j];
+ if (c == pattern[imatch]) {
+ imatch++;
+ } else if ((figncase == 1) &&
+ ((c & 0x5f) == (pattern[imatch] & 0x5f))) {
+ imatch++;
+ } else if (pattern[imatch] == '?') { /*wildcard char*/
+ imatch++;
+ } else {
+ if (imatch > 0) {
+ if (j > 0) j--; /* try again with the first match char */
+ imatch = 0;
+ }
+ }
+ if (imatch == spattern) break;
+ }
+ if (imatch == spattern) {
+ i = (j+1) - imatch; /*buffer[i] is the match */
+ return(i);
+ } else return (-1); /*not found*/
+} /*end findmatch */
+
+/*
+ * file_grep
+ * Search (grep) for a pattern within a file.
+ * Inputs: fname = file name to search
+ * pattn = pattern string to search for
+ * line = line buffer
+ * sline = size of line buffer
+ * bmode = 0 to use last match,
+ * 1 to use first match,
+ * 2 to specify starting line number & use first match.
+ * nret = IN: starting char offset, OUT: num chars read
+ * Outputs: line = resulting line (stringified) that matches pattn
+ * nret = resulting line number within file (0-based)
+ * returns 0 if match, < 0 if error
+ */
+int file_grep(char *fname, char *pattn, char *line, int sline,
+ char bmode, int *nret)
+{
+ FILE *fp;
+ char buff[1024];
+ int ret = ERR_NOT_FOUND;
+ int i, plen, blen;
+ int n = 0;
+ int nstart = 0;
+ int bufsz;
+
+ if (bmode == 2) nstart = *nret;
+ bufsz = sizeof(buff);
+ fp = fopen(fname,"r");
+ if (fp == NULL) {
+ if (fdebug) printf("file_grep: Cannot open %s\n",fname);
+ ret = ERR_FILE_OPEN; /*cannot open file*/
+ } else {
+ plen = strlen_(pattn);
+ fseek(fp, nstart, SEEK_SET);
+ n = nstart;
+ while (fgets(buff, bufsz, fp) != NULL)
+ {
+ blen = strlen_(buff);
+ /* check for pattern in this line */
+ i = findmatch(&buff[0],blen,pattn,plen,0);
+ if (i >= 0) {
+ ret = 0; /* found it, success */
+ if ((line != NULL) && sline > 1) {
+ if (blen >= sline) blen = sline - 1;
+ strncpy(line,buff,blen);
+ line[blen] = 0; /*stringify*/
+ }
+ if (nret != NULL) *nret = n + i + plen;
+ if (bmode > 0) break;
+ /* else keep looking, use last one if multiples */
+ }
+ n += blen; /*number of chars*/
+ } /*end while*/
+ fclose(fp);
+ } /*end else file opened*/
+ return(ret);
+} /*end file_grep*/
+
+char *get_sev_str(int val)
+{
+ if (val >= NSEV) val = SEV_CRIT;
+ return(sev_str[val]);
+}
+
+/* The htoi() routine is available in subs.c, but ievents.c also
+ * needs a local copy of it if built with -DALONE. */
+static uchar _htoi(char *inhex)
+{
+ // char rghex[16] = "0123456789ABCDEF";
+ uchar val;
+ char c;
+ c = inhex[0] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val = (c & 0x0f) << 4;
+ c = inhex[1] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val += (c & 0x0f);
+ return(val);
+}
+
+/*
+ * set_sel_opts is used to specify options for showing/decoding SEL events.
+ * sensdesc : 0 = simple, no sensor descriptions
+ * 1 = get sensor descriptions from sdr cache
+ * 2 = get sensor descriptions from sensor file (-s)
+ * canon : 0 = normal output
+ * 1 = canonical, delimited output
+ * sdrs : NULL = no sdr cache, dynamically get sdr cache if sensdesc==1
+ * ptr = use this pointer as existing sdr cache if sensdesc==1
+ * fdbg : 0 = normal mode
+ * 1 = debug mode
+ * futc : 0 = normal mode
+ * 1 = show raw UTC time
+ */
+void set_sel_opts(int sensdesc, int canon, void *sdrs, char fdbg, char utc)
+{
+ fsensdesc = (char)sensdesc; /*get extended sensor descriptions*/
+ fcanonical = (char)canon; /*show canonical, delimited output*/
+ if (sdrcache == NULL) sdrcache = sdrs;
+ else printf("Warning: attempted to set_sel_opts(sdrcache) twice\n");
+ fdebug = fdbg;
+ futc = utc;
+}
+
+/* get_sensdesc - get the sensor tag/description from the sensor.out file */
+int get_sensdesc(uchar sa, int snum, char *sensdesc, int *pstyp, int *pidx)
+{
+ int rv, i, j, len, idx;
+ char pattn[20];
+ char sensline[100];
+ int nline = 0;
+ uchar sa2;
+ char *sfil;
+ char *p;
+
+ if (sensdesc == NULL) return ERR_BAD_PARAM;
+ sensdesc[0] = 0;
+ if (fdebug) printf("sensdesc(%02x,%02x) with %s\n",sa,snum,sensfil);
+ sprintf(pattn,"snum %02x",snum);
+ for (j = 0; j < 3; j++)
+ {
+ sfil = sensfil;
+ /* Use this logic for both Linux and Windows */
+ rv = file_grep(sfil,pattn, sensline, sizeof(sensline), 2, &nline);
+ if (rv != 0) {
+ if (rv == ERR_FILE_OPEN) {
+ if (fdebug) fprintf(stdout,"Cannot open file %s\n",sfil);
+ sfil = sensfil2;
+ rv = file_grep(sfil, pattn, sensline,sizeof(sensline), 2, &nline);
+ if (fdebug && rv == ERR_FILE_OPEN)
+ fprintf(stdout,"Cannot open file %s\n",sfil);
+ }
+ if (rv != ERR_FILE_OPEN) {
+ if (fdebug) printf("Cannot find snum %02x in file %s\n",snum,sfil);
+ rv = ERR_NOT_FOUND;
+ }
+ break;
+ }
+ if (rv == 0) {
+ idx = _htoi(&sensline[2]) + (_htoi(&sensline[0]) << 8);
+ sa2 = _htoi(&sensline[20]);
+ if (fdebug)
+ printf("sensdesc(%02x,%02x) found snum for sa %02x at offset %d\n", sa,snum,sa2,nline);
+ if (sa == sa2) {
+ /* truncate the sensor line to omit the reading */
+ len = strlen_(sensline);
+ for (i = 0; i < len; i++)
+ if (sensline[i] == '=') { sensline[i] = 0; break; }
+ if (sensline[i-1] != ' ') {
+ sensline[i] = ' '; sensline[++i] = 0;
+ }
+ /* skip to just the sensor description from the SDR */
+ p = strstr(sensline,"snum");
+ p += 8; /* skip 'snum 11 ' */
+ strcpy(sensdesc,p);
+ if (pstyp != NULL) *pstyp = _htoi(&sensline[25]);
+ if (pidx != NULL) *pidx = idx;
+ break;
+ }
+ }
+ } /*end-for j*/
+ if (j >= 3) rv = ERR_NOT_FOUND; /*not found*/
+ return(rv);
+}
+
+char *get_genid_str(ushort genid)
+{
+ static char genstr[10];
+ char *gstr;
+ int i;
+
+ sprintf(genstr,"%04x",genid);
+ gstr = genstr; /* default */
+ for (i = 0; i < NGDESC; i++)
+ {
+ if (gen_desc[i].g_id == genid) {
+ gstr = (char *)gen_desc[i].desc;
+ break;
+ }
+ }
+ return(gstr);
+}
+
+static int is_threshold(uchar evtrg, ushort genid)
+{
+ int val = 0; /*false*/
+ /* It would be better to check the SDR (if Full supports thresholds),
+ * but we do not always have that available. */
+ if ( ((genid == BMC_SA) || /*from BMC*/
+ (genid == SMI_SA) || /*from SMI (simulated)*/
+ (genid == thr_sa)) && /*from HSC, or other*/
+ ((evtrg == 0x01) || /*threshold evt*/
+ (evtrg == 0x81))) /*threshold ok*/
+ val = 1;
+ return(val);
+}
+
+static void get_sdr_tag(uchar *sdr, char *tagstr)
+{
+ int i, j, k, len;
+ len = sdr[4] + 5;
+ switch(sdr[3]) {
+ case 0x01: k = 48; break; /*full sensor*/
+ case 0x02: k = 32; break; /*compact sensor*/
+ case 0x03: k = 17; break; /*compact sensor*/
+ case 0x10: k = 16; break; /*compact sensor*/
+ case 0x11: k = 16; break; /*compact sensor*/
+ case 0x12: k = 16; break; /*compact sensor*/
+ default: k = 0; break;
+ }
+ if (k > 0 && k < len) {
+ i = len - k;
+ for (j = 0; j < i; j++) {
+ if (sdr[k+j] == 0) break;
+ tagstr[j] = sdr[k+j];
+ }
+ tagstr[j++] = ' ';
+ tagstr[j] = 0;
+ }
+}
+
+/*
+ * get_sensor_tag
+ *
+ * Get the sensor tag (name) based on the sensor number, etc.
+ * Use one of 3 methods to get this:
+ * 1) Parse the sensor_out.txt (sensfil) if fsensdesc==2.
+ * Use this method if not METACOMMAND or if user-specified.
+ * 2) Find this SDR in the SDR cache, if available.
+ * 3) Do a GetSDR command function now (can be slow)
+ * Input parameters:
+ * isdr = index of SDR, use 0 if unknown
+ * genid = genid or sa (slave address) of this sensor
+ * snum = sensor number of this sensor
+ * tag = pointer to a buffer for the sensor tag (min 17 bytes)
+ * sdr = pointer to buffer for the SDR if found (usu <= 65 bytes)
+ * szsdr = size of the SDR buffer
+ * Output parameters:
+ * tag = filled in with sensor tag (name)
+ * sdr = filled in with SDR, if found.
+ * Returns:
+ * 0 if tag and sdr are found.
+ * ERR_NOT_FOUND if SDR is not found (but tag may be found)
+ * other errors, see ipmicmd.h
+ */
+int get_sensor_tag(int isdr, int genid, uchar snum, char *tag,
+ uchar *sdr, int szsdr)
+{
+ int rv, i, j = 0;
+ if (tag == NULL) return(ERR_BAD_PARAM);
+ if (sdr == NULL) return(ERR_BAD_PARAM);
+ if (genid == SMS_SA) genid = BMC_SA; /*parse Sms as if BMC*/
+ if (genid == SMI_SA) genid = BMC_SA; /*parse SMI as if BMC*/
+ tag[0] = 0;
+ if (fsensdesc == 2) { /*not connected, so do not try to GetSDR*/
+ rv = get_sensdesc((uchar)genid, snum, tag,NULL,&isdr);
+ rv = ERR_NOT_FOUND; /*got tag, but did not get SDR*/
+ } else if (sdrcache != NULL) { /*valid sdr cache*/
+ rv = find_sdr_by_snum(sdr,sdrcache, snum, (uchar)genid);
+ if (rv == 0) {
+ get_sdr_tag(sdr,tag);
+ }
+ } else { /* try to get this SDR */
+ rv = GetSDR(isdr, &i,sdr,szsdr,&j);
+ if (fdebug) printf("get_sensor_tag GetSDR[%x] rv=%d sz=%d\n",isdr,rv,j);
+ if (rv == 0) {
+ get_sdr_tag(sdr,tag);
+ } else { /* use a saved sensor.out file */
+ rv = get_sensdesc((uchar)genid, snum, tag,NULL,&isdr);
+ if (rv != 0) tag[0] = 0;
+ rv = ERR_NOT_FOUND; /*got tag, but did not get SDR*/
+ }
+ }
+ if (fdebug) printf("get_sensor_tag(%d): find_sdr(%x,%x) rv=%d tag=/%s/\n",
+ fsensdesc,snum,genid,rv,tag);
+ return(rv);
+}
+
+static
+int decode_post_oem(int vend, int prod, ushort code, char *outbuf,int szbuf)
+{
+ int rv = -1;
+ if (outbuf == NULL || szbuf == 0) return(rv);
+#if defined(METACOMMAND)
+ switch(vend) {
+ case VENDOR_INTEL:
+ rv = decode_post_intel(prod,code,outbuf,szbuf);
+ break;
+ default:
+ break;
+ }
+#endif
+ if (rv != 0) snprintf(outbuf,szbuf,"POST Code %04x",code);
+ return(rv);
+}
+
+static
+int decode_sel_oem(int vend, uchar *pevt, char *outbuf,int szbuf,
+ char fdesc, char fdbg)
+{
+ int rv = -1;
+#ifdef METACOMMAND
+ switch(vend) {
+ case VENDOR_KONTRON:
+ rv = decode_sel_kontron(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_FUJITSU:
+ /* Fujitsu does an OEM IPMI command to return the decoded string. */
+ rv = decode_sel_fujitsu(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_INTEL:
+ thr_sa = HSC_SA; /* HSC_SA(0xC0) by default */
+ rv = decode_sel_intel(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_PEPPERCON: /*SuperMicro AOC-SIMSO*/
+ if (pevt[7] == 0x40) pevt[7] = BMC_SA; /*genid broken, fix it*/
+ break;
+ case VENDOR_MAGNUM:
+ case VENDOR_SUPERMICRO:
+ case VENDOR_SUPERMICROX:
+ rv = decode_sel_supermicro(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_QUANTA:
+ rv = decode_sel_quanta(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_NEWISYS:
+ rv = decode_sel_newisys(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ case VENDOR_DELL:
+ rv = decode_sel_dell(pevt,outbuf,szbuf,fdesc,fdbg);
+ break;
+ default:
+ break;
+ }
+#endif
+ if (fdebug) printf("decode_sel_oem(0x%04x) rv=%d\n",vend,rv);
+ return(rv);
+}
+
+#define N_PWRUNIT 12
+static struct {
+ uchar trg; uchar data1; uchar sev; char *msg;
+ } pwrunit_evts[N_PWRUNIT] = {
+{ 0x6f, 0x00, 0,"Power Off "},
+{ 0x6f, 0x01, 0,"Power Cycle "},
+{ 0x6f, 0x02, 0,"240VA power down"},
+{ 0x6f, 0x03, 0,"Interlock power down"},
+{ 0x6f, 0x04, 1,"AC Lost"},
+{ 0x6f, 0x05, 2,"Soft Powerup failure"},
+{ 0x6f, 0x06, 2,"Failure detected"},
+{ 0x6f, 0x07, 1,"Predictive failure"},
+{ 0xef, 0x00, 0,"Power Restored"},
+{ 0xef, 0x01, 0,"Power Cycle ok"},
+{ 0xef, 0x04, 0,"AC Regained"},
+{ 0xef, 0x06, 0,"Failure OK now"}
+};
+static int decode_pwrunit(uchar trg, uchar data1, char *pstr, uchar *psev)
+{
+ int rv = -1;
+ int i, j;
+ j = data1 & 0x0f;
+ if (psev == NULL || pstr == NULL) return(rv);
+ sprintf(pstr,"_");
+ for (i = 0; i < N_PWRUNIT; i++)
+ {
+ if ((trg == pwrunit_evts[i].trg) &&
+ (j == pwrunit_evts[i].data1)) {
+ *psev = pwrunit_evts[i].sev;
+ sprintf(pstr,"%s",pwrunit_evts[i].msg);
+ rv = 0;
+ }
+ }
+ return(rv);
+}
+
+#define N_REDUN 16
+static struct {
+ uchar trg; uchar data1; uchar sev; char *msg;
+ } redund_evts[N_REDUN] = {
+{ 0x0B, 0x00, SEV_INFO,"Redundancy OK "},
+{ 0x0B, 0x01, SEV_MAJ, "Redundancy Lost"},
+{ 0x0B, 0x02, SEV_MAJ, "Redundancy Degraded"},
+{ 0x0B, 0x03, SEV_MAJ, "Not Redundant"},
+{ 0x0B, 0x04, SEV_MAJ, "Sufficient Resources"},
+{ 0x0B, 0x05, SEV_CRIT,"Insufficient Resources"},
+{ 0x0B, 0x06, SEV_MAJ, "Fully-to-Degraded"},
+{ 0x0B, 0x07, SEV_MIN, "NonR-to-Degraded"},
+{ 0x8B, 0x00, SEV_MAJ, "Redundancy NOT ok"},
+{ 0x8B, 0x01, SEV_INFO,"Redundancy Regained"},
+{ 0x8B, 0x02, SEV_INFO,"Redundancy Restored"},
+{ 0x8B, 0x03, SEV_INFO,"Redundant"},
+{ 0x8B, 0x04, SEV_MAJ, "Not Sufficient"},
+{ 0x8B, 0x05, SEV_INFO,"Not Insufficient"},
+{ 0x8B, 0x06, SEV_INFO,"Degraded-to-Fully"},
+{ 0x8B, 0x07, SEV_MIN, "Degraded-to-NonR"}
+};
+static int decode_redund(uchar trg, uchar data1, char *pstr, uchar *psev)
+{
+ int rv = -1;
+ int i, j;
+ j = data1 & 0x0f;
+ if (psev == NULL || pstr == NULL) return(rv);
+ sprintf(pstr,"_");
+ for (i = 0; i < N_REDUN; i++)
+ {
+ if ((trg == redund_evts[i].trg) &&
+ (j == redund_evts[i].data1)) {
+ *psev = redund_evts[i].sev;
+ sprintf(pstr,"%s",redund_evts[i].msg);
+ rv = 0;
+ }
+ }
+ return(rv);
+}
+
+#define N_PRESENT 2
+static char * present_str[N_PRESENT] = { /* Availability, evtype 0x08 */
+ /*00*/ "Absent", /*Absent/Removed*/
+ /*01*/ "Present"}; /*Present/Inserted*/
+
+static int decode_presence(uchar trg, uchar data1, char *pstr, uchar *psev)
+{
+ int rv = -1;
+ int i;
+ if (psev == NULL || pstr == NULL) return(rv);
+ sprintf(pstr,"_");
+ *psev = SEV_INFO;
+ i = data1 & 0x0f;
+ if (trg == 0x08) {
+ if (i >= N_PRESENT) i = N_PRESENT - 1;
+ sprintf(pstr,"%s",present_str[i]);
+ rv = 0;
+ } else if (trg == 0x88) {
+ if (data1 & 0x01) i = 0;
+ else i = 1;
+ sprintf(pstr,"%s",present_str[i]);
+ }
+ return(rv);
+}
+
+void format_event(ushort id, time_t timestamp, int sevid, ushort genid,
+ char *ptype, uchar snum, char *psens, char *pstr, char *more,
+ char *outbuf, int outsz)
+{
+ char sensdesc[36];
+ char timestr[40];
+ uchar sdr[MAX_BUFFER_SIZE]; /*sdr usu <= 65 bytes*/
+ char *gstr;
+ int isdr = 0;
+ int rv;
+
+ if (more == NULL) more = "";
+ if (psens != NULL) ; /* use what was passed in */
+ else { /*psens==NULL, may need to get tag*/
+ psens = &sensdesc[0];
+ sensdesc[0] = 0;
+ if (fsensdesc) {
+ rv = get_sensor_tag(isdr,genid,snum,psens,sdr,sizeof(sdr));
+ if (fdebug) printf("get_sensor_tag(%x) rv = %d\n",snum,rv);
+ }
+ }
+ fmt_time(timestamp, timestr, sizeof(timestr));
+ gstr = get_genid_str(genid); /*get Generator ID / Source string*/
+
+ if (fcanonical) {
+ snprintf(outbuf,outsz,"%04x %c %s %c %s %c %s %c %s %c %s %c %s %s\n",
+ id, bdelim, timestr, bdelim,
+ get_sev_str(sevid), bdelim,
+ gstr, bdelim, ptype, bdelim,
+ psens, bdelim, pstr, more );
+ } else {
+ snprintf(outbuf,outsz,"%04x %s %s %s %s #%02x %s%s %s\n",
+ id, timestr, get_sev_str(sevid),
+ gstr, ptype, snum, psens, pstr, more);
+ }
+ return;
+}
+
+/*------------------------------------------------------------------------
+ * decode_sel_entry
+ * Parse and decode the SEL record into readable format.
+ * This routine is constructed so that it could be used as a library
+ * function.
+ * Note that this routine outputs 14 of the 16 bytes in either text or
+ * raw hex form. For the two bytes not shown:
+ * . record type: usually = 02, is shown otherwise (e.g. OEM type)
+ * . event msg revision: =03 if IPMI 1.0, =04 if IPMI 1.5 or IPMI 2.0
+ *
+ * Input: psel, a pointer to the IPMI SEL record (16 bytes)
+ * Output: outbuf, a description of the event, max 80 chars.
+ * Called by: ReadSEL()
+ * Calls: fmt_time() get_misc_desc()
+ *
+ * IPMI SEL record format (from IPMI Table 32-1):
+ * Offset Meaning
+ * 0-1 Record ID (LSB, MSB)
+ * 2 Record Type (usu 0x02)
+ * 3-6 Timestamp (LS byte first)
+ * 7-8 Generator ID (LS first, usually 20 00)
+ * 9 Event message format (=0x04, or =0x03 if IPMI 1.0)
+ * 10 Sensor type
+ * 11 Sensor number
+ * 12 Event Dir | Event Type
+ * 13 Event Data 1
+ * 14 Event Data 2
+ * 15 Event Data 3
+ *------------------------------------------------------------------------*/
+int decode_sel_entry( uchar *pevt, char *outbuf, int szbuf)
+{
+ char mystr[80] = "panic(123)"; /*used for panic string*/
+ char *pstr;
+ char poststr[80] = "OEM Post Code = %x%x";
+ char sensstr[50];
+ char datastr[64];
+ char cstr[4];
+ char *psensstr;
+ int i, j, k, n;
+ time_t eventTime;
+ uchar *evtime;
+ char timebuf[40];
+ uchar *pc;
+ SEL_RECORD *psel;
+ uchar fdeassert = 0;
+ uchar sev = SEV_INFO;
+ uchar sdr[MAX_BUFFER_SIZE]; /*sdr usu <= 65 bytes*/
+ int isdr = 0;
+ int vend, prod;
+ int rv = 0;
+ char fhave_sdr = 0;
+ char mdesc[80]; /*used for oem memory description*/
+ int msz;
+
+ if (outbuf == NULL) return(ERR_BAD_PARAM);
+ if (pevt == NULL) {
+ outbuf[0] = 0;
+ return(ERR_BAD_PARAM);
+ }
+ get_mfgid(&vend,&prod); /*saved from ipmi_getdeviceid */
+ psel = (SEL_RECORD *)pevt;
+
+ j = decode_sel_oem(vend,pevt,outbuf,szbuf,fsensdesc,fdebug);
+ if (j == 0) return(0); /*successful, have the description*/
+
+ if (psel->record_type == 0xDC) {
+ /* OEM Record: these are usually Microsoft */
+ char *mfgstr;
+ int mfg;
+ evtime = (uchar *)&psel->timestamp;
+ eventTime = evtime[0] + (evtime[1] << 8) +
+ (evtime[2] << 16) + (evtime[3] << 24);
+ fmt_time(eventTime, timebuf, sizeof(timebuf));
+ pc = (uchar *)&psel->generator_id; /* offset 7 */
+ mfgstr = get_mfg_str(&pc[0],&mfg);
+
+ if (fcanonical)
+ sprintf(outbuf,"%04x %c %s %c %s %c %02x %c %06x %c %s %c OEM Event ",
+ psel->record_id, bdelim, timebuf, bdelim,
+ get_sev_str(sev), bdelim, psel->record_type, bdelim,
+ mfg, bdelim, mfgstr, bdelim);
+ else
+ sprintf(outbuf,"%04x %s %s %02x %06x %s OEM Event ",
+ psel->record_id, timebuf, get_sev_str(sev),
+ psel->record_type, mfg, mfgstr);
+ j = strlen_(outbuf);
+ for (i = 3; i < 9; i++) { /* 10:16 = 6 bytes data */
+ sprintf(&outbuf[j],"%02x ",pc[i]);
+ j += 3;
+ }
+ outbuf[j++] = '\n';
+ outbuf[j++] = 0;
+ } else if (psel->record_type == 0xDD) { /* usu Intel OEM string */
+ char *mfgstr;
+ int mfg;
+ int ix = 0;
+ /* Windows reboot reason string from MS ipmidrv.sys */
+ evtime = (uchar *)&psel->timestamp;
+ eventTime = evtime[0] + (evtime[1] << 8) +
+ (evtime[2] << 16) + (evtime[3] << 24);
+ fmt_time(eventTime, timebuf, sizeof(timebuf));
+ pc = (uchar *)&psel->generator_id; /* IANA at offset 7 */
+ mfgstr = get_mfg_str(&pc[0],&mfg);
+ if (fcanonical)
+ sprintf(outbuf,"%04x %c %s %c %s %c %02x %c %06x %c %s %c OEM Event ",
+ psel->record_id, bdelim, timebuf, bdelim,
+ get_sev_str(sev), bdelim, psel->record_type, bdelim,
+ mfg, bdelim, mfgstr, bdelim);
+ else
+ sprintf(outbuf,"%04x %s %s %02x %06x %s OEM Event ",
+ psel->record_id, timebuf, get_sev_str(sev),
+ psel->record_type, mfg, mfgstr );
+ j = strlen_(outbuf);
+ for (i = 3; i < 9; i++) { /* 10:16 = 6 bytes data */
+ if (i == 3 || ix == 0) {
+ if (i == 3) ix = pc[i];
+ sprintf(&outbuf[j],"%02x ",pc[i]);
+ j += 3;
+ } else {
+ if (pc[i] == 0) outbuf[j] = ' ';
+ else sprintf(&outbuf[j],"%c",pc[i]);
+ j += 1;
+ }
+ }
+ outbuf[j++] = '\n';
+ outbuf[j++] = 0;
+ } else if (psel->record_type >= 0xe0) { /*OEM Record 26.3*/
+ /* 3 bytes header, 13 bytes data, no timestamp */
+ pc = (uchar *)&psel->timestamp; /*bytes 4:16*/
+ if (fcanonical)
+ sprintf(outbuf,"%04x %c %s %c %s %c %02x %c %s %c %s %c OEM Event ",
+ psel->record_id, bdelim, "", bdelim,
+ get_sev_str(sev), bdelim, psel->record_type, bdelim,
+ "", bdelim, "", bdelim);
+ else
+ sprintf(outbuf,"%04x %s %02x OEM Event ",
+ psel->record_id,get_sev_str(sev),psel->record_type);
+ j = strlen_(outbuf);
+ for (i = 0; i < 13; i++) { /* 5:16 = 11 bytes data */
+ if ((psel->record_type == 0xf0) && (i >= 2)) {
+ /* Linux panic string will be type 0xf0 */
+ if (pc[i] == 0) break;
+ outbuf[j++] = pc[i];
+ } else if (psel->record_type == 0xf1) {
+ /* custom ascii string record, type 0xf1 */
+ if (i == 0) { /*linux panic*/
+ outbuf[j++] = ':';
+ outbuf[j++] = ' ';
+ }
+ if (pc[i] == 0) break;
+ outbuf[j++] = pc[i];
+ } else {
+ sprintf(&outbuf[j],"%02x ",pc[i]);
+ j += 3;
+ }
+ }
+ outbuf[j++] = '\n';
+ outbuf[j++] = 0;
+ } else if (psel->record_type >= 0xc0) { /*OEM Record 26.3*/
+ /* 10 bytes header, 6 bytes data, has timestamp */
+ evtime = (uchar *)&psel->timestamp;
+ eventTime = evtime[0] + (evtime[1] << 8) +
+ (evtime[2] << 16) + (evtime[3] << 24);
+ fmt_time(eventTime, timebuf, sizeof(timebuf));
+ pc = (uchar *)&psel->generator_id; /* IANA at offset 7 */
+ if (fcanonical)
+ sprintf(outbuf,"%04x %c %s %c %s %c %02x %c %02x%02x%02x %c %s %c OEM Event ",
+ psel->record_id, bdelim, timebuf, bdelim,
+ get_sev_str(sev), bdelim, psel->record_type, bdelim,
+ pc[2],pc[1],pc[0], bdelim, "", bdelim);
+ else
+ sprintf(outbuf,"%04x %s %s %02x %02x%02x%02x OEM Event ",
+ psel->record_id, timebuf, get_sev_str(sev),
+ psel->record_type, pc[2],pc[1],pc[0] );
+ j = strlen_(outbuf);
+ for (i = 3; i < 9; i++) { /* 10:16 = 6 bytes data */
+ sprintf(&outbuf[j],"%02x ",pc[i]);
+ j += 3;
+ }
+ outbuf[j++] = '\n';
+ outbuf[j++] = 0;
+ } else if (psel->record_type == 0x02) {
+ uchar c = 0;
+ /* most records are record type 2 */
+ /* Interpret the event by sensor type */
+ switch(psel->sensor_type)
+ {
+ case 0x20: /*OS Crit Stop*/
+ i = psel->event_data1 & 0x0f;
+ switch(i) {
+ case 0x00: pstr = "Startup Crit Stop";
+ sev = SEV_CRIT; break;
+ case 0x02: pstr = "OS Graceful Stop"; break;
+ case 0x03: pstr = "OS Graceful Shutdown"; break;
+ case 0x04: pstr = "PEF Soft-Shutdown"; break;
+ case 0x05: pstr = "Agent Not Responding"; break;
+ case 0x01: /*OS Runtime Critical Stop (panic)*/
+ default:
+ sev = SEV_CRIT;
+ if (psel->sensor_number == 0) { /*Windows*/
+ pstr = "Runtime Crit Stop";
+ } else { /*Linux panic, get string*/
+ /* Show first 3 chars of panic string */
+ pstr = mystr;
+ strcpy(mystr,"panic(");
+ for (i = 6; i <= 8; i++) {
+ switch(i) {
+ case 6: c = psel->sensor_number; break;
+ case 7: c = psel->event_data2; break;
+ case 8: c = psel->event_data3; break;
+ }
+ c &= 0x7f;
+ if (c < 0x20) c = '.';
+ mystr[i] = c;
+ }
+ mystr[9] = ')';
+ mystr[10] = 0;
+ if (psel->sensor_number & 0x80)
+ strcat(mystr,"Oops!");
+ if (psel->event_data2 & 0x80)
+ strcat(mystr,"Int!");
+ if (psel->event_data3 & 0x80)
+ strcat(mystr,"NullPtr!");
+ }
+ break;
+ } /*end data1 switch*/
+ break;
+ case 0x01: /*Temperature events*/
+ if (is_threshold(psel->event_trigger,
+ psel->generator_id)) {
+ pstr = get_misc_desc( psel->generator_id,
+ psel->sensor_type,
+ psel->sensor_number,
+ psel->event_trigger,
+ psel->event_data1,
+ psel->event_data2,
+ psel->event_data3, &sev);
+ } else { /*else discrete temp event*/
+ /* data1 should usually be 0x01 */
+ if (psel->event_trigger & 0x80)
+ strcpy(mystr,"Temp OK");
+ else strcpy(mystr,"Temp Asserted");
+ pstr = mystr;
+ } /*end-else discrete*/
+ break;
+ /* case 0X04 for Fan events is further below. */
+ case 0x07: /*Processor (CPU)*/
+ i = psel->event_data1 & 0x0f;
+ if (psel->event_trigger == 0x6f) {
+ /* Processor status sensor */
+ if (i >= NPROC) i = NPROC - 1;
+ if (i == 7) sev = SEV_INFO;
+ else if (i > 7) sev = SEV_MIN;
+ else sev = SEV_CRIT;
+ sprintf(mystr,"%s",proc_str[i]);
+ pstr = mystr;
+ } else if (psel->event_trigger == 0xef) {
+ sev = SEV_CRIT;
+ if (i >= NPROC) i = NPROC - 1;
+ sprintf(mystr,"%s deasserted",proc_str[i]);
+ pstr = mystr;
+ } else if (psel->sensor_number == 0x80) { /*CATERR*/
+ char *p1, *p2;
+ sev = SEV_CRIT;
+ switch( psel->event_data2 & 0x0F)
+ {
+ case 1: p1 = "CATERR"; break;
+ case 2: p1 = "CPU Core Error"; break;
+ case 3: p1 = "MSID Mismatch"; break;
+ default: p1 = "Unknown Error"; break;
+ }
+ if (psel->event_data2 & 0x01) p2 = "CPU0";
+ else if (psel->event_data2 & 0x02) p2 = "CPU1";
+ else if (psel->event_data2 & 0x04) p2 = "CPU2";
+ else if (psel->event_data2 & 0x08) p2 = "CPU3";
+ else p2 = "CPU4";
+ sprintf(mystr,"%s on %s",p1,p2);
+ pstr = mystr;
+ } else if (psel->event_trigger == 0x03) {
+ if (i) {pstr = "Proc Config Error"; sev = SEV_CRIT;}
+ else {pstr = "Proc Config OK"; sev = SEV_INFO; }
+ } else if (psel->event_trigger == 0x83) {
+ if (i) { pstr = "Proc Config OK"; sev = SEV_INFO; }
+ else { pstr = "Proc Config Error"; sev = SEV_CRIT; }
+ } else { /* else other processor sensor */
+ i = ((psel->event_trigger & 0x80) >> 7);
+ if (i) { pstr = "ProcErr Deasserted"; sev = SEV_INFO;}
+ else { pstr = "ProcErr Asserted"; sev = SEV_CRIT; }
+ }
+ break;
+ case 0x09: /*Power Unit*/
+ if ((psel->event_trigger == 0x0b) ||
+ (psel->event_trigger == 0x8b)) {
+ rv = decode_redund(psel->event_trigger,
+ psel->event_data1, mystr, &sev);
+ } else { /*sensor-specific 0x6f/0xef*/
+ rv = decode_pwrunit(psel->event_trigger,
+ psel->event_data1, mystr, &sev);
+ }
+ if (rv == 0) pstr = mystr;
+ else pstr = NULL; /*falls through to unknown*/
+ break;
+ case 0x0C: /*Memory*/
+ i = psel->event_data1 & 0x0f; /*memstr index*/
+ { /* now get the DIMM index from data2 or data3 */
+ uchar b2, b3, bdata;
+ b2 = psel->event_data2;
+ b3 = psel->event_data3;
+ if ((vend == VENDOR_INTEL && prod == 0x4311) ||
+ (vend == VENDOR_NSC)) { /*mini-BMC*/
+ bdata = b2;
+ } else if (b3 == 0xff) { /* FF is reserved */
+ bdata = b2;
+ } else { /* normal case */
+ bdata = b3;
+ }
+ j = bdata & 0x3f;
+ /* Now i==data1(lo nib) for memstr, j==DIMM index */
+ if (i == 0) sev = SEV_MIN; /*correctable ECC*/
+ else sev = SEV_MAJ;
+ if (fdebug) printf("DIMM(%d) vend=%x prod=%x\n",j,vend,prod);
+ /* For Intel S5500/S2600 see decode_mem_intel */
+ if (vend == VENDOR_INTEL) {
+ decode_mem_intel(prod,b2,b3,mdesc,&msz);
+ sprintf(mystr,"%s%c %s",mem_str(i),bcomma,mdesc);
+ } else if ((vend == VENDOR_SUPERMICRO) ||
+ (vend == VENDOR_SUPERMICROX)) {
+ decode_mem_supermicro(prod,b2,b3,mdesc,&msz);
+ sprintf(mystr,"%s%c %s",mem_str(i),bcomma,mdesc);
+ } else {
+ sprintf(mystr,"%s%c DIMM[%d]",mem_str(i),bcomma,j);
+ /* DIMM[2] = 3rd one (zero-based index) */
+ }
+ }
+ pstr = mystr;
+ break;
+ case 0x0F: /*System Firmware events, incl POST Errs*/
+ sev = SEV_MAJ; /*usu major, but platform-specific*/
+ switch (psel->event_data1)
+ {
+ case 0x00: /* System firmware errors */
+ i = psel->event_data2;
+ if (i > NFWERRS) i = NFWERRS;
+ pstr = fwerrs[i].msg;
+ break;
+ case 0x01: /* System firmware hang */
+ i = psel->event_data2;
+ if (i > NFWSTAT) i = NFWSTAT;
+ sprintf(poststr,"hang%c %s",bcomma,
+ fwstat[i].msg);
+ pstr = poststr;
+ break;
+ case 0x02: /* System firmware progress */
+ sev = SEV_INFO;
+ i = psel->event_data2;
+ if (i > NFWSTAT) i = NFWSTAT;
+ sprintf(poststr,"prog%c %s",bcomma,
+ fwstat[i].msg);
+ pstr = poststr;
+ break;
+ case 0xa0: /* OEM post codes */
+ /* OEM post codes in bytes 2 & 3 (lo-hi) */
+ j = psel->event_data2 |
+ (psel->event_data3 << 8);
+ /* interpret some OEM post codes if -e */
+ i = decode_post_oem(vend,prod,(ushort)j,
+ poststr,sizeof(poststr));
+ pstr = poststr;
+ break;
+ default:
+ pstr = get_misc_desc( psel->generator_id,
+ psel->sensor_type,
+ psel->sensor_number,
+ psel->event_trigger,
+ psel->event_data1,
+ psel->event_data2,
+ psel->event_data3, &sev);
+ if (pstr == NULL)
+ pstr = "POST Error"; /*default string*/
+ } /*end switch(data1)*/
+ break;
+ case 0x13: /*Crit Int*/
+ sev = SEV_CRIT;
+ i = psel->event_data1 & 0x0f;
+ if (i >= NCRITS) i = NCRITS - 1;
+ pstr = crit_int_str[i];
+ if ((psel->event_trigger == 0x70) ||
+ (psel->event_trigger == 0x71)) {
+ uchar bus,dev,func;
+ /* Intel AER< decode PCI bus:dev.func data */
+ bus = psel->event_data2;
+ dev = ((psel->event_data3 & 0xf8) >> 3);
+ func = (psel->event_data3 & 0x07);
+ sprintf(mystr,"%s (on %02x:%02x.%d)",
+ crit_int_str[i],bus,dev,func);
+ pstr = mystr;
+ }
+ break;
+ case 0x15: /*Board (e.g. IO Module)*/
+ if ((psel->event_trigger == 0x08) ||
+ (psel->event_trigger == 0x88)) {
+ rv = decode_presence(psel->event_trigger,
+ psel->event_data1, mystr, &sev);
+ pstr = mystr;
+ } else pstr = NULL; /*falls through to unknown*/
+ break;
+ case 0x16: /*Microcontroller (e.g. ME or HDD)*/
+ // if (psel->event_trigger == 0x0A) // Availability
+ {
+ i = psel->event_data1 & 0x0f;
+ if (i >= N_AVAIL) i = N_AVAIL - 1;
+ if (i >= 4) sev = SEV_MIN;
+ else sev = SEV_INFO;
+ pstr = avail_str[i];
+ }
+ break;
+ case 0x1D: /*System Boot Initiated*/
+ i = psel->event_data1 & 0x0f;
+ if (i >= NBOOTI) i = NBOOTI - 1;
+ pstr = boot_init_str[i];
+ break;
+ case 0x1F: /*OS Boot */
+ i = psel->event_data1 & 0x0f;
+ if (i >= NOSBOOT) i = NOSBOOT - 1;
+ pstr = osboot_str[i];
+ break;
+ case 0x21: /*Slot/Con*/
+ i = psel->event_data1 & 0x0f;
+ if (i >= NSLOTC) i = NSLOTC - 1;
+ if (i == 0) sev = SEV_MAJ; /*Fault*/
+ else if (i == 8) sev = SEV_MIN;
+ sprintf(mystr,"%s",slot_str[i]);
+ /* could also decode data2/data3 here if valid */
+ pstr = mystr;
+ break;
+ case 0x22: /*ACPI Power state*/
+ i = psel->event_data1 & 0x0f;
+ if (i >= NACPIP) i = NACPIP - 1;
+ sprintf(mystr,"%s",acpip_str[i]);
+ pstr = mystr;
+ break;
+ case 0x28: /*Management Subsystem Health*/
+ i = psel->event_data1 & 0x0f;
+ if (i == 0x04) /*sensor error*/
+ sprintf(mystr,"Sensor %02x fault",psel->event_data2);
+ else
+ sprintf(mystr,"Other FW HAL error");
+ pstr = mystr;
+ break;
+ case 0x29: /*Battery*/
+ if (is_threshold(psel->event_trigger,
+ psel->generator_id))
+ {
+ pstr = get_misc_desc( psel->generator_id,
+ psel->sensor_type,
+ psel->sensor_number,
+ psel->event_trigger,
+ psel->event_data1,
+ psel->event_data2,
+ psel->event_data3, &sev);
+ } else {
+ i = psel->event_data1 & 0x0f;
+ if (i >= NBATT) i = NBATT - 1;
+ /* sev defaults to SEV_INFO */
+ if (psel->event_trigger & 0x80) { /*deasserted*/
+ sprintf(mystr,"%s",batt_clr[i]);
+ } else { /*asserted*/
+ sprintf(mystr,"%s",batt_str[i]);
+ if (i == 0) sev = SEV_MIN;
+ else if (i == 1) sev = SEV_MAJ;
+ }
+ pstr = mystr;
+ }
+ break;
+ case 0x2A: /*Session Audit, new for IPMI 2.0*/
+ i = psel->event_data1 & 0x0f;
+ if (i >= NAUDIT) i = NAUDIT - 1;
+ sprintf(mystr,"%s User%d",audit_str[i],
+ psel->event_data2);
+ /* see also psel->event_data3 for cause/channel*/
+ pstr = mystr;
+ break;
+ case 0xDC: /*ME Node Manager, for S5500 Urbanna*/
+ i = psel->event_trigger;
+ if (i & 0x80) { fdeassert = 1; i &= 0x7f; }
+ if (i >= 0x72) i -= 0x72;
+ if (i >= N_NM) i = N_NM - 1;
+ sprintf(mystr,"%s",nm_str[i]);
+ if (fdeassert) strcat(mystr," OK");
+ n = strlen_(mystr);
+ sprintf(cstr,"%c ",bcomma);
+ j = psel->event_data2;
+ switch(i) {
+ case 0x00: /*0x72 NM Exception*/
+ j = psel->event_data1;
+ if ((j & 0x08) == 0) {
+ k = j & 0x03;
+ sprintf(&mystr[n],
+ "%sThreshold %d Exceeded",cstr,k);
+ } else { /*Policy event*/
+ sprintf(&mystr[n],
+ "%sPolicy Time Exceeded",cstr);
+ }
+ sev = SEV_MIN;
+ break;
+ case 0x01: /*0x73 NM Health*/
+ j &= 0x0f; // if (j >= 0x10) j -= 0x10;
+ if (j >= N_NMH) j = N_NMH - 1;
+ if (j != 5) sev = SEV_MAJ;
+ strcat(mystr,cstr); /*", "*/
+ strcat(mystr,nmh_str[j]);
+ break;
+ case 0x03: /*0x75 FW Health*/
+ if (j >= N_NMFW) j = N_NMFW - 1;
+ sev = SEV_MAJ;
+ strcat(mystr,cstr); /*", "*/
+ strcat(mystr,nmfw_str[j]);
+ break;
+ case 0x02: /*0x74 NM Capabilities*/
+ default:
+ sev = SEV_MIN;
+ break;
+ }
+ pstr = mystr;
+ break;
+ case 0x04: /*Fan sensor events */
+ if ((psel->event_trigger == 0x0b) ||
+ (psel->event_trigger == 0x8b)) {
+ rv = decode_redund(psel->event_trigger,
+ psel->event_data1, mystr, &sev);
+ pstr = mystr;
+ break;
+ } else if ((psel->event_trigger == 0x08) ||
+ (psel->event_trigger == 0x88)) {
+ rv = decode_presence(psel->event_trigger,
+ psel->event_data1, mystr, &sev);
+ pstr = mystr;
+ break;
+ } else if (psel->event_trigger == 0x06) {
+ /* usu psel->event_data1 == 0x01 */
+ sev = SEV_MIN;
+ strcpy(mystr,"Performance Lags");
+ pstr = mystr;
+ break;
+ } else if (psel->event_trigger == 0x86) {
+ sev = SEV_INFO;
+ strcpy(mystr,"Performance OK");
+ pstr = mystr;
+ break;
+ }
+ /* else Fan threshold events handled below, trig=01/81*/
+ default: /* all other sensor types, see sens_desc */
+ pstr = get_misc_desc( psel->generator_id,
+ psel->sensor_type,
+ psel->sensor_number,
+ psel->event_trigger,
+ psel->event_data1,
+ psel->event_data2,
+ psel->event_data3, &sev);
+ break;
+ } /*end switch(sensor_type)*/
+
+ if (pstr == NULL) { /* none found, unknown */
+ mystr[0] = '-'; mystr[1] = 0;
+ pstr = mystr;
+ }
+
+
+ /*firmware timestamp is #seconds since 1/1/1970 localtime*/
+ evtime = (uchar *)&psel->timestamp;
+ eventTime = evtime[0] + (evtime[1] << 8) +
+ (evtime[2] << 16) + (evtime[3] << 24);
+ if (fdebug) {
+ char tbuf[40];
+ char *tz; char *lctime;
+ strftime(timebuf,sizeof(timebuf), "%x %H:%M:%S %Z",
+ localtime(&eventTime));
+ strftime(tbuf,sizeof(tbuf), "%x %H:%M:%S %Z",
+ gmtime(&eventTime));
+ tz = getenv("TZ");
+ if (tz == NULL) tz = "";
+ lctime = getenv("LC_TIME");
+ if (lctime == NULL) lctime = "";
+ SELprintf("%s\nTZ=%s, LC_TIME=%s, gmtime=%s\n",
+ timebuf,tz,lctime,tbuf);
+ }
+ psensstr = NULL;
+ sensstr[0] = 0;
+ if (fsensdesc) {
+ rv = get_sensor_tag(isdr,psel->generator_id,
+ psel->sensor_number, sensstr,
+ sdr, sizeof(sdr));
+ if (rv == 0) {
+ fhave_sdr = 1;
+ psensstr = &sensstr[0];
+ } else rv = 0; /*no sdr but not an error*/
+ } /*endif fsensdesc*/
+
+ if (is_threshold(psel->event_trigger,psel->generator_id)) {
+ /* Also usually ((psel->event_data1 & 0x50) == 0x50) */
+ /* We know that these two MCs should include the
+ * actual and threshold raw values in data2 & data3 */
+ if (fsensdesc && fhave_sdr) {
+ double v1, v2;
+ char *u;
+ /* if sdrcache, find_sdr_by_snum got the sdr above */
+ /* else, GetSDR tried to get the sdr above */
+ v1 = RawToFloat(psel->event_data2,sdr);
+ v2 = RawToFloat(psel->event_data3,sdr);
+ u = get_unit_type(sdr[20],sdr[21],sdr[22],1);
+ sprintf(datastr, "actual=%.2f %s, threshold=%.2f %s",
+ v1,u, v2,u);
+ } else { // if (fsensdesc == 0 || (rv != 0)) {
+ sprintf(datastr,"act=%02x thr=%02x",
+ psel->event_data2, /*actual raw reading*/
+ psel->event_data3 ); /*threshold raw value*/
+ }
+ } else {
+ if (fcanonical) datastr[0] = 0;
+ else sprintf(datastr,"%02x [%02x %02x %02x]",
+ psel->event_trigger,
+ psel->event_data1,
+ psel->event_data2,
+ psel->event_data3 );
+ }
+
+ format_event(psel->record_id, eventTime, sev,
+ psel->generator_id,
+ get_sensor_type_desc(psel->sensor_type),
+ psel->sensor_number, psensstr,
+ pstr, datastr, outbuf,szbuf);
+
+ } /*endif type 2 */
+ else { /* other misc record type */
+ if (fdebug) printf("Unrecognized record type %02x\n",
+ psel->record_type);
+ rv = ERR_NOT_FOUND;
+ pc = (uchar *)&psel->record_type;
+ sprintf(outbuf,"%04x Type%02x %s ",
+ psel->record_id,pc[0],get_sev_str(sev));
+ j = strlen_(outbuf);
+ for (i = 1; i < 14; i++) {
+ sprintf(mystr,"%02x ",pc[i]);
+ strcat(outbuf,mystr);
+ }
+ strcat(outbuf,"\n");
+ } /*endif misc type*/
+ return(rv);
+} /*end decode_sel_entry()*/
+
+static void show_usage(void)
+{
+ printf("Usage: %s [-bdfhprstux] 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10\n",progname);
+ printf("where -b = interpret Binary raw SEL file, from ipmitool sel writeraw\n");
+ printf(" -d = get DeviceID for vendor/product-specific events\n");
+ printf(" -f = interpret File with raw ascii SEL data, from ipmiutil sel -r\n");
+ printf(" -h = interpret Hex binary raw SEL file (same as -b)\n");
+#ifndef ALONE
+ printf(" -o = specify the target vendor IANA number.\n");
+#endif
+ printf(" -n = generate New platform event, use last 9 event bytes\n");
+ printf(" -p = decode PET event bytes, use 34 PET data bytes,\n");
+ printf(" skipping the first 8 of the 47-byte PET data (-t=all).\n");
+ printf(" If not specified, assumes a 16-byte IPMI event.\n");
+ printf(" -r = interpret RAW ascii SEL file (same as -f)\n");
+ printf(" -s = sensor file with output of 'ipmiutil sensor', used\n");
+ printf(" to get the PET sensor_type from the sensor_num.\n");
+ printf(" The default is %s\n",sensfil);
+ printf(" -t = decode PET trap bytes, use all 47 PET data bytes (-p=34)\n");
+ printf(" If not specified, assumes a 16-byte IPMI event.\n");
+ printf(" -u = use raw UTC time\n");
+ printf(" -x = show eXtra debug messages\n");
+}
+
+/*
+ * decode_raw_sel
+ * input parameters:
+ * raw_file : filename of raw SEL file
+ * mode : 1 = ascii raw from ipmiutil sel -r
+ * 2 = binary hex from ipmiutil sel writeraw {raw_file}
+ */
+int decode_raw_sel(char *raw_file, int mode)
+{
+ FILE *fp;
+ char buff[256];
+ uchar msg[132];
+ uchar hbuf[50];
+ int fvalid = 0;
+ int len, i;
+
+ fp = fopen(raw_file,"r");
+ if (fp == NULL) {
+ printf("Cannot open file %s\n",raw_file);
+ return(ERR_FILE_OPEN);
+ } else {
+ printf("%s",evt_hdr); /*"RecId Date/Time_______*/
+ if (mode == 1) { /*ascii raw*/
+ if (fdebug)
+ printf("decoding raw ascii file with IPMI event bytes\n");
+ while (fgets(buff, 255, fp)) {
+ len = strlen_(buff);
+ fvalid = 0;
+ if (buff[0] >= '0' && (buff[0] <= '9')) fvalid = 1;
+ else if (buff[0] >= 'a' && (buff[0] <= 'f')) fvalid = 1;
+ else if (buff[0] >= 'A' && (buff[0] <= 'F')) fvalid = 1;
+ if (fvalid == 0) continue;
+ for (i = 0; i < 16; i++) {
+ hbuf[i] = _htoi(&buff[i*3]);
+ }
+ decode_sel_entry(hbuf,msg,sizeof(msg));
+ printf("%s", msg);
+ } /*end while*/
+ } else { /*hex raw*/
+ if (fdebug)
+ printf("decoding binary hex file with IPMI event bytes\n");
+ while (fread(hbuf, 1, 16, fp) == 16) {
+ decode_sel_entry(hbuf,msg,sizeof(msg));
+ printf("%s", msg);
+ } /*end while*/
+ }
+ fclose(fp);
+ }
+ return(0);
+}
+
+/*
+ * The events utility interprets standard 16-byte IPMI events into
+ * human-readable form by default.
+ * User must pass raw 16-byte event data from some log text for decoding.
+ *
+ * Sample IPMI event usage:
+ * # ievents fb 07 02 e5 1a b8 44 21 00 03 1d 9a 6f 40 8f ff
+ * RecId Date/Time_______ SEV Src_ Evt_Type___ Sens# Evt_detail - Trig [Evt_data]
+ * 07fb 07/14/06 18:29:57 INF SMI System Boot Initiated #9a Power Up 6f [40 8f ff]
+ * # ievents 14 04 02 BE 35 13 45 33 40 04 0C 08 6F 20 00 04
+ * RecId Date/Time_______ SEV Src_ Evt_Type___ Sens# Evt_detail - Trig [Evt_data]
+ * 0414 09/21/06 21:00:46 MIN 4033 Memory #08 Correctable ECC, DIMM[4] 6f [20 00 04]
+ *
+ * If fPET, interpret the SNMP Platform Event Trap hex varbind data.
+ * For interpreting the 47-byte hex data from SNMP Platform Event Traps,
+ * specify events -p with the 34 data bytes following the 16-byte GUID.
+ *
+ * Sample SNMP PET Data for events:
+ * 0000: 3C A7 56 85 08 C5 11 D7 C3 A2 00 04 23 BC AC 12
+ * 0010: 51 14 11 72 38 58 FF FF 20 20 00 10 83 07 01 41
+ * 0020: 0F FF 00 00 00 00 00 19 00 00 01 57 00 22 C1
+ *
+ * Sample events -p command from above data:
+ * # ievents -p C3 A2 00 04 23 BC AC 12 51 14 11 72 38 58 FF FF 20 20 00 10 83 07 01 41 0F FF 00 00 00 00
+ * RecId Date/Time_______ SEV Src_ Evt_Type___ Sens# Evt_detail - Trig [Evt_data]
+ * 0014 04/11/07 12:03:20 INF BMC System Event #83 OEM System Booted 6f [41 0f ff]
+ *
+ * Platform Event Trap Format
+ * Offset Len Meaning
+ * 0 16 System GUID
+ * 16 2 Sequence Number/Cookie
+ * 18 4 Local Timestamp
+ * 22 2 UTC Offset
+ * 24 1 Trap Source Type (usu 0x20)
+ * 25 1 Event Source Type (usu 0x20)
+ * 26 1 Event Severity
+ * 27 1 Sensor Device
+ * 28 1 Sensor Number
+ * 29 1 Entity
+ * 30 1 Entity Instance
+ * 31 8 Event Data (8 bytes max, 3 bytes used)
+ * 39 1 Language Code (usu 0x19/25. = English)
+ * 40 4 Manufacturer IANA number (Intel=0x000157)
+ * 44 1-N OEM data, C1="No more fields"
+ * If Intel (0x000157):
+ * 44 2 Product ID
+ * 46 1 0xC1 (No more fields)
+ */
+#if defined(ALONE)
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#else
+/* #elif defined(METACOMMAND) or if libipmiutil */
+int i_events(int argc, char **argv)
+#endif
+{
+ uchar buf[50];
+ uchar msg[132];
+ uchar *pmsg;
+ int i, j, len;
+ char fPET = 0;
+ char frawfile = 0;
+ char fhexfile = 0;
+ int rv = 0;
+ char c;
+ uchar b = 0;
+#ifndef ALONE
+ uchar devid[16];
+#endif
+#if defined(METACOMMAND)
+ char *p;
+#endif
+
+ printf("%s version %s\n",progname,progver);
+ if (argc > 0) { argc--; argv++; } /*skip argv[0], program name*/
+ /* ievents getopt: [ -bdfhnoprstux -NPRUEFJTVY */
+ while ((argc > 0) && argv[0][0] == '-')
+ {
+ c = argv[0][1];
+ switch(c) {
+ case 'x': fdebug = 1; break;
+ case 'd': fgetdevid = 1; break; /*get device id (vendor, product)*/
+ case 'n': fnewevt = 1; break; /* generate New event */
+ case 'p': /* PET format, minus first 8 bytes*/
+ /* This is important for some SNMP trap receivers that obscure
+ * the first 8 bytes of the trap data */
+ fPET = 1; /*incoming data is in PET format*/
+ break;
+ case 'u': futc = 1; break; /*use raw UTC time*/
+#ifndef ALONE
+ case 'o': /*specify OEM IANA manufacturer id */
+ if (argc > 1) { /*next argv is IANA number */
+ i = atoi(argv[1]);
+ printf("setting IANA to %d (%s)\n",i,get_iana_str(i));
+ set_iana(i);
+ argc--; argv++;
+ } else {
+ printf("option -%c requires an argument\n",c);
+ rv = ERR_BAD_PARAM;
+ }
+ break;
+#endif
+ case 't': /*PET format Trap, use all data*/
+ /* This may be helpful if all bytes are available, or if
+ * the GUID is relevant. */
+ fPET = 1; /*incoming data is in PET format*/
+ pet_guid = 16;
+ break;
+ case 'f':
+ case 'r':
+ /* interpret raw ascii SEL file from optarg */
+ frawfile = 1;
+ if (argc > 1) { /*next argv is filename*/
+ len = strlen_(argv[1]);
+ if (len >= sizeof(rawfil))
+ len = sizeof(rawfil) - 1;
+ strncpy(rawfil,argv[1],len);
+ rawfil[len] = 0; /*stringify*/
+ argc--; argv++;
+ } else {
+ printf("option -%c requires a filename argument\n",c);
+ rv = ERR_BAD_PARAM;
+ }
+ break;
+ case 'b':
+ case 'h':
+ /* interpret raw binary/hex SEL file from optarg */
+ fhexfile = 1;
+ if (argc > 1) { /*next argv is filename*/
+ len = strlen_(argv[1]);
+ if (len >= sizeof(rawfil))
+ len = sizeof(rawfil) - 1;
+ strncpy(rawfil,argv[1],len);
+ rawfil[len] = 0; /*stringify*/
+ argc--; argv++;
+ } else {
+ printf("option -%c requires a filename argument\n",c);
+ rv = ERR_BAD_PARAM;
+ }
+ break;
+ case 's': /* get sensor file from optarg */
+ if (argc > 1) { /*next argv is filename*/
+ FILE *fp;
+ len = strlen_(argv[1]);
+ if (len >= sizeof(sensfil))
+ len = sizeof(sensfil) - 1;
+ strncpy(sensfil,argv[1],len);
+ sensfil[len] = 0; /*stringify*/
+ fp = fopen(sensfil,"r");
+ if (fp == NULL) {
+ printf("cannot open file %s\n",sensfil);
+ rv = ERR_FILE_OPEN;
+ } else fclose(fp);
+ argc--; argv++;
+ } else {
+ printf("option -%c requires a filename argument\n",c);
+ rv = ERR_BAD_PARAM;
+ }
+ fsensdesc = 2;
+ break;
+#if defined(METACOMMAND)
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ if (c == 'Y' || c == 'E') p = NULL;
+ else if (argc <= 1) {
+ printf("option -%c requires an argument\n",c);
+ rv = ERR_BAD_PARAM;
+ } else { /* has an optarg */
+ p = argv[1];
+ argc--; argv++;
+ }
+ if (rv == 0) parse_lan_options(c,p,fdebug);
+ break;
+#endif
+ default: /*unknown option*/
+ printf("Unknown option -%c\n",c);
+ show_usage();
+ rv = ERR_USAGE;
+ goto do_exit;
+ break;
+ }
+ argc--; argv++;
+ } /*end while options*/
+
+ len = argc; /*number of data bytes*/
+ if (!fPET && len > 16) len = 16; /* IPMI event max is 16 */
+ if (frawfile || fhexfile) len = 0;
+ else if (fnewevt) {
+ if (len < 9) {
+ printf("Need 9 bytes for a New event, got %d bytes input\n",len);
+ show_usage();
+ rv = ERR_BAD_PARAM;
+ }
+ } else if (len < 16) {
+ printf("Need 16 bytes for an IPMI event, got %d bytes input\n",len);
+ show_usage();
+ rv = ERR_BAD_PARAM;
+ }
+ if (rv != 0) goto do_exit;
+
+#ifndef ALONE
+ if (fgetdevid || fsensdesc)
+ rv = ipmi_getdeviceid( devid, sizeof(devid),fdebug); /*sets mfgid*/
+#endif
+
+ for (i = 0; i < len; i++)
+ {
+ if (fPET) msg[i] = _htoi(argv[i]);
+ else buf[i] = _htoi(argv[i]);
+ }
+ if (fPET != 0) /*PET, reorder bytes to std event format*/
+ {
+ uchar snum, styp;
+ int timestamp;
+ int yrs, time2;
+ char sensdesc[100];
+ int mfg;
+
+ pmsg = &msg[pet_guid]; /*pet_guid=8, skip the GUID*/
+ if (fdebug) {
+ printf("decoding IPMI PET event bytes\n");
+ dump_buf("PET buffer",msg,len,1);
+ }
+ /* pmsg[ 9] is event source type (gen id, usu 0x20) */
+ /* pmsg[10] is event severity */
+ /* pmsg[11] is sensor device */
+ /* pmsg[12] is sensor number */
+ /* pmsg[13] is Entity */
+ snum = pmsg[12];
+ styp = entity2sensor_type(pmsg[13]);
+ rv = get_sensdesc(pmsg[9],snum,sensdesc,&i,NULL);
+ if (rv == 0) {
+ styp = (uchar)i;
+ if (fdebug) printf("sensor[%02x]: %s\n",snum,sensdesc);
+ set_sel_opts(2,0, NULL,fdebug,futc);
+ } else {
+ if (rv == ERR_NOT_FOUND) {
+ printf("Cannot find snum %02x in %s\n",snum,sensfil);
+ printf("Resolve this by doing 'ipmiutil sensor >sensorX.txt' "
+ "on a system similar\nto the target, then use "
+ "'ipmiutil events -s sensorX.txt ...'\n");
+ }
+ /* Try GetSensorType(), which will work if local IPMI. */
+ rv = GetSensorType(snum,&b,NULL);
+ if (fdebug) printf("sensor[%02x]: GetSensorType rv=%d stype=%x\n",
+ snum,rv,b);
+ if (rv == 0) styp = b;
+ }
+
+ buf[0] = pmsg[1]; /*record id (sequence num)*/
+ buf[1] = 0; /* was pmsg[0]; */
+ buf[2] = 0x02; /*event type*/
+#ifdef RAW
+ buf[3] = pmsg[5]; /*timestamp*/
+ buf[4] = pmsg[4]; /*timestamp*/
+ buf[5] = pmsg[3]; /*timestamp*/
+ buf[6] = pmsg[2]; /*timestamp*/
+#else
+ timestamp = pmsg[5] + (pmsg[4] << 8) + (pmsg[3] << 16) + (pmsg[2] << 24);
+ /* add 28 years, includes 7 leap days, less 1 hour TZ fudge */
+ // yrs = ((3600 * 24) * 365 * 28) + (7 * (3600 * 24)) - 3600;
+ yrs = 0x34aace70;
+ time2 = timestamp + yrs;
+ if (fdebug)
+ printf("timestamp: %08x + %08x = %08x\n",timestamp,yrs,time2);
+ buf[3] = time2 & 0x000000ff; /*timestamp*/
+ buf[4] = (time2 & 0x0000ff00) >> 8; /*timestamp*/
+ buf[5] = (time2 & 0x00ff0000) >> 16; /*timestamp*/
+ buf[6] = (time2 & 0xff000000) >> 24; /*timestamp*/
+#endif
+ buf[7] = pmsg[9]; /*generator_id*/
+ buf[8] = 0;
+ buf[9] = 0x04; /*evm_rev*/
+ buf[10] = styp; /*derived sensor type, from above */
+ buf[11] = snum; /*sensor number*/
+ /* set the event trigger based on context */
+ switch(styp) { /*set the event trigger*/
+ case 0x12: buf[12] = 0x6f; break; /*system event (sensor-specific)*/
+ case 0x09: buf[12] = 0x0b; break; /*Power Unit*/
+ case 0x01: /*temp*/
+ case 0x02: /*voltage*/
+ case 0x03: /*current*/
+ case 0x04: /*fan*/
+ if (pmsg[10] == 0x04) buf[12] = 0x81; /*info severity, ok*/
+ else buf[12] = 0x01; /* threshold asserted*/
+ break;
+ default:
+ buf[12] = pmsg[14]; /*event trigger = Entity Instance */
+ /*Note that Entity Instance will not match an event trigger*/
+ buf[12] = 0x6f; /*set trigger to sensor-specific*/
+ break;
+ }
+ memcpy(&buf[13],&pmsg[15],3); /*event data*/
+ mfg = pmsg[27] + (pmsg[26] << 8) + (pmsg[25] << 16);
+ if (fdebug) {
+ printf("PET severity=%02x, mfgId=%02x%02x%02x%02x\n",
+ pmsg[10], pmsg[24], pmsg[25], pmsg[26], pmsg[27]);
+ dump_buf("IPMI event",buf,16,0);
+ }
+ if (mfg == VENDOR_SUN) { /* Sun = 0x00002A, extra OEM data */
+ j = 28 + pet_guid; /*offset 28+16=44 (OEM data) */
+ pmsg = &msg[j];
+ for (i = 0; (i+j) < len; ) {
+ if (pmsg[i] == 0xC1) break;
+ if (i == 0) i += 2; /* 2-byte header 0x0c 0x01 */
+ else if (pmsg[i] == 0x80) { /* 3-byte header, usu strings */
+ if (pmsg[i+2] == 0x03) printf(" %s\n",&pmsg[i+3]);
+ i += (3 + pmsg[i+1]);
+ } else i++;
+ }
+ }
+ decode_sel_entry(buf,msg,sizeof(msg));
+ printf("%s", evt_hdr); /*"RecId Date/Time_______*/
+ printf("%s", msg);
+ } else if (fnewevt) {
+ rv = new_event(buf,len); /*do new platform event*/
+ } else if (frawfile) {
+ rv = decode_raw_sel(rawfil,1); /*ascii raw data from file */
+ } else if (fhexfile) {
+ rv = decode_raw_sel(rawfil,2); /*binary/hex raw data from file*/
+ } else {
+ if (fdebug) printf("decoding standard IPMI event bytes\n");
+ if (fdebug) dump_buf("IPMI event",buf,16,0);
+ set_sel_opts(2,0, NULL,fdebug,futc);
+ rv = decode_sel_entry(buf,msg,sizeof(msg));
+ /* show header for the event record */
+ printf("%s", evt_hdr); /*"RecId Date/Time_______*/
+ printf("%s", msg);
+ }
+do_exit:
+#ifndef METACOMMAND
+ printf("%s, %s\n",progname,decode_rv(rv));
+#endif
+ return(rv);
+}
+// #endif
+
+/* end ievents.c */
diff --git a/util/ievents.h b/util/ievents.h
new file mode 100644
index 0000000..71bc449
--- /dev/null
+++ b/util/ievents.h
@@ -0,0 +1,64 @@
+/*
+ * ievents.h
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2011 Kontron America, Inc.
+ *
+ * 12/12/11 Andy Cress - created
+ */
+/*M*
+Copyright (c) 2011 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+/* Public routines from ievents.c */
+int decode_sel_entry( uchar *psel, char *outbuf, int sz);
+char *decode_entity_id(int id);
+char *get_sensor_type_desc(uchar stype);
+char *get_sev_str(int val);
+void fmt_time(time_t etime, char *buf, int bufsz);
+int get_sensor_tag(int isdr, int genid, uchar snum, char *tag,
+ uchar *sdr, int szsdr);
+void format_event(ushort id, time_t timestamp, int sevid, ushort genid,
+ char *ptype, uchar snum, char *psens, char *pstr, char *more,
+ char *outbuf, int outsz);
+/*
+ * set_sel_opts is used to specify options for showing/decoding SEL events.
+ * sensdesc : 0 = simple, no sensor descriptions
+ * 1 = get sensor descriptions from sdr cache
+ * 2 = get sensor descriptions from sensor file (-s)
+ * canon : 0 = normal output
+ * 1 = canonical, delimited output
+ * sdrs : NULL = no sdr cache, dynamically get sdr cache if sensdesc==1
+ * ptr = use this pointer as existing sdr cache if sensdesc==1
+ * fdbg : 0 = normal mode
+ * 1 = debug mode
+ * futc : 0 = normal mode
+ * 1 = show raw UTC time
+ */
+void set_sel_opts(int sensdsc, int canon, void *sdrs, char fdbg, char futc);
+
+/*end ievents.h*/
diff --git a/util/ifirewall.c b/util/ifirewall.c
new file mode 100644
index 0000000..b92d7d5
--- /dev/null
+++ b/util/ifirewall.c
@@ -0,0 +1,1154 @@
+/*
+ * ifirewall.c
+ * Handle firmware firewall IPMI command functions
+ *
+ * Change history:
+ * 06/04/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ * Copyright (c) 2010 Kontron America Inc. All Rights Reserved,
+ * Copyright (c) 2005 International Business Machines, Inc. All Rights Reserved
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *---------------------------------------------------------------------
+ */
+#ifdef WIN32
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include "ipmicmd.h"
+#include "ifirewall.h"
+
+/* global variables */
+static char * progname = "ifirewall";
+static char * progver = "2.93";
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+extern int verbose; /*see ipmilanplus.c*/
+
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+
+static void
+printf_firewall_usage(void)
+{
+ printf("Firmware Firewall Commands:\n");
+ printf("\tinfo [channel H] [lun L]\n");
+ printf("\tinfo [channel H] [lun L [netfn N [command C [subfn S]]]]\n");
+ printf("\tenable [channel H] [lun L [netfn N [command C [subfn S]]]]\n");
+ printf("\tdisable [channel H] [lun L [netfn N [command C [subfn S]]]] [force])\n");
+ printf("\treset [channel H] \n");
+ printf("\t\twhere H is a Channel, L is a LUN, N is a NetFn,\n");
+ printf("\t\tC is a Command and S is a Sub-Function\n");
+}
+
+// print n bytes of bit field bf (if invert, print ~bf)
+static void print_bitfield(const unsigned char * bf, int n, int invert, int loglevel) {
+ int i = 0;
+ if (loglevel < 0) {
+ while (i<n) {
+ printf("%02x", (unsigned char) (invert?~bf[i]:bf[i]));
+ if (++i % 4 == 0)
+ printf(" ");
+ }
+ printf("\n");
+ } else {
+ while (i<n) {
+ lprintf(loglevel, "%02x", (unsigned char) (invert?~bf[i]:bf[i]));
+ if (++i % 4 == 0)
+ lprintf(loglevel, " ");
+ }
+ lprintf(loglevel, "\n");
+ }
+
+}
+
+static int
+ipmi_firewall_parse_args(int argc, char ** argv, struct ipmi_function_params * p)
+{
+ int i;
+
+ if (!p) {
+ lprintf(LOG_ERR, "ipmi_firewall_parse_args: p is NULL");
+ return -1;
+ }
+ for (i=0; i<argc; i++) {
+ if (strncmp(argv[i], "channel", 7) == 0) {
+ if (++i < argc)
+ p->channel = atob(argv[i]);
+ }
+ else if (strncmp(argv[i], "lun", 3) == 0) {
+ if (++i < argc)
+ p->lun = atob(argv[i]);
+ }
+ else if (strncmp(argv[i], "force", 5) == 0) {
+ p->force = 1;
+ }
+ else if (strncmp(argv[i], "netfn", 5) == 0) {
+ if (++i < argc)
+ p->netfn = atob(argv[i]);
+ }
+ else if (strncmp(argv[i], "command", 7) == 0) {
+ if (++i < argc)
+ p->command = atob(argv[i]);
+ }
+ else if (strncmp(argv[i], "subfn", 5) == 0) {
+ if (++i < argc)
+ p->subfn = atob(argv[i]);
+ }
+ }
+ if (p->subfn >= MAX_SUBFN) {
+ printf("subfn is out of range (0-%d)\n", MAX_SUBFN-1);
+ return -1;
+ }
+ if (p->command >= MAX_COMMAND) {
+ printf("command is out of range (0-%d)\n", MAX_COMMAND-1);
+ return -1;
+ }
+ if (p->netfn >= MAX_NETFN) {
+ printf("netfn is out of range (0-%d)\n", MAX_NETFN-1);
+ return -1;
+ }
+ if (p->lun >= MAX_LUN) {
+ printf("lun is out of range (0-%d)\n", MAX_LUN-1);
+ return -1;
+ }
+ if (p->netfn >= 0 && p->lun < 0) {
+ printf("if netfn is set, lun must be set also\n");
+ return -1;
+ }
+ if (p->command >= 0 && p->netfn < 0) {
+ printf("if command is set, netfn must be set also\n");
+ return -1;
+ }
+ if (p->subfn >= 0 && p->command < 0) {
+ printf("if subfn is set, command must be set also\n");
+ return -1;
+ }
+ return 0;
+}
+
+/* _get_netfn_suport
+ *
+ * @intf: ipmi interface
+ * @channel: ipmi channel
+ * @lun: a pointer to a 4 byte field
+ * @netfn: a pointer to a 128-bit bitfield (16 bytes)
+ *
+ * returns 0 on success and fills in the bitfield for
+ * the 32 netfn * 4 LUN pairs that support commands
+ * returns -1 on error
+ */
+static int
+_get_netfn_support(void * intf, int channel, unsigned char * lun, unsigned char * netfn)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char * d, rqdata;
+ unsigned int l;
+
+ if (!lun || !netfn) {
+ lprintf(LOG_ERR, "_get_netfn_suport: lun or netfn is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_NETFN_SUPPORT;
+ rqdata = (unsigned char) channel;
+ req.msg.data = &rqdata;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get NetFn Support command failed: %d (0x%02x)\n",rv,rv);
+ return(rv);
+ }
+
+ d = &rsp[0];
+ for (l=0; l<4; l++) {
+ lun[l] = (*d)>>(2*l) & 0x3;
+ }
+ d++;
+
+ memcpy(netfn, d, 16);
+
+ return 0;
+}
+
+/* _get_command_suport
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @lnfn: a pointer to a struct lun_netfn_support
+ *
+ * returns 0 on success and fills in lnfn according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_command_support(void * intf,
+ struct ipmi_function_params * p, struct lun_netfn_support * lnfn)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char * d, rqdata[3];
+ unsigned int c;
+
+ if (!p || !lnfn) {
+ lprintf(LOG_ERR, "_get_command_suport: p or lnfn is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_SUPPORT;
+ rqdata[0] = (unsigned char)p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Support (LUN=%d, NetFn=%d, op=0) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = &rsp[0];
+ for (c=0; c<128; c++) {
+ if (!(d[c>>3] & (1<<(c%8))))
+ lnfn->command[c].support |= BIT_AVAILABLE;
+ }
+ memcpy(lnfn->command_mask, d, MAX_COMMAND_BYTES/2);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_SUPPORT;
+ rqdata[0] = (unsigned char)p->channel;
+ rqdata[1] = (unsigned char)(0x40 | p->netfn);
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Support (LUN=%d, NetFn=%d, op=1) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = &rsp[0];
+ for (c=0; c<128; c++) {
+ if (!(d[c>>3] & (1<<(c%8))))
+ lnfn->command[128+c].support |= BIT_AVAILABLE;
+ }
+ memcpy(lnfn->command_mask+MAX_COMMAND_BYTES/2, d, MAX_COMMAND_BYTES/2);
+ return 0;
+}
+
+/* _get_command_configurable
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @lnfn: a pointer to a struct lun_netfn_support
+ *
+ * returns 0 on success and fills in lnfn according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_command_configurable(void * intf,
+ struct ipmi_function_params * p, struct lun_netfn_support * lnfn)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char * d, rqdata[3];
+ unsigned int c;
+
+ if (!p || !lnfn) {
+ lprintf(LOG_ERR, "_get_command_configurable: p or lnfn is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_CONFIGURABLE_COMMANDS;
+ rqdata[0] = (unsigned char)p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Configurable Command (LUN=%d, NetFn=%d, op=0) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = rsp;
+ for (c=0; c<128; c++) {
+ if (d[c>>3] & (1<<(c%8)))
+ lnfn->command[c].support |= BIT_CONFIGURABLE;
+ }
+ memcpy(lnfn->config_mask, d, MAX_COMMAND_BYTES/2);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_CONFIGURABLE_COMMANDS;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)(0x40 | p->netfn);
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Configurable Command (LUN=%d, NetFn=%d, op=1) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = rsp;
+ for (c=0; c<128; c++) {
+ if (d[c>>3] & (1<<(c%8)))
+ lnfn->command[128+c].support |= BIT_CONFIGURABLE;
+ }
+ memcpy(lnfn->config_mask+MAX_COMMAND_BYTES/2, d, MAX_COMMAND_BYTES/2);
+ return 0;
+}
+
+/* _get_command_enables
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @lnfn: a pointer to a struct lun_netfn_support
+ *
+ * returns 0 on success and fills in lnfn according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_command_enables(void * intf,
+ struct ipmi_function_params * p, struct lun_netfn_support * lnfn)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char * d, rqdata[3];
+ unsigned int c;
+
+ if (!p || !lnfn) {
+ lprintf(LOG_ERR, "_get_command_enables: p or lnfn is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Enables (LUN=%d, NetFn=%d, op=0) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = rsp;
+ for (c=0; c<128; c++) {
+ if (d[c>>3] & (1<<(c%8)))
+ lnfn->command[c].support |= BIT_ENABLED;
+ }
+ memcpy(lnfn->enable_mask, d, MAX_COMMAND_BYTES/2);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)(0x40 | p->netfn);
+ rqdata[2] = (unsigned char)p->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Enables (LUN=%d, NetFn=%d, op=1) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+
+ d = rsp;
+ for (c=0; c<128; c++) {
+ if (d[c>>3] & (1<<(c%8)))
+ lnfn->command[128+c].support |= BIT_ENABLED;
+ }
+ memcpy(lnfn->enable_mask+MAX_COMMAND_BYTES/2, d, MAX_COMMAND_BYTES/2);
+ return 0;
+}
+
+/* _set_command_enables
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @lnfn: a pointer to a struct lun_netfn_support that contains current info
+ * @enable: a pointer to a 32 byte bitfield that contains the desired enable state
+ * @gun: here is a gun to shoot yourself in the foot. If this is true
+ * you are allowed to disable this command
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+static int
+_set_command_enables(void * intf,
+ struct ipmi_function_params * p, struct lun_netfn_support * lnfn,
+ unsigned char * enable, int gun)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char * d, rqdata[19];
+ unsigned int c;
+
+ if (!p || !lnfn) {
+ lprintf(LOG_ERR, "_set_command_enables: p or lnfn is NULL");
+ return -1;
+ }
+
+ lprintf(LOG_INFO, "support: ");
+ print_bitfield(lnfn->command_mask, MAX_COMMAND_BYTES, 1, LOG_INFO);
+ lprintf(LOG_INFO, "configurable: ");
+ print_bitfield(lnfn->config_mask, MAX_COMMAND_BYTES, 0, LOG_INFO);
+ lprintf(LOG_INFO, "enabled: ");
+ print_bitfield(lnfn->enable_mask, MAX_COMMAND_BYTES, 0, LOG_INFO);
+ lprintf(LOG_INFO, "enable mask before: ");
+ print_bitfield(enable, MAX_COMMAND_BYTES, 0, LOG_INFO);
+
+ // mask off the appropriate bits (if not configurable, set enable bit
+ // must be the same as the current enable bit)
+ for (c=0; c<(MAX_COMMAND_BYTES); c++) {
+ enable[c] = (lnfn->config_mask[c] & enable[c]) |
+ (~lnfn->config_mask[c] & lnfn->enable_mask[c]);
+ }
+
+ // take the gun out of their hand if they are not supposed to have it
+ if (!gun) {
+ enable[SET_COMMAND_ENABLE_BYTE] =
+ (lnfn->config_mask[SET_COMMAND_ENABLE_BYTE]
+ & SET_COMMAND_ENABLE_BIT) |
+ (~lnfn->config_mask[SET_COMMAND_ENABLE_BYTE]
+ & lnfn->enable_mask[SET_COMMAND_ENABLE_BYTE]);
+ }
+ lprintf(LOG_INFO, "enable mask after: ");
+ print_bitfield(enable, MAX_COMMAND_BYTES, 0, LOG_INFO);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_SET_COMMAND_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ memcpy(&rqdata[3], enable, MAX_COMMAND_BYTES/2);
+ req.msg.data = rqdata;
+ req.msg.data_len = 19;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Set Command Enables (LUN=%d, NetFn=%d, op=0) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+ d = &rsp[0];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_SET_COMMAND_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)(0x40 | p->netfn);
+ rqdata[2] = (unsigned char)p->lun;
+ memcpy(&rqdata[3], enable+MAX_COMMAND_BYTES/2, MAX_COMMAND_BYTES/2);
+ req.msg.data = rqdata;
+ req.msg.data_len = 19;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Set Command Enables (LUN=%d, NetFn=%d, op=1) command failed: %d (0x%02x)\n", p->lun, p->netfn, rv,rv);
+ return(rv);
+ }
+ d = &rsp[0];
+
+ return 0;
+}
+
+/* _get_subfn_support
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @cmd: a pointer to a struct command_support
+ *
+ * returns 0 on success and fills in cmd according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_subfn_support(void * intf,
+ struct ipmi_function_params * p, struct command_support * cmd)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char rqdata[4];
+
+ if (!p || !cmd) {
+ lprintf(LOG_ERR, "_get_subfn_support: p or cmd is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_SUBFUNCTION_SUPPORT;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ rqdata[3] = (unsigned char)p->command;
+ req.msg.data = rqdata;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Subfunction Support (LUN=%d, NetFn=%d, cmd=%d) command failed: %d (0x%02x)\n", p->lun, p->netfn, p->command, rv,rv);
+ return(rv);
+ }
+
+ memcpy(cmd->subfn_support, rsp, sizeof(cmd->subfn_support));
+ return 0;
+}
+
+/* _get_subfn_configurable
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @cmd: a pointer to a struct command_support
+ *
+ * returns 0 on success and fills in cmd according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_subfn_configurable(void * intf,
+ struct ipmi_function_params * p, struct command_support * cmd)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char rqdata[4];
+
+ if (!p || !cmd) {
+ lprintf(LOG_ERR, "_get_subfn_configurable: p or cmd is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_CONFIGURABLE_COMMAND_SUBFUNCTIONS;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ rqdata[3] = (unsigned char)p->command;
+ req.msg.data = rqdata;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Configurable Command Subfunction Support (LUN=%d, NetFn=%d, cmd=%d) command failed: %d (0x%02x)\n", p->lun, p->netfn, p->command, rv,rv);
+ return(rv);
+ }
+
+ memcpy(cmd->subfn_config, rsp, sizeof(cmd->subfn_config));
+ return 0;
+}
+
+/* _get_subfn_enables
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @cmd: a pointer to a struct command_support
+ *
+ * returns 0 on success and fills in cmd according to the request in p
+ * returns -1 on error
+ */
+static int
+_get_subfn_enables(void * intf,
+ struct ipmi_function_params * p, struct command_support * cmd)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char rqdata[4];
+
+ if (!p || !cmd) {
+ lprintf(LOG_ERR, "_get_subfn_enables: p or cmd is NULL");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_COMMAND_SUBFUNCTION_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ rqdata[3] = (unsigned char)p->command;
+ req.msg.data = rqdata;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Get Command Subfunction Enables (LUN=%d, NetFn=%d, cmd=%d) command failed: %d (0x%02x)\n", p->lun, p->netfn, p->command, rv,rv);
+ return(rv);
+ }
+
+ memcpy(cmd->subfn_enable, rsp, sizeof(cmd->subfn_enable));
+ return 0;
+}
+
+/* _set_subfn_enables
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @cmd: a pointer to a struct command_support
+ * @enable: a pointer to a 4 byte bitfield that contains the desired enable state
+ *
+ * returns 0 on success (and modifies enable to be the bits it actually set)
+ * returns -1 on error
+ */
+static int
+_set_subfn_enables(void * intf,
+ struct ipmi_function_params * p, struct command_support * cmd,
+ unsigned char * enable)
+{
+ struct ipmi_rq req;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ unsigned char rqdata[8];
+ unsigned int c;
+
+ if (!p || !cmd) {
+ lprintf(LOG_ERR, "_set_subfn_enables: p or cmd is NULL");
+ return -1;
+ }
+
+ lprintf(LOG_INFO, "support: ");
+ print_bitfield(cmd->subfn_support, MAX_SUBFN_BYTES, 1, LOG_INFO);
+ lprintf(LOG_INFO, "configurable: ");
+ print_bitfield(cmd->subfn_config, MAX_SUBFN_BYTES, 0, LOG_INFO);
+ lprintf(LOG_INFO, "enabled: ");
+ print_bitfield(cmd->subfn_enable, MAX_SUBFN_BYTES, 0, LOG_INFO);
+ lprintf(LOG_INFO, "enable mask before: ");
+ print_bitfield(enable, MAX_SUBFN_BYTES, 0, LOG_INFO);
+ // mask off the appropriate bits (if not configurable, set enable bit
+ // must be the same as the current enable bit)
+ for (c=0; c<sizeof(cmd->subfn_enable); c++) {
+ enable[c] = (cmd->subfn_config[c] & enable[c]) |
+ (~cmd->subfn_config[c] & cmd->subfn_enable[c]);
+ }
+ lprintf(LOG_INFO, "enable mask after: ");
+ print_bitfield(enable, MAX_SUBFN_BYTES, 0, LOG_INFO);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_SET_COMMAND_SUBFUNCTION_ENABLES;
+ rqdata[0] = (unsigned char) p->channel;
+ rqdata[1] = (unsigned char)p->netfn;
+ rqdata[2] = (unsigned char)p->lun;
+ rqdata[3] = (unsigned char)p->command;
+ memcpy(&rqdata[4], enable, MAX_SUBFN_BYTES);
+ req.msg.data = rqdata;
+ req.msg.data_len = 8;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Set Command Subfunction Enables (LUN=%d, NetFn=%d, cmd=%d) command failed: %d (0x%02x)\n", p->lun, p->netfn, p->command, rv,rv);
+ return(rv);
+ }
+
+ return 0;
+}
+
+/* _gather_info
+ *
+ * @intf: ipmi interface
+ * @p: a pointer to a struct ipmi_function_params
+ * @bmc: a pointer to a struct bmc_fn_support
+ * @enable: a pointer to a 4 byte bitfield that contains the desired enable state
+ *
+ * returns 0 on success and fills in bmc according to request p
+ * returns -1 on error
+ */
+static int _gather_info(void * intf, struct ipmi_function_params * p, struct bmc_fn_support * bmc)
+{
+ int ret, l, n;
+ unsigned char lun[MAX_LUN], netfn[16];
+
+ ret = _get_netfn_support(intf, p->channel, lun, netfn);
+ if (ret != 0) return (ret);
+ else { /*success*/
+ for (l=0; l<MAX_LUN; l++) {
+ if (p->lun >= 0 && p->lun != l)
+ continue;
+ bmc->lun[l].support = lun[l];
+ if (lun[l]) {
+ for (n=0; n<MAX_NETFN_PAIR; n++) {
+ int offset = l*MAX_NETFN_PAIR+n;
+ bmc->lun[l].netfn[n].support =
+ !!(netfn[offset>>3] & (1<<(offset%8)));
+ }
+ }
+ }
+ }
+ if (p->netfn >= 0) {
+ if (!((p->lun < 0 || bmc->lun[p->lun].support) &&
+ (p->netfn < 0 || bmc->lun[p->lun].netfn[p->netfn>>1].support))) {
+ lprintf(LOG_ERR, "LUN or LUN/NetFn pair %d,%d not supported", p->lun, p->netfn);
+ return 0;
+ }
+ ret = _get_command_support(intf, p, &(bmc->lun[p->lun].netfn[p->netfn>>1]));
+ ret |= _get_command_configurable(intf, p, &(bmc->lun[p->lun].netfn[p->netfn>>1]));
+ ret |= _get_command_enables(intf, p, &(bmc->lun[p->lun].netfn[p->netfn>>1]));
+ if (!ret && p->command >= 0) {
+ ret = _get_subfn_support(intf, p,
+ &(bmc->lun[p->lun].netfn[p->netfn>>1].command[p->command]));
+ ret |= _get_subfn_configurable(intf, p,
+ &(bmc->lun[p->lun].netfn[p->netfn>>1].command[p->command]));
+ ret |= _get_subfn_enables(intf, p,
+ &(bmc->lun[p->lun].netfn[p->netfn>>1].command[p->command]));
+ }
+ }
+ else if (p->lun >= 0) {
+ l = p->lun;
+ if (bmc->lun[l].support) {
+ for (n=0; n<MAX_NETFN_PAIR; n++) {
+ p->netfn = n*2;
+ if (bmc->lun[l].netfn[n].support) {
+ ret = _get_command_support(intf, p, &(bmc->lun[l].netfn[n]));
+ ret |= _get_command_configurable(intf, p, &(bmc->lun[l].netfn[n]));
+ ret |= _get_command_enables(intf, p, &(bmc->lun[l].netfn[n]));
+ }
+ if (ret)
+ bmc->lun[l].netfn[n].support = 0;
+ }
+ }
+ p->netfn = -1;
+ } else {
+ for (l=0; l<4; l++) {
+ p->lun = l;
+ if (bmc->lun[l].support) {
+ for (n=0; n<MAX_NETFN_PAIR; n++) {
+ p->netfn = n*2;
+ if (bmc->lun[l].netfn[n].support) {
+ ret = _get_command_support(intf, p, &(bmc->lun[l].netfn[n]));
+ ret |= _get_command_configurable(intf, p, &(bmc->lun[l].netfn[n]));
+ ret |= _get_command_enables(intf, p, &(bmc->lun[l].netfn[n]));
+ }
+ if (ret)
+ bmc->lun[l].netfn[n].support = 0;
+ }
+ }
+ }
+ p->lun = -1;
+ p->netfn = -1;
+ }
+
+ return 0;
+}
+
+/* ipmi_firewall_info - print out info for firewall functions
+ *
+ * @intf: ipmi inteface
+ * @argc: argument count
+ * @argv: argument list
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+static int
+ipmi_firewall_info(void * intf, int argc, char ** argv)
+{
+ int ret = 0;
+ struct ipmi_function_params p = {0xe, -1, -1, -1, -1};
+ struct bmc_fn_support * bmc_fn_support;
+ unsigned int l, n, c;
+
+ if ((argc > 0 && strncmp(argv[0], "help", 4) == 0) || ipmi_firewall_parse_args(argc, argv, &p) < 0)
+ {
+ printf("info [channel H]\n");
+ printf("\tlist all of the firewall information for all LUNs, NetFns, and Commands\n");
+ printf("\tthis is a long list and is not very human readable\n");
+ printf("info [channel H] lun L\n");
+ printf("\tthis also prints a long list that is not very human readable\n");
+ printf("info [channel H] lun L netfn N\n");
+ printf("\tthis prints out information for a single LUN/NetFn pair\n");
+ printf("\tthat is not really very usable, but at least it is short\n");
+ printf("info [channel H] lun L netfn N command C\n");
+ printf("\tthis is the one you want -- it prints out detailed human\n");
+ printf("\treadable information. It shows the support, configurable, and\n");
+ printf("\tenabled bits for the Command C on LUN/NetFn pair L,N and the\n");
+ printf("\tsame information about each of its Sub-functions\n");
+ return 0;
+ }
+
+ bmc_fn_support = malloc(sizeof(struct bmc_fn_support));
+ if (!bmc_fn_support) {
+ lprintf(LOG_ERR, "malloc struct bmc_fn_support failed");
+ return -1;
+ }
+
+ ret = _gather_info(intf, &p, bmc_fn_support);
+
+ if (p.command >= 0) {
+ struct command_support * cmd;
+ if (!((p.lun < 0 || bmc_fn_support->lun[p.lun].support) &&
+ (p.netfn < 0 || bmc_fn_support->lun[p.lun].netfn[p.netfn>>1].support) &&
+ bmc_fn_support->lun[p.lun].netfn[p.netfn>>1].command[p.command].support))
+ {
+ lprintf(LOG_ERR, "Command 0x%02x not supported on LUN/NetFn pair %02x,%02x",
+ p.command, p.lun, p.netfn);
+ free(bmc_fn_support);
+ return 0;
+ }
+ cmd =
+ &bmc_fn_support->lun[p.lun].netfn[p.netfn>>1].command[p.command];
+ c = cmd->support;
+ printf("(A)vailable, (C)onfigurable, (E)nabled: | A | C | E |\n");
+ printf("-----------------------------------------------------\n");
+ printf("LUN %01d, NetFn 0x%02x, Command 0x%02x: | %c | %c | %c |\n",
+ p.lun, p.netfn, p.command,
+ (c & BIT_AVAILABLE) ? 'X' : ' ',
+ (c & BIT_CONFIGURABLE) ? 'X' : ' ',
+ (c & BIT_ENABLED) ? 'X': ' ');
+
+ for (n=0; n<MAX_SUBFN; n++) {
+ printf("sub-function 0x%02x: | %c | %c | %c |\n", n,
+ (!bit_test(cmd->subfn_support, n)) ? 'X' : ' ',
+ (bit_test(cmd->subfn_config, n)) ? 'X' : ' ',
+ (bit_test(cmd->subfn_enable, n)) ? 'X' : ' ');
+ }
+ }
+ else if (p.netfn >= 0) {
+ if (!((p.lun < 0 || bmc_fn_support->lun[p.lun].support) &&
+ (bmc_fn_support->lun[p.lun].netfn[p.netfn>>1].support)))
+ {
+ lprintf(LOG_ERR, "LUN or LUN/NetFn pair %02x,%02x not supported",
+ p.lun, p.netfn);
+ free(bmc_fn_support);
+ return 0;
+ }
+ n = p.netfn >> 1;
+ l = p.lun;
+ printf("Commands on LUN 0x%02x, NetFn 0x%02x\n", p.lun, p.netfn);
+ printf("support: ");
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].command_mask,
+ MAX_COMMAND_BYTES, 1, -1);
+ printf("configurable: ");
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].config_mask,
+ MAX_COMMAND_BYTES, 0, -1);
+ printf("enabled: ");
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].enable_mask,
+ MAX_COMMAND_BYTES, 0, -1);
+ }
+ else {
+ for (l=0; l<4; l++) {
+ p.lun = l;
+ if (bmc_fn_support->lun[l].support) {
+ for (n=0; n<MAX_NETFN_PAIR; n++) {
+ p.netfn = n*2;
+ if (bmc_fn_support->lun[l].netfn[n].support) {
+ printf("%02x,%02x support: ", p.lun, p.netfn);
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].command_mask,
+ MAX_COMMAND_BYTES, 1, -1);
+ printf("%02x,%02x configurable: ", p.lun, p.netfn);
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].config_mask,
+ MAX_COMMAND_BYTES, 0, -1);
+ printf("%02x,%02x enabled: ", p.lun, p.netfn);
+ print_bitfield(bmc_fn_support->lun[l].netfn[n].enable_mask,
+ MAX_COMMAND_BYTES, 0, -1);
+ }
+ }
+ }
+ }
+ p.lun = -1;
+ p.netfn = -1;
+ }
+
+ free(bmc_fn_support);
+ return ret;
+}
+
+/* ipmi_firewall_enable_disable - enable/disable BMC functions
+ *
+ * @intf: ipmi inteface
+ * @enable: whether to enable or disable
+ * @argc: argument count
+ * @argv: argument list
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+static int
+ipmi_firewall_enable_disable(void * intf, int enable, int argc, char ** argv)
+{
+ struct ipmi_function_params p = {0xe, -1, -1, -1, -1};
+ struct bmc_fn_support * bmc_fn_support;
+ unsigned int l, n, c;
+ int ret;
+ unsigned char enables[MAX_COMMAND_BYTES];
+
+ if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
+ char * s1 = enable?"en":"dis";
+ char * s2 = enable?"":" [force]";
+ printf("%sable [channel H] lun L netfn N%s\n", s1, s2);
+ printf("\t%sable all commands on this LUN/NetFn pair\n", s1);
+ printf("%sable [channel H] lun L netfn N command C%s\n", s1, s2);
+ printf("\t%sable Command C and all its Sub-functions for this LUN/NetFn pair\n", s1);
+ printf("%sable [channel H] lun L netfn N command C subfn S\n", s1);
+ printf("\t%sable Sub-function S for Command C for this LUN/NetFn pair\n", s1);
+ if (!enable) {
+ printf("* force will allow you to disable the \"Command Set Enable\" command\n");
+ printf("\tthereby letting you shoot yourself in the foot\n");
+ printf("\tthis is only recommended for advanced users\n");
+ }
+ return 0;
+ }
+ if (ipmi_firewall_parse_args(argc, argv, &p) < 0)
+ return -1;
+
+ bmc_fn_support = malloc(sizeof(struct bmc_fn_support));
+ if (!bmc_fn_support) {
+ lprintf(LOG_ERR, "malloc struct bmc_fn_support failed");
+ return -1;
+ }
+
+ ret = _gather_info(intf, &p, bmc_fn_support);
+ if (ret < 0) {
+ free(bmc_fn_support);
+ return ret;
+ }
+
+ l = p.lun;
+ n = p.netfn>>1;
+ c = p.command;
+ if (p.subfn >= 0) {
+ // firewall (en|dis)able [channel c] lun l netfn n command m subfn s
+ // (en|dis)able this sub-function for this commnad on this lun/netfn pair
+ memcpy(enables,
+ bmc_fn_support->lun[l].netfn[n].command[c].subfn_enable,
+ MAX_SUBFN_BYTES);
+ bit_set(enables, p.subfn, enable);
+ ret = _set_subfn_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n].command[c], enables);
+
+ } else if (p.command >= 0) {
+ // firewall (en|dis)able [channel c] lun l netfn n command m
+ // (en|dis)able all subfn and command for this commnad on this lun/netfn pair
+ memset(enables, enable?0xff:0, MAX_SUBFN_BYTES);
+ ret = _set_subfn_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n].command[c], enables);
+ memcpy(enables,
+ &bmc_fn_support->lun[l].netfn[n].enable_mask, sizeof(enables));
+ bit_set(enables, p.command, enable);
+ ret |= _set_command_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n], enables, p.force);
+ } else if (p.netfn >= 0) {
+ // firewall (en|dis)able [channel c] lun l netfn n
+ // (en|dis)able all commnads on this lun/netfn pair
+ memset(enables, enable?0xff:0, sizeof(enables));
+ ret = _set_command_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n], enables, p.force);
+ /*
+ } else if (p.lun >= 0) {
+ // firewall (en|dis)able [channel c] lun l
+ // (en|dis)able all commnads on all netfn pairs for this lun
+ */
+ }
+ free(bmc_fn_support);
+ return ret;
+}
+
+/* ipmi_firewall_reset - reset firmware firewall to enable everything
+ *
+ * @intf: ipmi inteface
+ * @argc: argument count
+ * @argv: argument list
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+static int
+ipmi_firewall_reset(void * intf, int argc, char ** argv)
+{
+ struct ipmi_function_params p = {0xe, -1, -1, -1, -1};
+ struct bmc_fn_support * bmc_fn_support;
+ unsigned int l, n, c;
+ int ret;
+ unsigned char enables[MAX_COMMAND_BYTES];
+
+ if (argc > 0 || (argc > 0 && strncmp(argv[0], "help", 4) == 0)) {
+ printf_firewall_usage();
+ return 0;
+ }
+ if (ipmi_firewall_parse_args(argc, argv, &p) < 0)
+ return -1;
+
+ bmc_fn_support = malloc(sizeof(struct bmc_fn_support));
+ if (!bmc_fn_support) {
+ lprintf(LOG_ERR, "malloc struct bmc_fn_support failed");
+ return -1;
+ }
+
+ ret = _gather_info(intf, &p, bmc_fn_support);
+ if (ret < 0) {
+ free(bmc_fn_support);
+ return ret;
+ }
+
+ for (l=0; l<MAX_LUN; l++) {
+ p.lun = l;
+ for (n=0; n<MAX_NETFN; n+=2) {
+ p.netfn = n;
+ for (c=0; c<MAX_COMMAND; c++) {
+ p.command = c;
+ printf("reset lun %d, netfn %d, command %d, subfn\n", l, n, c);
+ memset(enables, 0xff, MAX_SUBFN_BYTES);
+ ret = _set_subfn_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n].command[c], enables);
+ }
+ printf("reset lun %d, netfn %d, command\n", l, n);
+ memset(enables, 0xff, sizeof(enables));
+ ret = _set_command_enables(intf, &p,
+ &bmc_fn_support->lun[l].netfn[n], enables, 0);
+ }
+ }
+
+ free(bmc_fn_support);
+ return ret;
+}
+
+#ifdef METACOMMAND
+int i_firewall(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"m:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 1; verbose = 1;
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ printf_firewall_usage();
+ return 0;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
+ printf_firewall_usage();
+ }
+ else if (strncmp(argv[0], "info", 4) == 0) {
+ rc = ipmi_firewall_info(intf, argc-1, &(argv[1]));
+ }
+ else if (strncmp(argv[0], "enable", 6) == 0) {
+ rc = ipmi_firewall_enable_disable(intf, 1, argc-1, &(argv[1]));
+ }
+ else if (strncmp(argv[0], "disable", 7) == 0) {
+ rc = ipmi_firewall_enable_disable(intf, 0, argc-1, &(argv[1]));
+ }
+ else if (strncmp(argv[0], "reset", 5) == 0) {
+ rc = ipmi_firewall_reset(intf, argc-1, &(argv[1]));
+ }
+ else {
+ printf_firewall_usage();
+ rc = ERR_BAD_PARAM;
+ }
+
+ ipmi_close_();
+ // show_outcome(progname,rc);
+ return rc;
+}
diff --git a/util/ifirewall.h b/util/ifirewall.h
new file mode 100644
index 0000000..14a04f4
--- /dev/null
+++ b/util/ifirewall.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_FIREWALL_H
+#define IPMI_FIREWALL_H
+
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+
+// struct ipmi_rq definition was moved to ipmicmd.h
+#define IPMI_NETFN_APP 0x06
+
+#define BMC_GET_NETFN_SUPPORT 0x09
+#define BMC_GET_COMMAND_SUPPORT 0x0A
+#define BMC_GET_COMMAND_SUBFUNCTION_SUPPORT 0x0B
+#define BMC_GET_CONFIGURABLE_COMMANDS 0x0C
+#define BMC_GET_CONFIGURABLE_COMMAND_SUBFUNCTIONS 0x0D
+#define BMC_SET_COMMAND_ENABLES 0x60
+#define BMC_GET_COMMAND_ENABLES 0x61
+#define BMC_SET_COMMAND_SUBFUNCTION_ENABLES 0x62
+#define BMC_GET_COMMAND_SUBFUNCTION_ENABLES 0x63
+#define BMC_OEM_NETFN_IANA_SUPPORT 0x64
+
+#define SET_COMMAND_ENABLE_BYTE (BMC_SET_COMMAND_ENABLES / 8)
+#define SET_COMMAND_ENABLE_BIT (BMC_SET_COMMAND_ENABLES % 8)
+
+#define MAX_LUN 4
+#define MAX_NETFN 64
+#define MAX_NETFN_PAIR (MAX_NETFN/2)
+#define MAX_COMMAND 256
+#define MAX_SUBFN 32
+#define MAX_COMMAND_BYTES (MAX_COMMAND>>3)
+#define MAX_SUBFN_BYTES (MAX_SUBFN>>3)
+
+// support is a bitfield with the following bits set...
+#define BIT_AVAILABLE 0x01
+#define BIT_CONFIGURABLE 0x02
+#define BIT_ENABLED 0x04
+
+struct command_support {
+ unsigned char support;
+ unsigned char version[3];
+ unsigned char subfn_support[MAX_SUBFN_BYTES];
+ unsigned char subfn_config[MAX_SUBFN_BYTES];
+ unsigned char subfn_enable[MAX_SUBFN_BYTES];
+};
+struct lun_netfn_support {
+ unsigned char support;
+ struct command_support command[MAX_COMMAND];
+ unsigned char command_mask[MAX_COMMAND_BYTES];
+ unsigned char config_mask[MAX_COMMAND_BYTES];
+ unsigned char enable_mask[MAX_COMMAND_BYTES];
+};
+struct lun_support {
+ unsigned char support;
+ struct lun_netfn_support netfn[MAX_NETFN_PAIR];
+};
+struct bmc_fn_support {
+ struct lun_support lun[MAX_LUN];
+};
+struct ipmi_function_params {
+ int channel;
+ int lun;
+ int netfn;
+ int command;
+ int subfn;
+ unsigned char force;
+};
+
+#ifdef WIN32
+#define INLINE /*nop*/
+#else
+#define INLINE inline
+#endif
+static INLINE int bit_test(const unsigned char * bf, int n) {
+ return !!(bf[n>>3]&(1<<(n%8)));
+}
+static INLINE void bit_set(unsigned char * bf, int n, int v) {
+ bf[n>>3] = (bf[n>>3] & ~(1<<(n%8))) | ((v?1:0)<<(n%8));
+}
+
+#endif /*IPMI_FIREWALL_H */
diff --git a/util/ifru.c b/util/ifru.c
new file mode 100755
index 0000000..ba834e6
--- /dev/null
+++ b/util/ifru.c
@@ -0,0 +1,2123 @@
+/*
+ * ifru (was fruconfig.c)
+ *
+ * This tool reads the FRU configuration, and optionally sets the asset
+ * tag field in the FRU data. See IPMI v1.5 spec section 28.
+ * It can use either the Intel /dev/imb driver or VALinux /dev/ipmikcs.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 10/28/02 Andy Cress - created
+ * 12/11/02 Andy Cress v0.9 - disable write until checksum fixed.
+ * 12/13/02 Andy Cress v0.91 - don't abort if cc=c9 in load_fru loop.
+ * 01/27/03 Andy Cress v0.92 - more debug, do checksums,
+ * 01/28/03 Andy Cress v1.0 do writes in small chunks, tested w SCB2 & STL2
+ * 02/19/03 Andy Cress v1.1 also get System GUID
+ * 03/10/03 Andy Cress v1.2 do better bounds checking on FRU size
+ * 04/30/03 Andy Cress v1.3 Board Part# & Serial# reversed
+ * 05/13/03 Andy Cress v1.4 Added Chassis fields
+ * 06/19/03 Andy Cress v1.5 added errno.h (email from Travers Carter)
+ * 05/03/04 Andy Cress v1.6 BladeCenter has no product area, only board area
+ * 05/05/04 Andy Cress v1.7 call ipmi_close before exit,
+ * added WIN32 compile options.
+ * 11/01/04 Andy Cress v1.8 add -N / -R for remote nodes
+ * 12/10/04 Andy Cress v1.9 add gnu freeipmi interface
+ * 01/13/05 Andy Cress v1.10 add logic to scan SDRs for all FRU devices,
+ * and interpret them
+ * 01/17/05 Andy Cress v1.11 decode SPD Manufacturer
+ * 01/21/05 Andy Cress v1.12 format SystemGUID display
+ * 02/03/05 Andy Cress v1.13 fixed fwords bit mask in load_fru,
+ * decode DIMM size from SPD also.
+ * 02/04/05 Andy Cress v1.14 decode FRU Board Mfg DateTime
+ * 03/16/05 Andy Cress v1.15 show Asset Tag Length earlier
+ * 05/24/05 Andy Cress v1.16 only do write_asset if successful show_fru
+ * 06/20/05 Andy Cress v1.17 handle Device SDRs also for ATCA
+ * 08/22/05 Andy Cress v1.18 allow setting Product Serial Number also (-s),
+ * also add -b option to show only baseboard data.
+ * 10/31/06 Andy Cress v1.25 handle 1-char asset/serial strings (avoid c1)
+ */
+/*M*
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <errno.h>
+#endif
+#endif
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "ipicmg.h"
+#include "oem_intel.h"
+#include "ifru.h"
+
+#define PICMG_CHILD 1
+#define MIN_SDR_SZ 8
+#ifndef URNLOOPS
+#define URNLOOPS 1000
+#endif
+extern int get_BiosVersion(char *str);
+extern int get_SystemGuid(uchar *guid);
+extern void fmt_time(time_t etime, char *buf, int bufsz); /*see ievents.c*/
+extern int get_LastError( void ); /* ipmilan.c */
+extern int GetSDRRepositoryInfo(int *nret, int *fdev); /*isensor.h*/
+#ifdef METACOMMAND
+extern int ipmi_kontronoem_main(void * intf, int argc, char ** argv);
+#endif
+
+static char *progname = "ifru";
+static char *progver = "2.93";
+static int vend_id = 0;
+static int prod_id = 0;
+static char fdebug = 0;
+static char fpicmg = 0;
+static char fonlybase = 0;
+static char fonlyhsc = 0;
+static int fwritefru = 0;
+static int fdevsdrs = 0;
+static char fshowlen = 0;
+static char ftestshow = 0;
+// static char fgetfru = 0;
+static char fdoanyway = 0;
+static char fprivset = 0;
+static char fset_mc = 0;
+static char fcanonical = 0;
+static char foemkontron = 0;
+static char fbasefru = 1;
+static char fdump = 0;
+static char frestore = 0;
+static char fchild = 0; /* =1 follow child MCs if picmg bladed*/
+static char do_systeminfo = 1;
+static char do_guid = 1;
+static char bdelim = ':';
+static uchar bmc_sa = BMC_SA; /*defaults to 0x20*/
+static uchar guid[17] = "";
+static char *binfile = NULL;
+static uchar *frubuf = NULL;
+#define FIELD_LEN 20
+#define SZ_PRODAREA 520 /* product area max is 8*32 + 3 = 259 mod 8 = 264 */
+static int sfru = 0;
+static int asset_offset = -1;
+static int asset_len = 0;
+static int sernum_offset = -1;
+static int sernum_len = 0;
+static int prodver_offset = -1;
+static int prodver_len = 0;
+static int chassis_offset = -1;
+static int chassis_len = 0;
+static char asset_tag[FIELD_LEN] = {0};
+static char serial_num[FIELD_LEN] = {0};
+static char prod_ver[FIELD_LEN] = {0};
+static char chassis_name[FIELD_LEN] = {0};
+static char ps_prod[FIELD_LEN] = {0};
+static int maxprod = 0;
+static int ctype;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = 0;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static uchar g_fruid = 0; /* default to fruid 0 */
+static uchar g_frutype = 0;
+static uchar lastfru[3] = {0,0,0};
+/* g_frutype values (detected), see also FruTypeString
+ * --TAG---- FRU IPMB
+ * Baseboard = 0x0c 0x07
+ * PowerSply = 0x0a
+ * PowerCage = 0x15
+ * DIMM = 0x20
+ * HotSwapCt = 0x0f
+ * ME = 0x2e
+ * SysInfo = 0x40
+ * Component = * * (all others)
+ */
+#ifdef METACOMMAND
+extern int verbose;
+extern int sdr_get_reservation(uchar *res_id, int fdev);
+#else
+static int verbose;
+static int sdr_get_reservation(uchar *res_id, int fdev) { return(-1); }
+#endif
+
+#define ERR_LENMAX -7 /*same as LAN_ERR_BADLENGTH */
+#define ERR_LENMIN -10 /*same as LAN_ERR_TOO_SHORT */
+#define ERR_OTHER -13 /*same as LAN_ERR_OTHER */
+
+#define STRING_DATA_TYPE_BINARY 0x00
+#define STRING_DATA_TYPE_BCD_PLUS 0x01
+#define STRING_DATA_TYPE_SIX_BIT_ASCII 0x02
+#define STRING_DATA_TYPE_LANG_DEPENDENT 0x03
+
+#define FRUCHUNK_SZ 16
+#define FRU_END 0xC1
+#define FRU_EMPTY_FIELD 0xC0
+#define FRU_TYPE_MASK 0xC0
+#define FRU_LEN_MASK 0x3F
+
+#define NUM_BOARD_FIELDS 6
+#define NUM_PRODUCT_FIELDS 8
+#define NUM_CHASSIS_FIELDS 3
+#define MAX_CTYPE 26
+char *ctypes[MAX_CTYPE] = { "", "Other", "Unknown", "Desktop",
+ "Low Profile Desktop", "Pizza Box", "Mini-Tower", "Tower",
+ "Portable", "Laptop", "Notebook", "Handheld", "Docking Station",
+ "All-in-One", "Sub-Notebook", "Space-saving", "Lunch Box",
+ "Main Server Chassis", "Expansion Chassis", "SubChassis",
+ "Bus Expansion Chassis", "Peripheral Chassis",
+ "RAID Chassis", /*0x17=23.*/ "Rack-Mount Chassis",
+ "New24" , "New25"};
+ /* what about bladed chassies? */
+char *ctype_hdr =
+"Chassis Type ";
+char *chassis[NUM_CHASSIS_FIELDS] = {
+"Chassis Part Number ",
+"Chassis Serial Num ",
+"Chassis OEM Field " };
+char *board[NUM_BOARD_FIELDS] = {
+"Board Manufacturer ",
+"Board Product Name ",
+"Board Serial Number ",
+"Board Part Number ",
+"Board FRU File ID ",
+"Board OEM Field " };
+char *product[NUM_PRODUCT_FIELDS] = {
+"Product Manufacturer",
+"Product Name ",
+"Product Part Number ",
+"Product Version ",
+"Product Serial Num ",
+"Product Asset Tag ",
+"Product FRU File ID ",
+"Product OEM Field " };
+char *asset_hdr =
+" Asset Tag Length ";
+
+#if 0
+typedef struct {
+ uchar len :6;
+ uchar type:2;
+ } TYPE_LEN; /*old, assumes lo-hi byte order*/
+#else
+typedef struct {
+ uchar len;
+ uchar type;
+ } TYPE_LEN;
+#endif
+
+void
+free_fru(uchar *pfrubuf)
+{
+ if (pfrubuf != NULL) {
+ if (frubuf != NULL) free(frubuf);
+ frubuf = NULL;
+ }
+ return;
+}
+
+int
+load_fru(uchar sa, uchar frudev, uchar frutype, uchar **pfrubuf)
+{
+ int ret = 0;
+ uchar indata[16];
+ uchar resp[18];
+ int sresp;
+ uchar cc;
+ int sz;
+ char fwords;
+ ushort fruoff = 0;
+ int i, rv;
+ int chunk;
+
+ if (pfrubuf == NULL) return(ERR_BAD_PARAM);
+ *pfrubuf = NULL;
+ indata[0] = frudev;
+ sresp = sizeof(resp);
+ if (fdebug) printf("load_fru: sa=%02x, frudev=%02x, addrtype=%d\n",
+ sa,frudev,g_addrtype);
+ ret = ipmi_cmd_mc(GET_FRU_INV_AREA,indata,1,resp,&sresp,&cc,fdebug);
+ if (fdebug) printf("load_fru: inv ret=%d, cc=%x, resp=%02x %02x %02x\n",
+ ret,cc, resp[0], resp[1], resp[2]);
+ if (ret != 0) return(ret);
+ if (cc != 0) { ret = (cc & 0x00ff); return(ret); }
+
+ sz = resp[0] + (resp[1] << 8);
+ if (resp[2] & 0x01) { fwords = 1; sz = sz * 2; }
+ else fwords = 0;
+
+ frubuf = malloc(sz);
+ if (frubuf == NULL) return(get_errno());
+ *pfrubuf = frubuf;
+ sfru = sz;
+
+ /* Loop on READ_FRU_DATA */
+ for (i = 0, chunk=FRUCHUNK_SZ; i < sz; i+=chunk)
+ {
+ if ((i+chunk) >= sz) chunk = sz - i;
+ indata[0] = frudev; /* FRU Device ID */
+ if (fwords) {
+ indata[3] = chunk / 2;
+ fruoff = (i/2);
+ } else {
+ indata[3] = (uchar)chunk;
+ fruoff = (ushort)i;
+ }
+ indata[1] = fruoff & 0x00FF;
+ indata[2] = (fruoff & 0xFF00) >> 8;
+ sresp = sizeof(resp);
+ ret = ipmi_cmd_mc(READ_FRU_DATA,indata,4,resp,&sresp,&cc,fdebug);
+ if (ret != 0) break;
+ else if (cc != 0) {
+ if (i == 0) ret = cc & 0x00ff;
+ if (fdebug) printf("read_fru[%d]: ret = %d cc = %x\n",i,ret,cc);
+ break;
+ }
+ memcpy(&frubuf[i],&resp[1],chunk);
+ }
+
+ if ((frudev == 0) && (sa == bmc_sa) && do_guid)
+ { /*main system fru, so get GUID*/
+ sresp = sizeof(resp);
+ rv = ipmi_cmd_mc(GET_SYSTEM_GUID,indata,0,resp,&sresp,&cc,fdebug);
+ if (fdebug) printf("system_guid: ret = %d, cc = %x\n",rv,cc);
+ if (rv == 0) rv = cc;
+ if ((rv != 0) && !is_remote()) { /* get UUID from SMBIOS */
+ cc = 0; sresp = 16;
+ rv = get_SystemGuid(resp);
+ if (fdebug) printf("get_SystemGuid: ret = %d\n",rv);
+ }
+ if (rv == 0 && cc == 0) {
+ if (fdebug) {
+ printf("system guid (%d): ",sresp);
+ for (i=0; i<16; i++) printf("%02x ",resp[i]);
+ printf("\n");
+ }
+ memcpy(&guid,&resp,16);
+ guid[16] = 0;
+ } else {
+ printf("WARNING: GetSystemGuid error %d, %s\n",rv,decode_rv(rv));
+ /*do not pass this error upstream*/
+ }
+ } /*endif*/
+ return(ret);
+}
+
+static void decode_string(unsigned char type,
+ unsigned char language_code,
+ unsigned char *source,
+ int slen,
+ char *target,
+ int tsize)
+{
+ static const char bcd_plus[] = "0123456789 -.:,_";
+ unsigned char *s = &source[0];
+ int len, i, j, k;
+ union { uint32_t bits; char chars[4]; } u;
+
+ if (slen == 0 || slen == 1) return;
+ switch(type) {
+ case STRING_DATA_TYPE_BINARY: /* 00: binary/unspecified */
+ len = (slen*2); break; /* hex dump -> 2x length */
+ case STRING_DATA_TYPE_SIX_BIT_ASCII: /*type 2 6-bit ASCII*/
+ /* 4 chars per group of 1-3 bytes */
+ len = ((((slen+2)*4)/3) & ~3); break;
+ case STRING_DATA_TYPE_LANG_DEPENDENT: /* 03 language dependent */
+ case STRING_DATA_TYPE_BCD_PLUS: /* 01b: BCD plus */
+ default:
+ len = slen; break;
+ }
+ if (len >= tsize) len = tsize - 1;
+ memset(target, 0, len);
+ if (type == STRING_DATA_TYPE_BCD_PLUS) { /*type 1: BCD plus*/
+ for (k=0; k<len; k++)
+ target[k] = bcd_plus[(s[k] & 0x0f)];
+ target[k] = '\0';
+ } else if (type == STRING_DATA_TYPE_SIX_BIT_ASCII) { /*type 2: 6-bit ASCII*/
+ for (i=j=0; i<slen; i+=3) {
+ u.bits = 0;
+ k = ((slen-i) < 3 ? (slen-i) : 3);
+#if WORDS_BIGENDIAN
+ u.chars[3] = s[i];
+ u.chars[2] = (k > 1 ? s[i+1] : 0);
+ u.chars[1] = (k > 2 ? s[i+2] : 0);
+#define CHAR_IDX 3
+#else
+ memcpy((void *)&u.bits, &s[i], k);
+#define CHAR_IDX 0
+#endif
+ for (k=0; k<4; k++) {
+ target[j++] = ((u.chars[CHAR_IDX] & 0x3f) + 0x20);
+ u.bits >>= 6;
+ }
+ }
+ target[j] = '\0';
+ } else if (type == STRING_DATA_TYPE_LANG_DEPENDENT) { /*type 3*/
+ if ((language_code == 0x00) || (language_code == 0x25) ||
+ (language_code == 0x19)) {
+ memcpy(target, source, len);
+ target[len] = 0;
+ } else {
+ printf("Language 0x%x dependent decode not supported\n",language_code);
+ }
+ } else if (type == STRING_DATA_TYPE_BINARY) { /* 00: binary/unspecified */
+ strncpy(target, buf2str(s, slen), len);
+ target[len] = '\0'; /* add end-of-string char */
+ } else { /* other */
+ printf("Unable to decode type 0x%.2x\n",type);
+ }
+ return;
+}
+
+uchar calc_cksum(uchar *pbuf,int len)
+{
+ int i;
+ uchar cksum;
+ uchar sum = 0;
+
+ for (i = 0; i < len; i++) sum += pbuf[i];
+ cksum = 0 - sum;
+ return(cksum);
+}
+
+static void dumpbuf(uchar *pbuf,int sz)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) { j = 0; printf("%s\n %04d: ",line,i); }
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ printf("%02x ",pbuf[i]);
+ }
+ line[j] = 0;
+ printf("%s\n",line);
+ return;
+}
+
+#define NSPDMFG 10
+static struct {
+ uchar id; char *str;
+} spd_mfg[NSPDMFG] = { /* see JEDEC JEP106 doc */
+{ 0x02, "AMI" },
+{ 0x04, "Fujitsu" },
+{ 0x15, "Philips Semi" },
+{ 0x1c, "Mitsubishi" },
+{ 0x2c, "Micron" },
+{ 0x89, "Intel" },
+{ 0x98, "Kingston" },
+{ 0xA8, "US Modular" },
+{ 0xc1, "Infineon" },
+{ 0xce, "Samsung" }
+};
+
+int ValidTL(uchar typelen)
+{
+ if (vend_id != VENDOR_INTEL) return 1;
+ if ((typelen & 0xC0) == 0xC0) return 1; /* validate C type */
+ if ((typelen & 0x00) == 0x00) return 1; /* validate 0 type too */
+ else return 0;
+}
+
+#define SYS_FRUTYPE 0x40
+char * FruTypeString(uchar frutype, uchar dev)
+{
+ char *pstr;
+ switch (frutype) {
+ case 0x07: /*IPMB*/
+ case 0x0c: /*FRU*/
+ if (dev == 0) pstr = "Baseboard";
+ else pstr = "Board ";
+ break;
+ case 0x0a: pstr = "PowerSply"; break; /*FRU*/
+ case 0x15: pstr = "PowerCage"; break; /*FRU*/
+ case 0x20: pstr = "DIMM "; break; /*FRU*/
+ case 0x0f: pstr = "HotSwapCt"; break; /*IPMB*/
+ case 0x2e: pstr = "ME "; break; /*IPMB*/
+ case SYS_FRUTYPE: pstr = "SysInfo "; break; /*SysInfo*/
+ default: pstr = "Component"; break;
+ }
+ return(pstr);
+}
+
+static int ChkOverflow(int idx, int sz, uchar len)
+{
+ if (idx >= sz) {
+ printf(" ERROR - FRU Buffer Overflow (%d >= %d), last len=%d\n",
+ idx,sz,len);
+ return 1; /*overflow error*/
+ }
+ return 0;
+}
+
+static void
+show_spd(uchar *spd, int lenspd, uchar frudev, uchar frutype)
+{
+ int sz;
+ char *pstr;
+ int sdcap, ranks, busw, sdw, totcap;
+ uchar srev, mfgid, mrev1, mrev2, yr, wk;
+ uchar isdcap, iranks, ibusw, isdw;
+ uchar iparity, iser, ipart, irev;
+ int i;
+ char devstr[24];
+
+ /* Sample SPD Headers:
+ 80 08 07 0c 0a 01 48 00 (DDR SDRAM DIMM)
+ 92 10 0b 01 03 1a 02 00 (DDR3 SDRAM DIMMs) */
+ sz = spd[0]; /* sz should == lenspd */
+ srev = spd[1]; /* SPD Rev: 8 for DDR, 10 for DDR3 SPD spec */
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s, %02x] ",FruTypeString(frutype,frudev),frudev);
+ printf("%sMemory SPD Size %c %d\n",
+ devstr,bdelim,lenspd);
+ switch (spd[2]) {
+ case 0x02: pstr = "EDO"; break;
+ case 0x04: pstr = "SDRAM"; break;
+ case 0x05: pstr = "ROM"; break;
+ case 0x06: pstr = "DDR SGRAM"; break;
+ case 0x07: pstr = "DDR SDRAM"; break;
+ case 0x08: pstr = "DDR2 SDRAM"; break;
+ case 0x09: pstr = "DDR2 SDRAM FB"; break;
+ case 0x0A: pstr = "DDR2 SDRAM FB PROBE"; break;
+ case 0x0B: pstr = "DDR3 SDRAM"; break;
+ default: pstr = "DRAM"; break; /*FPM DRAM or other*/
+ }
+ printf("%sMemory Type %c %s\n", devstr,bdelim,pstr);
+ if (srev < 0x10) { /*used rev 0.8 of SPD spec*/
+ printf("%sModule Density %c %d MB per bank\n",
+ devstr,bdelim, (spd[31] * 4));
+ printf("%sModule Banks %c %d banks\n",
+ devstr,bdelim,spd[5]);
+ printf("%sModule Rows, Cols %c %d rows, %d cols\n",
+ devstr,bdelim, spd[3], spd[4]);
+ iparity = spd[11];
+ mfgid = spd[64];
+ } else { /* use 1.0 SPD spec with DDR3 */
+ /* SDRAM CAPACITY = SPD byte 4 bits 3~0 */
+ /* PRIMARY BUS WIDTH = SPD byte 8 bits 2~0 */
+ /* SDRAM WIDTH = SPD byte 7 bits 2~0 */
+ /* RANKS = SPD byte 7 bits 5~3 */
+ isdcap = (spd[4] & 0x0f);
+ iranks = (spd[7] & 0x38) >> 3;
+ isdw = (spd[7] & 0x07);
+ ibusw = (spd[8] & 0x07);
+ iparity = (spd[8] & 0x38) >> 3;
+ mfgid = spd[118];
+ switch(isdcap) {
+ case 0: sdcap = 256; /*MB*/ break;
+ case 1: sdcap = 512; /*MB*/ break;
+ case 2: sdcap = 1024; /*MB*/ break;
+ case 3: sdcap = 2048; /*MB*/ break;
+ case 4: sdcap = 4096; /*MB*/ break;
+ case 5: sdcap = 8192; /*MB*/ break;
+ case 6: sdcap = 16384; /*MB*/ break;
+ default: sdcap = 32768; /*MB*/ break;
+ }
+ switch(iranks) {
+ case 0: ranks = 1; break;
+ case 1: ranks = 2; break;
+ case 2: ranks = 3; break;
+ case 3:
+ default: ranks = 4; break;
+ }
+ switch(isdw) {
+ case 0: sdw = 4; break;
+ case 1: sdw = 8; break;
+ case 2: sdw = 16; break;
+ case 3:
+ default: sdw = 32; break;
+ }
+ switch(ibusw) {
+ case 0: busw = 8; break;
+ case 1: busw = 16; break;
+ case 2: busw = 32; break;
+ case 3:
+ default: busw = 64; break;
+ }
+ totcap = sdcap / 8 * busw / sdw * ranks;
+ printf("%sModule Density %c %d Mbits\n",devstr,bdelim,sdcap);
+ printf("%sModule Ranks %c %d ranks\n",devstr,bdelim,ranks);
+ printf("%sModule Capacity %c %d MB\n",devstr,bdelim,totcap);
+ }
+ if (iparity == 0x00) pstr = "Non-parity";
+ else /* usu 0x02 */ pstr = "ECC";
+ printf("%sDIMM Config Type %c %s\n", devstr,bdelim,pstr);
+ for (i = 0; i < NSPDMFG; i++)
+ if (spd_mfg[i].id == mfgid) break;
+ if (i == NSPDMFG) pstr = ""; /* not found, use null string */
+ else pstr = spd_mfg[i].str;
+ printf("%sManufacturer ID %c %s (0x%02x)\n", devstr,bdelim,pstr,mfgid);
+ if (srev < 0x10) {
+ yr = spd[93];
+ wk = spd[94];
+ iser = 95;
+ ipart = 73;
+ irev = 91;
+ } else { /* 1.0 SPD spec with DDR3 */
+ yr = spd[120];
+ wk = spd[121];
+ iser = 122;
+ ipart = 128;
+ irev = 146;
+ }
+ mrev1 = spd[irev]; /* save this byte for later */
+ mrev2 = spd[irev+1];
+ spd[irev] = 0; /*stringify part number */
+ printf("%sManufacturer Part# %c %s\n",
+ devstr,bdelim,&spd[ipart]);
+ printf("%sManufacturer Rev %c %02x %02x\n",
+ devstr,bdelim,mrev1,mrev2);
+ printf("%sManufacturer Date %c year=%02x week=%02x\n",
+ devstr,bdelim, yr,wk);
+ printf("%sAssembly Serial Num %c %02x%02x%02x%02x\n",
+ devstr,bdelim,spd[iser],spd[iser+1],spd[iser+2],spd[iser+3]);
+ spd[irev] = mrev1; /* restore byte, so ok to repeat later */
+ return;
+}
+
+void show_guid(uchar *pguid)
+{
+ char *s;
+ int i;
+ for (i=0; i<16; i++) {
+ if ((i == 4) || (i == 6) || (i == 8) || (i == 10)) s = "-";
+ else s = "";
+ printf("%s%02x",s,pguid[i]);
+ }
+}
+
+static char *volt_desc(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x03: s = "5V"; break;
+ case 0x02: s = "3.3V"; break;
+ case 0x01: s = "-12V"; break;
+ case 0x00:
+ default: s = "12V"; break;
+ }
+ return(s);
+}
+
+static char *mgt_type(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x01: s = "SysMgt_URL"; break;
+ case 0x02: s = "SystemName"; break;
+ case 0x03: s = "SysPingAddr"; break;
+ case 0x04: s = "Compon_URL"; break;
+ case 0x05: s = "ComponName"; break;
+ case 0x06: s = "ComponPing"; break;
+ case 0x07:
+ default: s = "SysGUID"; break;
+ }
+ return(s);
+}
+
+
+static
+void show_fru_multi(char *tag, int midx, uchar mtype, uchar *pdata, int dlen)
+{
+ int vend;
+ char mystr[256];
+ char *s1;
+ int v1, v2, v3, v4, v5, v6, v7;
+ uchar b1, b2;
+
+ if (fdebug) dumpbuf(pdata,dlen); /*multi-record area dump*/
+ sprintf(mystr,"%sMulti[%d] ",tag,midx);
+ switch(mtype) {
+ case 0x00: /*Power Supply*/
+ printf("%sPower Supply Record %c \n",mystr,bdelim);
+ v1 = pdata[0] + ((pdata[1] & 0x0f) << 8);
+ printf("\t Capacity \t%c %d W\n",bdelim, v1);
+ v2 = pdata[2] + (pdata[3] << 8);
+ printf("\t Peak VA \t%c %d VA\n",bdelim, v2);
+ printf("\t Inrush Current\t%c %d A\n",bdelim, pdata[4]);
+ printf("\t Inrush Interval\t%c %d ms\n",bdelim, pdata[5]);
+ v3 = pdata[6] + (pdata[7] << 8);
+ v4 = pdata[8] + (pdata[9] << 8);
+ printf("\t Input Voltage Range1\t%c %d-%d V\n",
+ bdelim,v3/100,v4/100);
+ v3 = pdata[10] + (pdata[11] << 8);
+ v4 = pdata[12] + (pdata[13] << 8);
+ printf("\t Input Voltage Range2\t%c %d-%d V\n",
+ bdelim,v3/100,v4/100);
+ printf("\t Input Frequency Range\t%c %d-%d Hz\n",
+ bdelim,pdata[14],pdata[15]);
+ printf("\t AC Dropout Tolerance\t%c %d ms\n",bdelim, pdata[16]);
+ b1 = pdata[17];
+ b2 = (b1 & 0x01);
+ if (b2) { /*predictive fail*/
+ if ((b1 & 0x10) != 0) s1 = "DeassertFail ";
+ else s1 = "AssertFail ";
+ } else {
+ if ((b1 & 0x10) != 0) s1 = "2pulses/rot ";
+ else s1 = "1pulse/rot ";
+ }
+ printf("\t Flags \t%c %s%s%s%s%s\n",bdelim,
+ b2 ? "PredictFail " : "",
+ ((b1 & 0x02) == 0) ? "" : "PowerFactorCorrect ",
+ ((b1 & 0x04) == 0) ? "" : "AutoswitchVolt ",
+ ((b1 & 0x08) == 0) ? "" : "Hotswap ", s1);
+ v5 = pdata[18] + ((pdata[19] & 0x0f) << 8);
+ v6 = (pdata[19] & 0xf0) >> 4;
+ printf("\t Peak Capacity \t%c %d W for %d s\n",bdelim, v5,v6);
+ if (pdata[20] == 0) {
+ printf("\t Combined Capacity\t%c not specified\n",bdelim);
+ } else {
+ b1 = pdata[20] & 0x0f;
+ b2 = (pdata[20] & 0xf0) >> 4;
+ v7 = pdata[21] + (pdata[22] << 8);
+ printf("\t Combined Capacity\t%c %d W (%s and %s)\n",
+ bdelim, v7,volt_desc(b1),volt_desc(b2));
+ }
+ if (b2) /*predictive fail*/
+ printf("\t Fan low threshold\t%c %d RPS\n",bdelim,pdata[23]);
+ break;
+ case 0x01: /*DC Output*/
+ b1 = pdata[0] & 0x0f;
+ b2 = ((pdata[0] & 0x80) != 0);
+ printf("%sDC Output %c number %d\n",mystr,bdelim,b1);
+ printf("\t Standby power \t%c %s\n", bdelim,
+ (b2 ? "Yes" : "No"));
+ v1 = pdata[1] + (pdata[2] << 8);
+ printf("\t Nominal voltage \t%c %.2f V\n", bdelim, v1 / 100);
+ v2 = pdata[3] + (pdata[4] << 8);
+ v3 = pdata[5] + (pdata[6] << 8);
+ printf("\t Voltage deviation \t%c + %.2f V / - %.2f V\n",
+ bdelim, v3/100, v2/100);
+ v4 = pdata[7] + (pdata[8] << 8);
+ printf("\t Ripple and noise pk-pk \t%c %d mV\n", bdelim, v4);
+ v5 = pdata[9] + (pdata[10] << 8);
+ printf("\t Min current draw \t%c %.3f A\n", bdelim, v5/1000);
+ v6 = pdata[11] + (pdata[12] << 8);
+ printf("\t Max current draw \t%c %.3f A\n", bdelim, v6/1000);
+ break;
+ case 0x02: /*DC Load*/
+ b1 = pdata[0] & 0x0f;
+ printf("%sDC Load %c number %d\n",mystr,bdelim,b1);
+ v1 = pdata[1] + (pdata[2] << 8);
+ printf("\t Nominal voltage \t%c %.2f V\n", bdelim, v1 / 100);
+ v2 = pdata[3] + (pdata[4] << 8);
+ v3 = pdata[5] + (pdata[6] << 8);
+ printf("\t Min voltage allowed \t%c %.2f A\n", bdelim, v2);
+ printf("\t Max voltage allowed \t%c %.2f A\n", bdelim, v3);
+ v4 = pdata[7] + (pdata[8] << 8);
+ printf("\t Ripple and noise pk-pk \t%c %d mV\n", bdelim, v4);
+ v5 = pdata[9] + (pdata[10] << 8);
+ printf("\t Min current load \t%c %.3f A\n", bdelim, v5/1000);
+ v6 = pdata[11] + (pdata[12] << 8);
+ printf("\t Max current load \t%c %.3f A\n", bdelim, v6/1000);
+ break;
+ case 0x03: /*Management Access*/
+ b1 = pdata[0];
+ printf("%sManagemt Access %c %s ",mystr,bdelim,mgt_type(b1));
+ memcpy(mystr,&pdata[1],dlen-1);
+ mystr[dlen-1] = 0;
+ printf("%s\n",mystr);
+ break;
+ case 0x04: /*Base Compatibility*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ printf("%sBasic Compat %c %06x\n",mystr,bdelim,vend);
+ break;
+ case 0x05: /*Extended Compatibility*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ printf("%sExtended Compat %c %06x\n",mystr,bdelim,vend);
+ break;
+ case 0xC0: /*OEM Extension*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ if (vend == OEM_PICMG) {
+ printf("%sOEM PICMG %c \n", mystr,bdelim);
+ show_fru_picmg(pdata,dlen);
+ } else
+ printf("%sOEM Ext %c %06x %02x\n",
+ mystr,bdelim, vend, pdata[3]);
+ break;
+ default:
+ printf("%s %02x %c %02x\n", mystr,mtype,bdelim, pdata[0]);
+ break;
+ }
+}
+
+int
+show_fru(uchar sa, uchar frudev, uchar frutype, uchar *pfrubuf)
+{
+ int ret = 0;
+ int i, j, n, sz;
+ uchar *pfru0;
+ uchar *pfru;
+ uchar lang;
+ TYPE_LEN tl;
+ char newstr[64];
+ int iaoff, ialen, bdoff, bdlen;
+ int proff, prlen, choff, chlen;
+ int moff, mlen;
+ char devstr[24];
+ char *pstr;
+
+ if ((pfrubuf[0] & 0x80) == 0x80) { /* 0x80 = type for DIMMs (SPD) */
+ /* FRU Header: 80 08 07 0c 0a 01 48 00 (DIMM) */
+ /* FRU Header: 92 10 0b 01 03 1a 02 00 (DDR3 DIMMs) */
+ sz = pfrubuf[0];
+ if (fdebug) {
+ printf("DIMM SPD Body (size=%d/%d): ",sz,sfru);
+ dumpbuf(pfrubuf,sfru);
+ }
+ show_spd(pfrubuf,sfru, frudev,frutype);
+ return(ret);
+ }
+
+ pstr = FruTypeString(frutype,frudev);
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s,%02x,%02x] ",pstr,sa,frudev);
+ printf("%s%s FRU Size %c %d\n",devstr,pstr,bdelim,sfru);
+
+ /*
+ * FRU header:
+ * 0 = format_ver (01 is std, usu 0x80 if DIMM)
+ * 1 = internal_use offset
+ * 2 = chassis_info offset
+ * 3 = board_info offset (usu 6 fields)
+ * 4 = product_info offset (usu 8 fields)
+ * 5 = multirecord offset
+ * 6 = pad (00)
+ * 7 = header checksum (zero checksum)
+ * FRU Header: 01 01 02 09 13 00 00 e0 (BMC)
+ * FRU Header: 01 00 00 00 01 07 00 f7 (Power Cage)
+ */
+ pfru0 = &pfrubuf[0]; /*pointer to fru start*/
+ pfru = &pfrubuf[0];
+ sz = 8; /*minimum for common header*/
+ for (i = 1; i < 6; i++) /* walk thru offsets */
+ if (pfrubuf[i] != 0) sz = pfrubuf[i] * 8;
+ if (sz > 8) { /* if have at least one section */
+ if (pfrubuf[5] != 0) j = 5 + pfrubuf[sz+2]; /*if multi-record area*/
+ else j = pfrubuf[sz+1] * 8; /* else add length of last section */
+ sz += j;
+ }
+
+ /* Now, sz = size used, sfru = total available size */
+ if (sz > sfru) {
+ if (fdebug) {
+ uchar hsum;
+ printf("FRU Header: ");
+ for (i = 0; i < 8; i++) printf("%02x ",pfrubuf[i]);
+ printf("\n");
+ hsum = calc_cksum(&pfrubuf[0],7);
+ if (pfrubuf[7] != hsum)
+ printf("FRU Header checksum mismatch (%x != %x)\n",pfrubuf[7],hsum);
+ }
+ printf("FRU size used=%d > available=%d\n",sz,sfru);
+ if (fpicmg || fdoanyway) sz = sfru; /*do it anyway*/
+ else {
+ printf("Please apply the correct FRU/SDR diskette\n");
+ return(ERR_OTHER);
+ }
+ }
+ /* internal area offset, length */
+ iaoff = pfrubuf[1] * 8;
+ ialen = pfrubuf[iaoff + 1] * 8;
+ /* chassis area offset, length */
+ choff = pfrubuf[2] * 8;
+ chlen = pfrubuf[choff + 1] * 8;
+ /* board area offset, length */
+ bdoff = pfrubuf[3] * 8;
+ bdlen = pfrubuf[bdoff + 1] * 8;
+ /* product area offset, length */
+ proff = pfrubuf[4] * 8;
+ prlen = pfrubuf[proff + 1] * 8;
+ /* multi-record area offset, length */
+ moff = pfrubuf[5] * 8;
+ mlen = 0;
+ if (moff > 0) {
+ for (i = moff; i < sfru; ) {
+ j = 5 + pfrubuf[i+2];
+ mlen += j;
+ if (pfrubuf[i+1] & 0x80) break;
+ i += j;
+ }
+ }
+
+ if (fdebug) {
+ printf("FRU Header: ");
+ for (i = 0; i < 8; i++) printf("%02x ",pfrubuf[i]);
+ printf("\n");
+ printf("FRU Body (size=%d/%d): ",sz,sfru);
+ dumpbuf(pfrubuf,sfru);
+ printf("header, len=%d, cksum0 = %02x, cksum1 = %02x\n",
+ 8,pfrubuf[7],calc_cksum(&pfrubuf[0],7));
+ printf("internal off=%d, len=%d, cksum = %02x\n",
+ iaoff,ialen,calc_cksum(&pfrubuf[iaoff],ialen-1));
+ printf("chassis off=%d, len=%d, cksum = %02x\n",
+ choff,chlen,calc_cksum(&pfrubuf[choff],chlen-1));
+ printf("board off=%d, len=%d, cksum = %02x\n",
+ bdoff,bdlen,calc_cksum(&pfrubuf[bdoff],bdlen-1));
+ printf("prod off=%d, len=%d, cksum = %02x\n",
+ proff,prlen,calc_cksum(&pfrubuf[proff],prlen-1));
+ /* Multi-record area */
+ printf("multi off=%d, len=%d, fru sz=%d\n", moff,mlen,sz);
+ } /*endif fdebug, show header*/
+
+ if (choff != 0) {
+ /* show Chassis area fields */
+ pfru = &pfrubuf[choff];
+ lang = 25; /* English */
+ ctype = pfru[2]; /*chassis type*/
+ if (fdebug) printf("ctype=%x\n",ctype);
+ if (ctype >= MAX_CTYPE) ctype = MAX_CTYPE - 1;
+ printf("%s%s%c %s\n",devstr, ctype_hdr,bdelim,ctypes[ctype]);
+ pfru += 3; /* skip chassis header */
+ tl.len = 0;
+ for (i = 0; i < NUM_CHASSIS_FIELDS; i++)
+ {
+ if (ChkOverflow((int)(pfru - pfru0),sfru,tl.len)) break;
+ if (pfru[0] == FRU_END) break; /*0xC1 = end of FRU area*/
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],chassis[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ if (i == 2) { /* OEM field for chassis_name */
+ chassis_offset = (int)(pfru - pfrubuf);
+ chassis_len = tl.len;
+ if (fdebug) printf("chassis oem dtype=%d lang=%d len=%d\n",
+ tl.type,lang,tl.len);
+ }
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, chassis[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug) printf("num Chassis fields = %d\n",i);
+ }
+
+ if (bdoff != 0) {
+ long nMin, nSec;
+ time_t tsec;
+ /* show Board area fields */
+ pfru = &pfrubuf[bdoff];
+ lang = pfru[2];
+ /* Decode board mfg date-time (num minutes since 1/1/96) */
+ nMin = pfru[3] + (pfru[4] << 8) + (pfru[5] << 16);
+ /* 820,454,400 sec from 1/1/70 to 1/1/96 */
+ nSec = (nMin * 60) + 820454400;
+ tsec = (time_t)(nSec & 0x0ffffffff);
+ // fmt_time(tsec,newstr,sizeof(newstr));
+ printf("%sBoard Mfg DateTime %c %s",devstr,bdelim,ctime(&tsec));
+ pfru += 6; /* skip board header */
+ tl.len = 0;
+ for (i = 0; i < NUM_BOARD_FIELDS; i++)
+ {
+ if (ChkOverflow((int)(pfru - pfru0),sfru,tl.len)) break;
+ if (pfru[0] == FRU_END) break; /*0xC1 = end*/
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],board[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, board[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug) printf("num Board fields = %d\n",i);
+ }
+
+ if (proff != 0)
+ {
+ /* show Product area fields */
+ pfru = &pfrubuf[proff];
+ maxprod = pfru[1] * 8;
+ lang = pfru[2];
+ pfru += 3; /* skip product header */
+ tl.len = 0;
+ for (i = 0; i < NUM_PRODUCT_FIELDS; i++)
+ {
+ if (ChkOverflow((int)(pfru - pfru0),sfru,tl.len)) break;
+ if (*pfru == FRU_END) { /*0xC1 = end*/
+ /* Wart for known Kontron 1-byte Product Version anomaly. */
+ if (vend_id == VENDOR_KONTRON && i == 3) ;
+ else break;
+ }
+ if (*pfru == 0) *pfru = FRU_EMPTY_FIELD; /* fix a broken table */
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],product[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ if ((frudev == 0) && (sa == bmc_sa)) { /*baseboard FRU*/
+ if (i == 5) { /* asset tag */
+ asset_offset = (int)(pfru - pfrubuf);
+ asset_len = tl.len;
+ if (fdebug) printf("asset off=%d dtype=%d lang=%d len=%d\n",
+ asset_offset,tl.type,lang,tl.len);
+ if (fshowlen) /* show asset tag length for main board */
+ printf("%s%c %d\n",asset_hdr,bdelim,asset_len);
+ } else if (i == 4) { /* serial number */
+ sernum_offset = (int)(pfru - pfrubuf);
+ sernum_len = tl.len;
+ if (fdebug) printf("sernum dtype=%d lang=%d len=%d\n",
+ tl.type, lang, tl.len);
+ } else if (i == 3) { /* product version number */
+ prodver_offset = (int)(pfru - pfrubuf);
+ prodver_len = tl.len;
+ if (fdebug) printf("prodver dtype=%d lang=%d len=%d\n",
+ tl.type, lang, tl.len);
+ }
+ } /*if baseboard sa*/
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, product[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug)
+ printf("num Product fields = %d, last=%x, max = %d\n",
+ i,*pfru,maxprod );
+ if (*pfru == 0x00) *pfru = FRU_END; /* insert end char if broken */
+ }
+
+ if (moff != 0)
+ {
+ /* multi-record area may contain several record headers
+ * 0 = record type id
+ * 1 = 0x02 or 0x82 if End-of-List
+ * 2 = record len
+ * 3 = record chksum
+ * 4 = header chksum
+ */
+ pfru = &pfrubuf[moff];
+ j = moff;
+ for (i = 0; j < sz ; i++)
+ {
+ n = pfru[2]; /* len of this record */
+ show_fru_multi(devstr,i,pfru[0],&pfru[5],n);
+ j += (5 + n);
+ if (pfru[1] & 0x80) j = sz; /*0x80 = last in list, break*/
+ pfru += (5 + n);
+ }
+ }
+
+ if ((frudev == 0) && (sa == bmc_sa) && do_guid) {
+ printf("%sSystem GUID %c ",devstr,bdelim);
+ show_guid(guid);
+ printf("\n");
+ }
+ return(ret);
+}
+
+int write_fru_data(uchar id, ushort offset, uchar *data, int dlen, char fdebug)
+{
+ int ret = -1;
+ int chunk;
+ ushort fruoff;
+ uchar req[25];
+ uchar resp[16];
+ int sresp;
+ uchar cc;
+ int i, j;
+
+ /* Write the buffer in small 16-byte (FRUCHUNK_SZ) chunks */
+ req[0] = 0x00; /* override FRU Device ID (fruid) */
+ fruoff = offset;
+ chunk = FRUCHUNK_SZ;
+ for (i = 0; i < dlen; i += chunk) {
+ req[1] = fruoff & 0x00ff;
+ req[2] = (fruoff & 0xff00) >> 8;
+ if ((i + chunk) > dlen) chunk = dlen - i;
+ memcpy(&req[3],&data[i],chunk);
+ if (fdebug) {
+ printf("write_fru_data[%d] (len=%d): ",i,chunk+3);
+ for (j = 0; j < chunk+3; j++) printf("%02x ",req[j]);
+ printf("\n");
+ }
+ sresp = sizeof(resp);
+ ret = ipmi_cmd_mc(WRITE_FRU_DATA,req,(uchar)(chunk+3),resp,&sresp,
+ &cc,fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc & 0x00ff;
+ if (fdebug && ret == 0)
+ printf("write_fru_data[%d]: %d bytes written\n",i,resp[0]);
+ if (ret != 0) break;
+ fruoff += (ushort)chunk;
+ }
+ return(ret);
+}
+
+/* write_asset updates the FRU Product area only. */
+int
+write_asset(char *tag, char *sernum, char *prodver, int flag, uchar *pfrubuf)
+{
+ int ret = -1;
+ uchar newdata[SZ_PRODAREA];
+ int alen, clen;
+ int snlen, verlen;
+ uchar *pfru0;
+ uchar *pfru;
+ uchar *pnew;
+ int i, j, m, n, newlen, max;
+ int chas_offset;
+ int prod_offset, prod_len;
+ int mult_offset, mult_len;
+ uchar chksum;
+ char fdoasset = 0;
+ char fdosernum = 0;
+ char fdoprodver = 0;
+ char fdochassis = 0;
+
+ if (flag == 0) return ERR_OTHER;
+ if (pfrubuf == NULL) pfrubuf = frubuf;
+ if (pfrubuf == NULL) return ERR_OTHER;
+ if ((flag & 0x01) != 0) {
+ fdoasset = 1;
+ alen = strlen_(tag); /*new*/
+ } else {
+ alen = asset_len; /*old*/
+ }
+ if ((flag & 0x02) != 0) {
+ fdosernum = 1;
+ snlen = strlen_(sernum); /*new*/
+ } else {
+ snlen = sernum_len; /*old*/
+ }
+ if ((flag & 0x200) != 0) {
+ fdochassis = 1;
+ // clen = strlen(chassis_nm); /*new, ignore*/
+ // if (clen <= 1) return ERR_LENMIN;
+ clen = chassis_len;
+ } else {
+ clen = chassis_len; /*old*/
+ }
+ if ((flag & 0x08) != 0) {
+ fdoprodver = 1;
+ verlen = strlen_(prodver); /*new*/
+ } else verlen = prodver_len; /*old*/
+ /*
+ * Abort if offset is negative or if it would clobber
+ * fru header (8 bytes).
+ * Abort if asset tag is too big for fru buffer.
+ */
+ if (fdebug) {
+ printf("write_asset: asset_off=%d asset_len=%d alen=%d sFRU=%d\n",
+ asset_offset,asset_len,alen,sfru);
+ printf(" sernum_off=%d sernm_len=%d snlen=%d maxprod=%d\n",
+ sernum_offset,sernum_len,snlen,maxprod);
+ printf(" prodver=%d prodver_len=%d verlen=%d maxprod=%d\n",
+ prodver_offset,prodver_len,verlen,maxprod);
+ }
+ if (fdoasset && (alen <= 1)) return ERR_LENMIN;
+ if (fdosernum && (snlen <= 1)) return ERR_LENMIN;
+ if (asset_offset < 8) return ERR_LENMIN;
+ if (asset_offset + alen > sfru) return ERR_LENMAX;
+ if (sernum_offset < 8) return ERR_LENMIN;
+ if (sernum_offset + snlen > sfru) return ERR_LENMAX;
+ if (prodver_offset < 8) return ERR_LENMIN;
+ if (prodver_offset + verlen > sfru) return ERR_LENMAX;
+
+ pfru0 = &pfrubuf[0];
+ chas_offset = pfrubuf[2] * 8; // offset of chassis data
+ prod_offset = pfrubuf[4] * 8; // offset of product data
+ prod_len = pfrubuf[prod_offset+1] * 8; // length of product data
+ mult_offset = pfrubuf[5] * 8;
+ mult_len = 0;
+ if (mult_offset > 0) {
+ for (i = mult_offset; i < sfru; ) {
+ mult_len += (5 + pfrubuf[i+2]);
+ if (pfrubuf[i+1] & 0x80) break;
+ i = mult_len;
+ }
+ }
+ /* Check if asset tag will fit in product data area of FRU. */
+ if (fdebug)
+ printf("write_asset: fru[4,p]=[%02x,%02x] prod_off=%d plen=%d veroff=%d\n",
+ pfrubuf[4],pfrubuf[prod_offset+1],prod_offset,prod_len, prodver_offset);
+ /* asset comes after sernum, so this check works for both */
+ if (prod_offset > prodver_offset) return ERR_LENMAX; // offsets wrong
+ if (prod_len > sizeof(newdata)) return ERR_LENMAX; // product > buffer
+
+ memset(newdata,0,prod_len);
+ pnew = &newdata[0];
+ /* Copy fru data from start to chassis OEM */
+ pfru = &pfrubuf[chas_offset];
+
+ /* Copy fru data before serial number */
+ pfru = &pfrubuf[prod_offset];
+ j = prodver_offset - prod_offset;
+ memcpy(pnew,pfru,j);
+ pfru += j;
+ pnew += j;
+ if (fdebug) {
+ printf("write_asset: fru[4,p]=[%02x,%02x] sernum_off=%d snlen=%d plen=%d\n",
+ pfrubuf[4],pfrubuf[sernum_offset+1],sernum_offset,snlen,prod_len);
+ }
+ if (fdoprodver) {
+ pnew[0] = (verlen | FRU_TYPE_MASK); /*add type=3 to snlen*/
+ memcpy(++pnew,prodver,verlen);
+ } else {
+ pnew[0] = (verlen | FRU_TYPE_MASK); /*type/len byte*/
+ memcpy(++pnew,&pfrubuf[prodver_offset+1],verlen);
+ }
+ j += prodver_len + 1;
+ pfru += prodver_len + 1;
+ pnew += verlen; /*already ++pnew above*/
+
+ /* Copy new or old serial number */
+ if (fdebug) printf("pfrubuf[%ld]: %02x %02x %02x, j=%d, snlen=%d/%d\n",
+ (pfru-pfrubuf),pfru[0],pfru[1],pfru[2],j,snlen,sernum_len);
+ if (fdosernum) {
+ pnew[0] = (snlen | FRU_TYPE_MASK); /*add type=3 to snlen*/
+ memcpy(++pnew,sernum,snlen);
+ } else {
+ pnew[0] = (snlen | FRU_TYPE_MASK); /*type/len byte*/
+ memcpy(++pnew,&pfrubuf[sernum_offset+1],snlen);
+ }
+ /* increment past serial number, to asset tag */
+ j += sernum_len + 1;
+ pfru += sernum_len + 1;
+ pnew += snlen; /*already ++pnew above*/
+
+ /* Copy new or old asset tag */
+ if (fdebug) printf("pfrubuf[%ld]: %02x %02x %02x, j=%d, alen=%d/%d\n",
+ (pfru-pfrubuf),pfru[0],pfru[1],pfru[2],j,alen,asset_len);
+ if (fdoasset) {
+ pnew[0] = (alen | FRU_TYPE_MASK); /*add type=3 to len*/
+ memcpy(++pnew,tag,alen);
+ } else {
+ pnew[0] = (alen | FRU_TYPE_MASK); /*type/len byte*/
+ memcpy(++pnew,&pfrubuf[asset_offset+1],alen);
+ }
+ j += asset_len + 1;
+ pfru += asset_len + 1;
+ pnew += alen;
+
+ /* copy trailing fru data from saved copy */
+ n = (int)(pnew - newdata); /* new num bytes used */
+ m = (int)(pfru - pfru0); /* old num bytes used */
+ if (fdebug) printf("pfrubuf[%d]: %02x %02x %02x, j=%d, n=%d, plen=%d\n",
+ m,pfru[0],pfru[1],pfru[2],j,n,prod_len);
+ if (mult_offset > 0) { /* do not expand if multi-record area there */
+ max = prod_len - j;
+ } else /* nothing else, can expand product area, up to sfru */
+ max = sfru - (j + prod_offset);
+ if (fdebug) printf("pfrubuf[%ld]: %02x %02x %02x, j=%d n=%d remainder=%d\n",
+ (pfru-pfrubuf),pfru[0],pfru[1],pfru[2],j,n,max);
+ if (max < 0) max = 0;
+ for (i = 0; i < max; i++) {
+ pnew[i] = pfru[i];
+ if (pfru[i] == FRU_END) { i++; break; }
+ }
+ if (i == max) { /*never found 0xC1 FRU_END*/
+ pnew[0] = FRU_END;
+ i = 1;
+ }
+
+ newlen = n + i;
+ if (fdebug) printf("newbuf[%d]: %02x %02x %02x, j=%d, newlen=%d\n",
+ n,pnew[0],pnew[1],pnew[2],j,newlen);
+ /* round up to next 8-byte boundary */
+ /* need one more byte for checksum, so if mod=0, adds 8 anyway */
+ j = 8 - (newlen % 8);
+ for (i = 0; i < j; i++) newdata[newlen++] = 0;
+
+ if (newlen < prod_len) newlen = prod_len; /* don't shrink product area */
+ newdata[1] = newlen / 8; // set length of product data
+
+ /* include new checksum (calc over Product area) */
+ chksum = calc_cksum(&newdata[0],newlen-1);
+ newdata[newlen-1] = chksum;
+
+#ifdef NEEDED
+ /* This caused a problem on Radisys systems, and is not needed, so skip it.*/
+ if (mult_offset > 0) {
+ /* add on any more data from multi-record area */
+ pnew = &newdata[newlen];
+ pfru = &pfrubuf[mult_offset];
+ memcpy(pnew,pfru,mult_len);
+ newlen += mult_len;
+ }
+#endif
+
+ if (fdebug) {
+ printf("old buffer (%d):",prod_len);
+ dumpbuf(&pfrubuf[prod_offset],prod_len);
+ printf("new buffer (%d):",newlen);
+ dumpbuf(newdata,newlen);
+ }
+ if (prod_offset + newlen >= sfru) return ERR_LENMAX;
+ if ((mult_offset > 0) && (newlen > prod_len)) return ERR_LENMAX;
+#ifdef TEST
+ newlen = 0;
+#endif
+
+ ret = write_fru_data(0, (ushort)prod_offset, newdata, newlen, fdebug);
+ return(ret);
+}
+
+#define SDR_CHUNKSZ 16
+#define LAST_REC 0xffff
+#define SDR_STR_OFF 16
+
+int get_sdr(ushort recid, ushort resid, ushort *recnext,
+ uchar *sdr, int *slen, uchar *pcc)
+{
+ uchar idata[6];
+ uchar rdata[64];
+ int sresp;
+ ushort cmd;
+ uchar cc = 0;
+ int len = 0;
+ int szsdr, thislen;
+ int rc;
+
+ memset(sdr,0,*slen); /*clear sdr */
+ idata[0] = resid & 0x00ff;
+ idata[1] = (resid & 0xff00) >> 8;
+ idata[2] = recid & 0x00ff;
+ idata[3] = (recid & 0xff00) >> 8;
+ idata[4] = 0; /*offset*/
+ idata[5] = SDR_CHUNKSZ; /*bytes to read*/
+ if (fdevsdrs) cmd = GET_DEVICE_SDR;
+ else cmd = GET_SDR;
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] ret = %d cc = %x sresp = %d\n",
+ recid,rc,cc,sresp);
+ if (rc == 0 && cc == 0xCA) { /*cannot read SDR_CHUNKSZ bytes*/
+ idata[5] = 8; /*bytes to read*/
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] ret = %d cc = %x sresp = %d\n",
+ recid,rc,cc,sresp);
+ }
+ *pcc = cc;
+ if (rc == 0 && cc == 0) {
+ *recnext = rdata[0] + (rdata[1] << 8);
+ if (sresp < 2) len = 0;
+ else len = sresp-2;
+ if (len > *slen) len = *slen;
+ memcpy(sdr,&rdata[2],len);
+ szsdr = sdr[4] + 5; /*get actual SDR size*/
+ if (szsdr > *slen) szsdr = *slen;
+ /* if an SDR locator record, get the rest of it. */
+ if (sdr[3] == 0x11 || sdr[3] == 0x12)
+ if (szsdr > SDR_CHUNKSZ) {
+ ushort resid2;
+ rc = sdr_get_reservation((uchar *)&resid2,fdevsdrs);
+ if (fdebug) printf("2nd sdr_get_reservation ret=%d\n",rc);
+ thislen = szsdr - SDR_CHUNKSZ;
+ if (thislen > SDR_CHUNKSZ) thislen = SDR_CHUNKSZ;
+ idata[0] = resid2 & 0x00ff;
+ idata[1] = (resid2 & 0xff00) >> 8;
+ idata[2] = recid & 0x00ff;
+ idata[3] = (recid & 0xff00) >> 8;
+ idata[4] = SDR_CHUNKSZ; /*offset*/
+ idata[5] = (uchar)thislen; /*bytes to read*/
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] 2nd ret=%d cc=%x sresp=%d\n",
+ recid,rc,cc,sresp);
+ if (rc == 0 && cc == 0) {
+ if (sresp < 2) sresp = 0;
+ else sresp -= 2;
+ if (sresp > thislen) sresp = thislen;
+ memcpy(&sdr[len],&rdata[2],sresp);
+ len += sresp;
+ } else rc = 0; /*ok because got first part*/
+ } /*endif got first chunk, need more*/
+ *slen = len;
+ } else *slen = 0;
+ return(rc);
+}
+
+void show_loadfru_error(uchar sa, uchar fruid, int ret)
+{
+ if (ret == 0) return;
+ switch(ret) {
+ case 0x081: printf("\tFRU(%x,%x) device busy\n",sa,fruid); break;
+ case 0x0C3: printf("\tFRU(%x,%x) timeout, not found\n",sa,fruid); break;
+ case 0x0CB: printf("\tFRU(%x,%x) not present\n",sa,fruid); break;
+ default: printf("load_fru(%x,%x) error = %d (0x%x)\n",
+ sa,fruid,ret,ret);
+ break;
+ }
+ return;
+}
+
+int get_show_fru(ushort recid, uchar *sdr, int sdrlen)
+{
+ int ret = 0;
+ int ilen;
+ char idstr[32];
+ uchar sa, fruid =0;
+ uchar frutype = 0;
+ char fgetfru = 0;
+ char fisbase = 0;
+ uchar *pfru;
+
+ if (sdrlen > SDR_STR_OFF) {
+ ilen = sdrlen - SDR_STR_OFF;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[SDR_STR_OFF],ilen);
+ idstr[ilen] = 0;
+ } else idstr[0] = 0;
+ sa = sdr[5]; /* usu 0x20 for bmc_sa */
+ if (fbasefru) fisbase = 1;
+
+ /* Get its FRU data */
+ if ((sdr[3] == 0x11) && (sdr[7] & 0x80)) { /* FRU SDRs */
+ /* It is a logical FRU device */
+ if (fcanonical)
+ printf("SDR[%04x] FRU %c %s\n", recid, bdelim, idstr);
+ else
+ printf("SDR[%04x] FRU %02x %02x %02x %02x %s\n", recid,
+ sdr[5],sdr[6],sdr[12],sdr[13],idstr);
+ fruid = sdr[6];
+ if (sdrlen > 12) frutype = sdr[12];
+ if (sa == bmc_sa && fruid == 0) { /*dont repeat base fru */
+ frutype = 0x0c;
+ fisbase = 1;
+ if (fbasefru) fgetfru = 1;
+ } else
+ switch(frutype) /*FRU entity id*/
+ {
+ case 0x0a: /*Power Supply*/
+ case 0x20: /*DIMM*/
+ case 0x15: /*Power Cage*/
+ default:
+ fgetfru = 1;
+ break;
+ }
+ } else if (sdr[3] == 0x12) { /* IPMB SDRs (DLRs for MCs) */
+ if (fcanonical)
+ printf("SDR[%04x] IPMB %c %s\n", recid, bdelim, idstr);
+ else
+ printf("SDR[%04x] IPMB %02x %02x %02x %02x %s\n", recid,
+ sdr[5],sdr[6],sdr[12],sdr[13],idstr);
+ fruid = 0; /*every MC must have fruid 0*/
+ if (sdrlen > 12) frutype = sdr[12];
+ if (sa == bmc_sa && fruid == 0) { /*dont repeat base fru */
+ fisbase = 1;
+ frutype = 0x07;
+ if (fdebug) printf("do bmc_sa %02x once\n",sa);
+ g_frutype = frutype;
+ if (fbasefru) fgetfru = 1;
+ } else if (frutype == 0x2e) { /*skip ME*/
+ if (fdebug) printf("skipping ME sa %02x, %02x\n",sa,fruid);
+ } else if (sa == 0x28) { /*do nothing for Bridge Ctlr sa=0x28*/
+ if (fdebug) printf("skipping IPMB sa %02x, %02x\n",sa,fruid);
+ } else if (sa == 0xC0) { /* HotSwap Backplane (sa=0xC0) */
+ /* Note: Loading sa 0xC0 over ipmi lan gives a timeout
+ * error, but it works locally. */
+ fgetfru = 1;
+ } else { /* other misc sa,fruid */
+ fgetfru = 1;
+ }
+ }
+
+ /* Check if matches previous FRU, if so don't repeat */
+ if ((sa == lastfru[0]) && (fruid == lastfru[1]) )
+ fgetfru = 0;
+
+ if (fgetfru) {
+ uchar adrtype;
+ adrtype = g_addrtype;
+ if (fdebug) printf("set_mc %02x:%02x:%02x type=%d fruid=%02x\n",
+ g_bus,sa,g_lun,adrtype,fruid);
+ ipmi_set_mc(g_bus, sa, g_lun,adrtype);
+ ret = load_fru(sa,fruid,frutype,&pfru);
+ if (ret != 0) {
+ show_loadfru_error(sa,fruid,ret);
+ } else {
+ ret = show_fru(sa,fruid,frutype,pfru);
+ if (ret != 0) printf("show_fru error = %d\n",ret);
+ if (sa == bmc_sa && fruid == 0) fbasefru = 0;
+ }
+ free_fru(pfru);
+ pfru = NULL;
+ ipmi_restore_mc();
+ lastfru[0] = sa;
+ lastfru[1] = fruid;
+ lastfru[2] = frutype;
+ }
+ return(ret);
+}
+
+/*
+ * test_show_fru
+ *
+ * Reads the FRU buffer dump from a file to test decoding the FRU.
+ * This file uses the format output from 'ipmiutil fru -x'.
+ *
+[Component,20,00] Component FRU Size : 4096
+FRU Header: 01 0a 00 01 20 00 00 d4
+FRU Body (size=256/4096):
+ 0000: 01 0a 00 01 20 00 00 d4 01 09 00 c0 3b 7e 83 64 .... .......;~.d
+ *
+ */
+static int test_show_fru(char *infile)
+{
+ int rv = -1;
+ FILE *fp;
+ int len, i, idx, sz, off;
+ uchar buff[256];
+ uchar sa = 0x20;
+ uchar fruid =0;
+ uchar frutype = 0;
+ uchar *pfru = NULL;
+ char *p1;
+ char *p2;
+
+ fp = fopen(infile,"r");
+ if (fp == NULL) {
+ printf("Cannot open file %s\n",infile);
+ return(ERR_FILE_OPEN);
+ } else {
+ if (fdebug) printf("decoding text file with FRU buffer bytes\n");
+ idx = 0;
+ off = 0;
+ sz = sizeof(buff);
+ while (fgets(buff, 255, fp)) {
+ len = strlen_(buff);
+ if (fdebug) printf("fgets[%d]: %s",idx,buff); /*has '\n'*/
+ if (idx == 0) { /* the FRU Size line*/
+ p1 = strstr(buff,"FRU Size");
+ if (p1 == NULL) continue;
+ p1 = strchr(buff,',');
+ if (p1 == NULL) continue;
+ p1++;
+ p2 = strchr(p1,',');
+ if (p2 == NULL) p2 = &buff[len];
+ *p2 = 0; /*stringify*/
+ sa = htoi(p1);
+ p1 = p2 + 1;
+ p2 = strchr(p1,']');
+ if (p2 == NULL) p2 = &buff[len];
+ *p2 = 0; /*stringify*/
+ fruid = htoi(p1);
+ frutype = 0;
+ if (fdebug) printf("read[%d] sa=%x fruid=%x\n",idx,sa,fruid);
+ idx++;
+ } else if (idx == 1) { /* the FRU Header line*/
+ p1 = strstr(buff,"FRU Header");
+ // if (p1 == NULL) continue;
+ if (fdebug) printf("read[%d] p1=%p\n",idx,p1);
+ idx++;
+ } else if (idx == 2) { /* the FRU Bodu line*/
+ p1 = strstr(buff,"FRU Body");
+ if (p1 == NULL) continue;
+ p1 = strchr(buff,'=');
+ if (p1 == NULL) continue;
+ ++p1;
+ p2 = strchr(p1,'/');
+ if (p2 == NULL) p2 = &buff[len];
+ *p2 = 0; /*stringify*/
+ sz = atoi(p1);
+ p1 = p2 + 1;
+ p2 = strchr(p1,')');
+ if (p2 == NULL) p2 = &buff[len];
+ *p2 = 0; /*stringify*/
+ sfru = atoi(p1); /*global sfru*/
+ pfru = malloc(sfru);
+ if (fdebug)
+ printf("read[%d] sz=%d/%d pfru=%p\n",idx,sz,sfru,pfru);
+ idx++;
+ } else { /*idx==3, this has the FRU buffer data */
+ p1 = strchr(buff,':');
+ if (p1 == NULL) continue;
+ p1 += 2;
+ for (i = 0; i < 16; i++) {
+ pfru[off+i] = htoi(&p1[i*3]);
+ }
+ off += 16;
+ if (fdebug) printf("read[%d] offset=%d\n",idx,off);
+ } /*endif */
+ if (off >= sz) { rv = 0; break; }
+ } /*end while*/
+
+ fclose(fp);
+ if (rv == 0) {
+ if (pfru == NULL) {
+ printf("Invalid input file format (mode %d)\n",idx);
+ return(ERR_BAD_FORMAT);
+ }
+ rv = show_fru(sa,fruid,frutype,pfru);
+ if (rv != 0) printf("show_fru error = %d\n",rv);
+ }
+ free_fru(pfru);
+ }
+ return(rv);
+}
+
+#ifdef ALONE
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#else
+/* METACOMMAND */
+int i_fru(int argc, char **argv)
+#endif
+{
+ int ret, rv;
+ int c;
+ char DevRecord[16];
+ ushort recid;
+ ushort nextid;
+ ushort rsvid;
+ uchar sdr[48];
+ char biosver[80];
+ uchar cc;
+ uchar sa;
+ //uchar fruid = 0;
+ //uchar frutype = 0;
+ int len, i, j;
+ char *s1;
+ uchar *pfru = NULL;
+ FILE *fp;
+ int ipass, npass, nsdrs;
+ char *tag;
+ char do_reserve = 1;
+ char devstr[32];
+
+ printf("%s: version %s\n",progname,progver);
+
+ parse_lan_options('V',"4",0); /*default to admin privilege*/
+ while ( (c = getopt( argc, argv,"a:bcd:efhkl:m:n:i:p:r:s:t:v:xyzT:V:J:EYF:P:N:R:U:Z:?")) != EOF )
+ switch(c) {
+ case 'x': fdebug = 1; break;
+ case 'z': fdebug = 3; break; /*do more LAN debug detail*/
+ case 'b': fonlybase = 1;
+ g_frutype = 0x07; break;
+ case 'c': fcanonical = 1; bdelim = BDELIM; break;
+ case 'd': fdump = 1; /*dump fru to a file*/
+ binfile = optarg;
+ break;
+ case 'e': fchild = 1; break; /*extra child MCs if bladed*/
+ case 'f': fchild = 1; break; /*follow child MCs if bladed*/
+ case 'h': fonlyhsc = 1; /* show HSC FRU, same as -m00c000s */
+ g_frutype = 0x0f; break;
+ case 'k': foemkontron = 1; break;
+ case 'n':
+ fwritefru |= 0x200;
+ if (optarg) {
+ len = strlen_(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(chassis_name,optarg,len);
+ if (len == 1) { /* add a space */
+ chassis_name[1] = ' ';
+ chassis_name[2] = 0;
+ }
+ }
+ break;
+ case 'p': /*Power Supply Product */
+ // fwritefru |= 0x10;
+ if (optarg) {
+ len = strlen_(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(ps_prod,optarg,len);
+ if (len == 1) { /* add a space */
+ ps_prod[1] = ' ';
+ ps_prod[2] = 0;
+ }
+ }
+ break;
+ case 'r': frestore = 1; /*restore fru from a file*/
+ fwritefru = 0x100;
+ binfile = optarg;
+ break;
+ case 't': ftestshow = 1; /*test show_fru from a file*/
+ binfile = optarg;
+ break;
+ case 'a':
+ fwritefru |= 0x01;
+ if (optarg) {
+ len = strlen_(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(asset_tag,optarg,len);
+ if (len == 1) { /* add a space */
+ asset_tag[1] = ' ';
+ asset_tag[2] = 0;
+ }
+ }
+ break;
+ case 's':
+ fwritefru |= 0x02;
+ if (optarg) {
+ len = strlen_(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(serial_num,optarg,len);
+ if (len == 1) { /* add a space */
+ serial_num[1] = ' ';
+ serial_num[2] = 0;
+ }
+ }
+ break;
+ case 'v':
+ fwritefru |= 0x08;
+ if (optarg) {
+ len = strlen_(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(prod_ver,optarg,len);
+ if (len == 1) { /* add a space */
+ prod_ver[1] = ' ';
+ prod_ver[2] = 0;
+ }
+ }
+ break;
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'l': /* set local IPMB MC sa (same as -Z but sets bmc_sa) */
+ sa = htoi(&optarg[0]); /*device slave address*/
+ ipmi_set_mymc(g_bus, sa, g_lun,ADDR_IPMB);
+ bmc_sa = sa;
+ break;
+ case 'i': fonlybase = 1; /*specify a fru id*/
+ if (strncmp(optarg,"0x",2) == 0) g_fruid = htoi(&optarg[2]);
+ else g_fruid = htoi(optarg);
+ printf("Using FRU ID 0x%02x\n",g_fruid);
+ break;
+ case 'y': fdoanyway = 1; break;
+ case 'V': /* priv level */
+ fprivset = 1;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-bceikmtvx -a asset_tag -s ser_num -NUPREFTVY]\n",
+ progname);
+ printf(" -a tag Sets the Product Asset Tag\n");
+ printf(" -b Only show Baseboard FRU data\n");
+ printf(" -c show canonical, delimited output\n");
+ printf(" -d file Dump the binary FRU data to a file\n");
+ printf(" -e walk Every child FRU, for blade MCs\n");
+ printf(" -i 00 Get a specific FRU ID\n");
+ printf(" -k Kontron setsn, setmfgdate\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -s snum Sets the Product Serial Number\n");
+ printf(" -v pver Sets the Product Version Number\n");
+ printf(" -x Display extra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ if (ftestshow) {
+ ret = test_show_fru(binfile);
+ goto do_exit;
+ }
+
+ if (is_remote() && (!fprivset)) {
+ /* If priv not specified, not writing, and only targetted FRU,
+ can default to request user privilege. */
+ if (!fwritefru && fonlybase) parse_lan_options('V',"2",0);
+ }
+
+ ret = ipmi_getdeviceid( DevRecord, sizeof(DevRecord),fdebug);
+ if (ret == 0) {
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = DevRecord[4] & 0x0f;
+ ipmi_min = DevRecord[4] >> 4;
+ vend_id = DevRecord[6] + (DevRecord[7] << 8) + (DevRecord[8] << 16);
+ prod_id = DevRecord[9] + (DevRecord[10] << 8);
+ show_devid( DevRecord[2], DevRecord[3], ipmi_maj, ipmi_min);
+ if (ipmi_maj < 2) do_systeminfo = 0;
+ if ((DevRecord[1] & 0x80) == 0x80) fdevsdrs = 1;
+ if (vend_id == VENDOR_NEC) fdevsdrs = 0;
+ else if (vend_id == VENDOR_SUN) {
+ do_guid = 0; /*Sun doesn't support GUID*/
+ do_systeminfo = 0; /*Sun doesn't support system info*/
+ } else if (vend_id == VENDOR_INTEL) {
+ if (is_thurley(vend_id,prod_id) || is_romley(vend_id,prod_id))
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ }
+ } else {
+ goto do_exit;
+ }
+
+ ret = ipmi_getpicmg( DevRecord, sizeof(DevRecord),fdebug);
+ if (ret == 0) fpicmg = 1;
+ if (!fpicmg) fdevsdrs = 0; /* override, use SDR repository for FRU */
+ if (fdebug) printf("bmc_sa = %02x, fdevsdrs = %d\n",bmc_sa,fdevsdrs);
+
+ if (fset_mc) {
+ /* target a specific MC via IPMB (usu a picmg blade) */
+ if (fdebug) printf("set_mc: %02x:%02x:%02x type=%d\n",
+ g_bus,g_sa,g_lun,g_addrtype);
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ fonlybase = 1; /*only show this MC*/
+ } else {
+ g_sa = bmc_sa; /* BMC_SA = 0x20 */
+ }
+ if (g_frutype == 0) {
+ g_frutype = 0x01; /* other = "Component" */
+ }
+
+ if (foemkontron) {
+#ifdef METACOMMAND
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+ if (fdebug) verbose = 1;
+ ret = ipmi_kontronoem_main(NULL,argc,argv);
+#else
+ ret = LAN_ERR_NOTSUPPORT;
+#endif
+ goto do_exit;
+ }
+ npass = 1;
+
+ if (fonlybase || fonlyhsc) fbasefru = 1;
+ else {
+ /* find FRU devices from SDRs */
+ if (fpicmg && fdevsdrs) {
+ /* npass = 2 will get both SdrRep & DevSdr passes on CMM */
+ npass = 2;
+ g_addrtype = ADDR_IPMB;
+ }
+
+ nsdrs = 0;
+ for (ipass = 0; ipass < npass; ipass++)
+ {
+ ret = GetSDRRepositoryInfo(&j,&fdevsdrs);
+ if (fdebug) printf("GetSDRRepositoryInfo: ret=%x nSDRs=%d fdevsdrs=%d\n",
+ ret,j,fdevsdrs);
+ if (j == 0) {
+ /* this is an error, probably because fdevsdrs is wrong.*/
+ fdevsdrs = (fdevsdrs ^ 1);
+ if (fdebug) printf("nsdrs=0, retrying with fdevsdrs=%d\n",fdevsdrs);
+ j = 60; /*try some default num SDRs*/
+ }
+ nsdrs = j;
+ if (fdevsdrs) tag="Device SDRs";
+ else tag="SDR Repository";
+ printf("--- Scanning %s for %d SDRs ---\n",tag,nsdrs);
+
+ /* loop thru SDRs to find FRU devices */
+ recid = 0;
+ while (recid != LAST_REC)
+ {
+ if (do_reserve) {
+ /* reserve the SDR repository */
+ ret = sdr_get_reservation((uchar *)&rsvid,fdevsdrs);
+ if (fdebug) printf("sdr_get_reservation ret=%d\n",ret);
+ if (ret == 0) do_reserve = 0;
+ }
+
+ len = sizeof(sdr); /*sizeof(sdr); get 32 sdr bytes*/
+ ret = get_sdr(recid,rsvid,&nextid,sdr,&len,&cc);
+ if ((ret != 0) || (cc != 0)) {
+ printf("SDR[%04x] error %d ccode = %x\n",recid,ret,cc);
+ if ((cc == 0xC5) || (cc == 0x83)) ; /*do not stop (ARC)*/
+ else break; /*stop if errors*/
+ }
+ if (len >= MIN_SDR_SZ) {
+ if ((sdr[3] == 0x11) || (sdr[3] == 0x12)) /*SDR FRU or IPMB type*/
+ ret = get_show_fru(recid, sdr,len);
+ do_reserve = 1;
+ } /*endif get_show_fru */
+#ifdef PICMG_CHILD
+ /*
+ * Special logic for blade child MCs in PICMG ATCA systems
+ * if fchild, try all child MCs within the chassis.
+ * SDR type 12 capabilities bits (sdrdata[8]):
+ * 80 = Chassis Device
+ * 40 = Bridge
+ * 20 = IPMB Event Generator
+ * 10 = IPMB Event Receiver
+ * 08 = FRU Device
+ * 04 = SEL Device
+ * 02 = SDR Repository Device
+ * 01 = Sensor Device
+ * But all child MCs use Device SDRs anyway.
+ */
+ if (fpicmg && fchild && (sdr[3] == 0x12)) { /* PICMG MC DLR */
+ ushort _recid, _recnext;
+ int _sz;
+ uchar _sdrdata[MAX_SDR_SIZE];
+ int devsdrs_save;
+ uchar cc;
+
+ /* save the BMC globals, use IPMB MC */
+ devsdrs_save = fdevsdrs;
+ fdevsdrs = 1; /* use Device SDRs for the children*/
+ if (fdebug)
+ printf(" --- IPMB MC (sa=%02x cap=%02x id=%02x devsdrs=%d):\n",
+ sdr[5],sdr[8],sdr[12],fdevsdrs);
+ ipmi_set_mc(PICMG_SLAVE_BUS,sdr[5],sdr[6],g_addrtype);
+
+ _sz = 16;
+ ret = ipmi_cmd_mc(GET_DEVICE_ID,NULL,0,_sdrdata,&_sz,&cc,fdebug);
+ if (ret == 0 && cc == 0) {
+ /* get a new SDR Reservation ID */
+ ret = sdr_get_reservation((uchar *)&rsvid,fdevsdrs);
+ if (fdebug) printf("sdr_get_reservation ret=%d\n",ret);
+ /* Get the SDRs from the IPMB MC */
+ _recid = 0;
+ while (_recid != 0xffff)
+ {
+ _sz = sizeof(_sdrdata);
+ ret = get_sdr(_recid,rsvid,&_recnext,_sdrdata,&_sz,&cc);
+ if (fdebug) printf("get_sdr(%x) rv=%d cc=%x rlen=%d\n",
+ _recid,ret,cc,_sz);
+ if (ret != 0) {
+ printf("%04x get_sdr error %d, rlen=%d\n",_recid,ret,_sz);
+ break;
+ }
+ else if (_sz >= MIN_SDR_SZ) {
+ if ((_sdrdata[3] == 0x11) || (_sdrdata[3] == 0x12))
+ ret = get_show_fru(_recid, _sdrdata, _sz);
+ }
+ if (_recnext == _recid) _recid = 0xffff;
+ else _recid = _recnext;
+ } /*end while*/
+ } /*endif ret==0*/
+
+ /* restore BMC globals */
+ fdevsdrs = devsdrs_save;
+ ipmi_restore_mc();
+ do_reserve = 1; /* get a new SDR Reservation ID */
+ } /*endif fpicmg && fchild*/
+#endif
+
+ recid = nextid;
+ } /*end while sdrs*/
+ if (npass > 1) { /*npass==2 for PICMG child*/
+ /* Switch fdevsdrs from Device to Repository (or vice-versa) */
+ if (fdevsdrs == 0) fdevsdrs = 1;
+ else fdevsdrs = 0;
+ }
+ } /*end ipass loop*/
+ } /*endif not fonlybase*/
+
+ /* load the FRU data for Baseboard (address 0x20) */
+ printf("\n");
+ sa = g_sa; /* bmc_sa = BMC_SA = 0x20 */
+ if (fonlyhsc) { sa = 0xC0; g_addrtype = ADDR_SMI;
+ ipmi_set_mc(g_bus,sa,g_lun,g_addrtype);
+ }
+ if (g_addrtype == ADDR_IPMB)
+ ipmi_set_mc(g_bus,sa,g_lun,g_addrtype);
+
+ if (fbasefru) {
+ /* get and display the Baseboard FRU data */
+ ret = load_fru(sa,g_fruid,g_frutype,&pfru);
+ if (ret != 0) {
+ show_loadfru_error(sa,g_fruid,ret);
+ free_fru(pfru);
+ pfru = NULL;
+ goto do_exit;
+ }
+ ret = show_fru(sa,g_fruid,g_frutype,pfru);
+ if (ret != 0) printf("show_fru error = %d\n",ret);
+ }
+
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s,%02x,%02x] ", /*was by g_frutype*/
+ FruTypeString(SYS_FRUTYPE,g_fruid),sa,g_fruid);
+
+ if (!is_remote()) {
+ i = get_BiosVersion(biosver);
+ if (i == 0)
+ printf("%sBIOS Version %c %s\n",devstr,bdelim,biosver);
+ }
+
+ if (do_systeminfo) {
+ char infostr[64];
+ int len;
+ len = sizeof(infostr);
+ rv = get_system_info(1,infostr,&len); /*Firmware Version*/
+ if (rv == 0) {
+ len = sizeof(infostr);
+ rv = get_system_info(2,infostr,&len);
+ if (rv == 0) printf("%sSystem Name %c %s\n",devstr,bdelim,infostr);
+ len = sizeof(infostr);
+ rv = get_system_info(3,infostr,&len);
+ if (rv == 0) printf("%sPri Operating System%c %s\n",devstr,bdelim,infostr);
+ len = sizeof(infostr);
+ rv = get_system_info(4,infostr,&len);
+ if (rv == 0) printf("%sSec Operating System%c %s\n",devstr,bdelim,infostr);
+ } else {
+ if (fdebug && (rv == 0xC1)) /*only supported on later IPMI 2.0 fw */
+ printf("GetSystemInfo not supported on this platform\n");
+ }
+ }
+
+ if (fdump && ret == 0) {
+ /* Dump FRU to a binary file */
+ fp = fopen(binfile,"w");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ } else {
+ printf("Writing FRU size %d to %s ...\n",sfru,binfile);
+ len = (int)fwrite(frubuf, 1, sfru, fp);
+ fclose(fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d writing file %s\n",ret,binfile);
+ } else ret = 0;
+ }
+ goto do_exit;
+ }
+ else if (frestore) {
+ uchar cksum;
+ /* Restore FRU from a binary file */
+ fp = fopen(binfile,"r");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ } else {
+ ret = 0;
+ /* sfru and frubuf were set from load_fru above. */
+ len = (int)fread(frubuf, 1, sfru, fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d reading file %s\n",ret,binfile);
+ sfru = 0; /*for safety*/
+ }
+ fclose(fp);
+ if (fdebug) {
+ printf("FRU buffer from file (%d):",sfru);
+ dumpbuf(frubuf,sfru);
+ }
+ /* Do some validation of the FRU buffer header */
+ cksum = calc_cksum(&frubuf[0],7);
+ if (fdebug)
+ printf("header, len=8, cksum0 = %02x, cksum1 = %02x\n",
+ frubuf[7],cksum);
+ if (frubuf[7] != cksum) {
+ printf("Not a valid FRU file\n");
+ ret = ERR_BAD_FORMAT;
+ free_fru(frubuf);
+ }
+ if (ret == 0) { /*successfully read data*/
+ printf("Writing FRU size %d from %s ...\n",sfru,binfile);
+ ret = write_fru_data(g_fruid, 0, frubuf, sfru, fdebug);
+ free_fru(frubuf);
+ if (ret != 0) printf("write_fru error %d (0x%02x)\n",ret,ret);
+ else { /* successful, show new data */
+ ret = load_fru(sa,g_fruid,g_frutype,&pfru);
+ if (ret != 0) show_loadfru_error(sa,g_fruid,ret);
+ else ret = show_fru(sa,g_fruid,g_frutype,pfru);
+ free_fru(pfru);
+ pfru = NULL;
+ }
+ }
+ }
+ } /*end-else frestore */
+ else if ((fwritefru != 0) && ret == 0) {
+ if (fbasefru == 0) {
+ /* if not fbasefru, must reload fru because freed in get_show_fru */
+ ret = load_fru(sa,g_fruid,g_frutype,&pfru);
+ if (ret != 0) {
+ show_loadfru_error(sa,g_fruid,ret);
+ free_fru(pfru);
+ pfru = NULL;
+ goto do_exit;
+ }
+ if (fdebug) printf("Baseboard FRU buffer reloaded (%d):",sfru);
+ }
+ printf("\nWriting new product data (%s,%s,%s) ...\n",
+ prod_ver,serial_num,asset_tag);
+ ret = write_asset(asset_tag,serial_num,prod_ver,fwritefru,pfru);
+ free_fru(pfru);
+ if (ret != 0) printf("write_asset error %d (0x%02x)\n",ret,ret);
+ else { /* successful, show new data */
+ ret = load_fru(sa,g_fruid,g_frutype,&pfru);
+ if (ret != 0) show_loadfru_error(sa,g_fruid,ret);
+ else ret = show_fru(sa,g_fruid,g_frutype,pfru);
+ free_fru(pfru);
+ }
+ pfru = NULL;
+ }
+ else
+ free_fru(pfru);
+
+do_exit:
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return(ret);
+}
+
+/* end ifru.c */
diff --git a/util/ifru.h b/util/ifru.h
new file mode 100644
index 0000000..f3efaf6
--- /dev/null
+++ b/util/ifru.h
@@ -0,0 +1,13 @@
+/*
+ * ifru.h
+ * common routines from ifru.c
+ */
+#ifndef uchar
+#define uchar unsigned char
+#endif
+
+int load_fru(uchar sa, uchar frudev, uchar frutype, uchar **pfrubuf);
+int show_fru(uchar sa, uchar frudev, uchar frutype, uchar *pfrubuf);
+void free_fru(uchar *pfrubuf);
+
+/* end ifru.h */
diff --git a/util/ifru_picmg.c b/util/ifru_picmg.c
new file mode 100644
index 0000000..fd6234f
--- /dev/null
+++ b/util/ifru_picmg.c
@@ -0,0 +1,486 @@
+/*
+ * ifru_picmg.c
+ * These are helper routines for FRU PICMG decoding.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 09/08/10 Andy Cress - created
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#endif
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "ipicmg.h"
+
+extern int verbose;
+extern void show_guid(uchar *pguid); /*from ifru.c*/
+
+static char *picmg_link_type(uchar b)
+{
+ char *s;
+ if (b >= 0xf0 && b <= 0xf3) s = "OEM GUID Definition";
+ else switch(b) {
+ case 0x01: s = "PICMG 3.0 Base Interface 10/100/1000"; break;
+ case 0x02: s = "PICMG 3.1 Ethernet Fabric Interface"; break;
+ case 0x03: s = "PICMG 3.2 Infiniband Fabric Interface"; break;
+ case 0x04: s = "PICMG 3.3 Star Fabric Interface"; break;
+ case 0x05: s = "PICMG 3.4 PCI Express Fabric Interface"; break;
+ default: s = "Reserved"; break;
+ }
+ return(s);
+}
+
+static char *picmg_if_type(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x00: s = "Base Interface"; break;
+ case 0x01: s = "Fabric Interface"; break;
+ case 0x02: s = "Update Channel"; break;
+ case 0x03:
+ default: s = "Reserved"; break;
+ }
+ return(s);
+}
+
+static char *picmg_chan_type(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x00:
+ case 0x07: s = "PICMG 2.9"; break;
+ case 0x08: s = "Single Port Fabric IF"; break;
+ case 0x09: s = "Double Port Fabric IF"; break;
+ case 0x0a: s = "Full Port Fabric IF"; break;
+ case 0x0b: s = "Base IF"; break;
+ case 0x0c: s = "Update Channel IF"; break;
+ default: s = "Unknown IF"; break;
+ }
+ return(s);
+}
+
+void show_fru_picmg(uchar *pdata, int dlen)
+{
+ int id, i, j, k, m, n;
+ float f;
+ uchar *p;
+ uchar b0, b1, b2, b3, b4, b5, b6, b7, b8;
+ char *s1, *s2;
+ long l1, l2, l3;
+
+ id = pdata[3];
+ i = 5;
+ switch(id) {
+ case FRU_PICMG_BACKPLANE_P2P:
+ printf("\tFRU_PICMG_BACKPLANE_P2P\n");
+ while (i <= dlen) {
+ b1 = pdata[i];
+ b2 = pdata[i+1];
+ b3 = pdata[i+2];
+ printf("\t Channel Type : %02x - %s\n",b1,
+ picmg_chan_type(b1));
+ printf("\t Slot Address : %02x\n",b2);
+ printf("\t Channel Count : %02x\n",b3);
+ i += 3;
+ for (j = 0; j < b3; j++) {
+ if (i > dlen) break;
+ if (verbose)
+ printf("\t Channel[%d] : %02x -> %02x in slot %02x\n",
+ j,pdata[i],pdata[i+1],pdata[i+2]);
+ i += 3;
+ }
+ }
+ break;
+ case FRU_PICMG_ADDRESS_TABLE:
+ printf("\tFRU_PICMG_ADDRESS_TABLE\n");
+ printf("\t Type/Len : %02x\n", pdata[i++]);
+ printf("\t Shelf Addr : ");
+ for (j = 0; j < 20; j++)
+ printf("%02x ",pdata[i++]);
+ printf("\n");
+ n = pdata[i++];
+ printf("\t AddrTable Entries: %02x\n",n);
+ for (j = 0; j < n; j++) {
+ if (i >= dlen) break;
+ printf("\t HWAddr %02x, SiteNum %02x, SiteType %02x\n",
+ pdata[i], pdata[i+1], pdata[i+2]);
+ i += 3;
+ }
+ break;
+ case FRU_PICMG_SHELF_POWER_DIST:
+ printf("\tFRU_PICMG_SHELF_POWER_DIST\n");
+ n = pdata[i++];
+ printf("\t Num Power Feeds : %02x\n",n);
+ for (j = 0; j < n; j++) {
+ if (i >= dlen) break;
+ printf("\t Max Ext Current : %04x\n",
+ (pdata[i] | (pdata[i+1] << 8)));
+ i += 2;
+ printf("\t Max Int Current : %04x\n",
+ (pdata[i] | (pdata[i+1] << 8)));
+ i += 2;
+ printf("\t Min Exp Voltage : %02x\n", pdata[i++]);
+ m = pdata[i++]; /*num entries*/
+ printf("\t Feed to FRU count: %02x\n", m);
+ for (k = 0; k < m; k++) {
+ if (i >= dlen) break;
+ printf("\t HW: %02x",pdata[i++]);
+ printf(" FRU ID: %02x\n",pdata[i++]);
+ }
+ }
+ break;
+ case FRU_PICMG_SHELF_ACTIVATION:
+ printf("\tFRU_PICMG_SHELF_ACTIVATION\n");
+ printf("\t Allowance for FRU Act Readiness : %02x\n",
+ pdata[i++]);
+ n = pdata[i++];
+ printf("\t FRU activation and Power desc Cnt: %02x\n",n);
+ for (j = 0; j < n; j++) {
+ if (i >= dlen) break;
+ printf("\t HW Addr: %02x, ", pdata[i++]);
+ printf(" FRU ID: %02x, ", pdata[i++]);
+ printf(" Max FRU Power: %04x, ", pdata[i] | (pdata[i+1]<<8));
+ i += 2;
+ printf(" Config: %02x\n", pdata[i++]);
+ }
+ break;
+ case FRU_PICMG_SHMC_IP_CONN:
+ printf("\tFRU_PICMG_SHMC_IP_CONN\n");
+ printf("\t Conn Data: ");
+ for ( ; i < dlen; i++) {
+ printf("%02x ",pdata[i]);
+ }
+ printf("\n");
+ break;
+ case FRU_PICMG_BOARD_P2P: /*0x14*/
+ printf("\tFRU_PICMG_BOARD_P2P\n");
+ n = pdata[i++]; /*guid count*/
+ printf("\t GUID count : %d\n",n);
+ for (j = 0; j < n; j++) {
+ printf("\t GUID[%d] : ",j);
+ show_guid(&pdata[i]);
+ printf("\n");
+ i += 16;
+ }
+ for (j = 1; i < dlen; i += 4) {
+ p = &pdata[i];
+ b1 = (p[0] & 0x3f); /*chan*/
+ b2 = (p[0] & 0xc0) >> 6; /*if*/
+ b3 = (p[1] & 0x0f); /*port*/
+ b4 = ((p[1] & 0xf0) >> 4) + (p[2] & 0xf0); /*type*/
+ b5 = (p[2] & 0x0f); /*ext*/
+ b6 = p[3]; /*grouping*/
+ printf("\t Link%d Grouping : %02x\n",j,b6);
+ printf("\t Link%d Extension : %02x\n",j,b5);
+ printf("\t Link%d Type : %02x - %s\n",
+ j,b4,picmg_link_type(b4));
+ printf("\t Link%d Port : %02x\n",j,b3);
+ printf("\t Link%d Interface : %02x - %s\n",
+ j,b2,picmg_if_type(b2));
+ printf("\t Link%d Channel : %02x\n",j,b1);
+ j++;
+ }
+ break;
+ case FRU_AMC_CURRENT:
+ printf("\tFRU_AMC_CURRENT\n");
+ b1 = pdata[i]; /*current*/
+ f = (float)(b1/10.0);
+ printf("\t Current draw: %.1f A @ 12V => %.2f Watt\n",
+ f, (f*12.0));
+ break;
+ case FRU_AMC_ACTIVATION:
+ printf("\tFRU_AMC_ACTIVATION\n");
+ b1 = pdata[i] | (pdata[i+1]<<8); /*max current*/
+ i += 2;
+ f = (float)b1 / 10;
+ printf("\t Max Internal Current(@12V) : %.2f A [ %.2f Watt ]\n",
+ f, f*12);
+ printf("\t Module Activation Readiness: %i sec.\n",pdata[i++]);
+ n = pdata[i++];
+ printf("\t Descriptor Count: %i\n",n);
+ for (j = 0; i < dlen; i += 3) {
+ if (j >= n) break;
+ printf("\t IPMB Address : %02x\n",pdata[i]);
+ printf("\t Max Module Current: %.2f A\n",
+ (float)(pdata[i+1]/10));
+ j++;
+ }
+ break;
+ case FRU_AMC_CARRIER_P2P:
+ printf("\tFRU_AMC_CARRIER_P2P\n");
+ for ( ; i < dlen; ) {
+ b1 = pdata[i]; /*resource id*/
+ n = pdata[i+1]; /*desc count*/
+ i += 2;
+ b2 = (b1 >> 7);
+ printf("\t Resource ID: %i, Type: %s\n",
+ (b1 & 0x07), (b2 == 1 ? "AMC" : "Local"));
+ printf("\t Descriptor Count: %i\n",n);
+ for (j = 0; j < n; j++) {
+ if (i >= dlen) break;
+ p = &pdata[i];
+ b3 = p[0]; /*remote resource id*/
+ b4 = (p[1] & 0x1f); /*remote port*/
+ b5 = (p[1] & 0xe0 >> 5) + (p[2] & 0x03 << 3); /*local*/
+ printf("\t Port %02d -> Remote Port %02d "
+ "[ %s ID: %02d ]\n", b5, b4,
+ ((b3 >> 7) == 1)? "AMC " : "local", b3 & 0x0f);
+ i += 3;
+ }
+ }
+ break;
+ case FRU_AMC_P2P:
+ printf("\tFRU_AMC_P2P\n");
+ n = pdata[i++]; /*guid count*/
+ printf("\t GUID count : %d\n",n);
+ for (j = 0; j < n; j++) {
+ printf("\t GUID[%d] : ",j);
+ show_guid(&pdata[i]);
+ printf("\n");
+ i += 16;
+ }
+ b1 = pdata[i] & 0x0f; /*resource id*/
+ b2 = (pdata[i] & 0x80) >> 7; /*resource type*/
+ i++;
+ printf("\t Resource ID: %i - %s\n",b1,
+ b2 ? "AMC Module" : "On-Carrier Device");
+ n = pdata[i++]; /*descriptor count*/
+ printf("\t Descriptor Count: %i\n",n);
+ for (j = 0; j < n; j++) { /*channel desc loop*/
+ if (i >= dlen) break;
+ p = &pdata[i];
+ b0 = p[0] & 0x1f;
+ b1 = ((p[0] & 0xe0) >> 5) + ((p[1] & 0x03) << 3);
+ b2 = ((p[1] & 0x7c) >> 2);
+ b3 = ((p[1] & 0x80) >> 7) + ((p[2] & 0x0f) << 1);
+ printf("\t Lane 0 Port: %i\n",b0);
+ printf("\t Lane 1 Port: %i\n",b1);
+ printf("\t Lane 2 Port: %i\n",b2);
+ printf("\t Lane 3 Port: %i\n",b3);
+ i += 3;
+ }
+ for ( ; i < dlen; i += 5) { /*ext descriptor loop*/
+ p = &pdata[i];
+ b0 = p[0]; /*channel id*/
+ b1 = p[1] & 0x01; /*port flag 0*/
+ b2 = (p[1] & 0x02) >> 1; /*port flag 1*/
+ b3 = (p[1] & 0x04) >> 2; /*port flag 2*/
+ b4 = (p[1] & 0x08) >> 3; /*port flag 3*/
+ b5 = ((p[1] & 0xf0) >> 4) + ((p[2] & 0x0f) << 4); /*type*/
+ b6 = (p[2] & 0xf0) >> 4; /*type ext*/
+ b7 = p[3]; /*group id*/
+ b8 = (p[4] & 0x03); /*asym match*/
+ printf("\t Link Designator: Channel ID: %i, "
+ "Port Flag 0: %s%s%s%s\n",b0,
+ b1 ? "o" : "-",
+ b2 ? "o" : "-",
+ b3 ? "o" : "-",
+ b4 ? "o" : "-" );
+ switch(b5) { /*link type*/
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE:
+ printf("\t Link Type: %02x - %s\n", b5,
+ "AMC.1 PCI Express");
+ switch(b6) { /*link type ext*/
+ case AMC_LINK_TYPE_EXT_PCIE_G1_NSSC:
+ s2 = "Gen 1 capable - non SSC"; break;
+ case AMC_LINK_TYPE_EXT_PCIE_G1_SSC:
+ s2 = "Gen 1 capable - SSC"; break;
+ case AMC_LINK_TYPE_EXT_PCIE_G2_NSSC:
+ s2 = "Gen 2 capable - non SSC"; break;
+ case AMC_LINK_TYPE_EXT_PCIE_G2_SSC:
+ s2 = "Gen 2 capable - SSC"; break;
+ default:
+ s2 = "Invalid"; break;
+ }
+ printf("\t Link Type Ext: %02x - %s\n", b6,s2);
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS1:
+ case FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS2:
+ printf("\t Link Type: %02x - %s\n", b5,
+ "AMC.1 PCI Express Advanced Switching");
+ printf("\t Link Type Ext: %02x\n", b6);
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET:
+ s1 = "AMC.2 Ethernet";
+ printf("\t Link Type: %02x - %s\n", b5,s1);
+ switch(b6) { /*link type ext*/
+ case AMC_LINK_TYPE_EXT_ETH_1000_BX:
+ s2 = "1000Base-Bx (SerDES Gigabit) Ethernet Link";
+ break;
+ case AMC_LINK_TYPE_EXT_ETH_10G_XAUI:
+ s2 = "10Gbit XAUI Ethernet Link"; break;
+ default:
+ s2 = "Invalid"; break;
+ }
+ printf("\t Link Type Ext: %02x - %s\n", b6,s2);
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE:
+ printf("\t Link Type: %02x - %s\n", b5,
+ "AMC.3 Storage");
+ switch(b6) { /*link type ext*/
+ case AMC_LINK_TYPE_EXT_STORAGE_FC:
+ s2 = "Fibre Channel"; break;
+ case AMC_LINK_TYPE_EXT_STORAGE_SATA:
+ s2 = "Serial ATA"; break;
+ case AMC_LINK_TYPE_EXT_STORAGE_SAS:
+ s2 = "Serial Attached SCSI"; break;
+ default:
+ s2 = "Invalid"; break;
+ }
+ printf("\t Link Type Ext: %02x - %s\n", b6,s2);
+ break;
+ case FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO:
+ printf("\t Link Type: %02x - %s\n", b5,
+ "AMC.4 Serial Rapid IO");
+ printf("\t Link Type Ext: %02x\n", b6);
+ break;
+ default:
+ printf("\t Link Type: %02x - %s\n", b5,
+ "reserved or OEM GUID");
+ printf("\t Link Type Ext: %02x\n", b6);
+ break;
+ } /*end switch(link_type)*/
+ printf("\t Link group Id: %i\n", b7);
+ printf("\t Link Asym Match: %i\n", b8);
+ } /*end ext descriptor loop*/
+ break;
+ case FRU_AMC_CARRIER_INFO:
+ printf("\tFRU_AMC_CARRIER_INFO\n");
+ b1 = pdata[i++]; /*extVersion*/
+ n = pdata[i++]; /*siteCount*/
+ printf("\t AMC.0 extension version: R%d.%d\n",
+ b1 & 0x0f, (b1 >> 4) & 0x0f);
+ printf("\t Carrier Site Count: %d\n",n);
+ for (j = 0; j < n; j++) {
+ if (i >= dlen) break;
+ printf("\t Site ID: %i\n", pdata[i++]);
+ }
+ break;
+ case FRU_PICMG_CLK_CARRIER_P2P:
+ printf("\tFRU_PICMG_CLK_CARRIER_P2P\n");
+ b0 = pdata[i++];
+ n = pdata[i++];
+ k = (b0 & 0xC0) >> 6;
+ switch(k) {
+ case 0: s1 = "On-Carrier-Device"; break;
+ case 1: s1 = "AMC slot"; break;
+ case 2: s1 = "Backplane"; break;
+ default: s1 = "reserved"; break;
+ }
+ printf("\t Clock Resource ID: %02x, Type: %s\n",b0,s1 );
+ printf("\t Channel Count : %02x\n",n);
+ for (j = 0; j < n; j++) {
+ b1 = pdata[i++]; /*local channel*/
+ b2 = pdata[i++]; /*remote channel*/
+ b3 = pdata[i++]; /*remote resource*/
+ k = (b3 & 0xC0) >> 6;
+ switch(k) {
+ case 0: s1 = "Carrier-Dev"; break;
+ case 1: s1 = "AMC slot "; break;
+ case 2: s1 = "Backplane "; break;
+ default: s1 = "reserved "; break;
+ }
+ printf("\t CLK-ID: %02x -> %02x [ %s %02x ]\n",b1,b2,s1,b3);
+ }
+ break;
+ case FRU_PICMG_CLK_CONFIG:
+ printf("\tFRU_PICMG_CLK_CONFIG\n");
+ b0 = pdata[i++];
+ n = pdata[i++];
+ printf("\t Clock Resource ID: %02x\n",b0);
+ printf("\t Descriptor Count : %02x\n",n);
+ for (j = 0; j < n; j++) {
+ b1 = pdata[i++]; /*channel id*/
+ b2 = pdata[i++]; /*control*/
+ printf("\t CLK-ID: %02x - CTRL %02x [ %12s ]\n", b1, b2,
+ (b2 & 0x01) == 0 ? "Carrier IPMC":"Application");
+ b3 = pdata[i++]; /*indirect_cnt*/
+ b4 = pdata[i++]; /*direct_cnt*/
+ printf("\t Cnt: Indirect %02x / Direct %02x\n",b3,b4);
+ for (k = 0; k < b3; k++) {
+ b5 = pdata[i++]; /*feature*/
+ b6 = pdata[i++]; /*dep_chn_id*/
+ printf("\t Feature: %02x [%8s] - ",
+ b5, (b5 & 0x01)==1 ? "Source":"Receiver");
+ printf("Dep. CLK-ID: %02x\n",b6);
+ }
+ for (k = 0; k < b4; k++) {
+ b5 = pdata[i++]; /*feature*/
+ b6 = pdata[i++]; /*family*/
+ b7 = pdata[i++]; /*accuracy*/
+ l1 = pdata[i] | (pdata[i+1] << 8) | /*frequency*/
+ (pdata[i+2] << 8) | (pdata[i+3] << 8);
+ i += 4;
+ l2 = pdata[i] | (pdata[i+1] << 8) | /*min frequency*/
+ (pdata[i+2] << 8) | (pdata[i+3] << 8);
+ i += 4;
+ l3 = pdata[i] | (pdata[i+1] << 8) | /*max frequency*/
+ (pdata[i+2] << 8) | (pdata[i+3] << 8);
+ i += 4;
+ printf("\t Feature: %02x - PLL: %x / Asym: %s\n",
+ b5, (b5 >> 1) & 0x01, (b5 & 1) ? "Source":"Receiver");
+ printf("\t Family : %02x - AccLVL: %02x\n", b6, b7);
+ printf("\t FRQ : %-9d, min: %-9d, max: %-9d\n",
+ (int)l1, (int)l2, (int)l3);
+ }
+ }
+ break;
+ case FRU_UTCA_FRU_INFO_TABLE:
+ case FRU_UTCA_CARRIER_MNG_IP:
+ case FRU_UTCA_CARRIER_INFO:
+ case FRU_UTCA_CARRIER_LOCATION:
+ case FRU_UTCA_SHMC_IP_LINK:
+ case FRU_UTCA_POWER_POLICY:
+ case FRU_UTCA_ACTIVATION:
+ case FRU_UTCA_PM_CAPABILTY:
+ case FRU_UTCA_FAN_GEOGRAPHY:
+ case FRU_UTCA_CLOCK_MAPPING:
+ case FRU_UTCA_MSG_BRIDGE_POLICY:
+ case FRU_UTCA_OEM_MODULE_DESC:
+ printf("\tNot yet implemented uTCA record %x\n",id);
+ break;
+ default:
+ printf("\tUnknown PICMG Extension %x\n",id);
+ break;
+ }
+} /*end show_fru_picmg*/
+
+/*end ifru_picmg.c */
diff --git a/util/ifruset.c b/util/ifruset.c
new file mode 100644
index 0000000..3e0299a
--- /dev/null
+++ b/util/ifruset.c
@@ -0,0 +1,1658 @@
+/*
+ * ifruset (copy of ifru.c with extended FRU writing)
+ *
+ * This tool reads the FRU configuration, and optionally sets the asset
+ * tag field in the FRU data. See IPMI v1.5 spec section 28.
+ * It can use either the Intel /dev/imb driver or VALinux /dev/ipmikcs.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 04/01/10 Andy Cress - created from ifru.c 2.6.1
+ */
+/*M*
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "ipicmg.h" // #define OEM_PICMG 12634
+
+extern int get_LastError( void ); /* ipmilan.c */
+extern int get_BiosVersion(char *str);
+extern int get_SystemGuid(uchar *str);
+extern void fmt_time(time_t etime, char *buf, int bufsz); /*see ievents.c*/
+
+#define FIELD_LEN 24
+#define NUM_BOARD_FIELDS 6
+#define NUM_PRODUCT_FIELDS 8
+#define NUM_CHASSIS_FIELDS 3
+#define ERR_LENMAX -7 /*same as LAN_ERR_BADLENGTH */
+#define ERR_LENMIN -10 /*same as LAN_ERR_TOO_SHORT */
+#define ERR_OTHER -13 /*same as LAN_ERR_OTHER */
+
+#define STRING_DATA_TYPE_BINARY 0x00
+#define STRING_DATA_TYPE_BCD_PLUS 0x01
+#define STRING_DATA_TYPE_SIX_BIT_ASCII 0x02
+#define STRING_DATA_TYPE_LANG_DEPENDENT 0x03
+
+#define FRUCHUNK_SZ 16
+#define FRU_END 0xC1
+#define FRU_EMPTY_FIELD 0xC0
+#define FRU_TYPE_MASK 0xC0
+#define FRU_LEN_MASK 0x3F
+#define IPROD_MANUF 0
+#define IPROD_NAME 1
+#define IPROD_PART 2
+#define IPROD_VERS 3
+#define IPROD_SERNUM 4
+#define IPROD_ASSET 5
+#define IPROD_FRUID 6
+#define IPROD_OEM 7
+
+static char *progname = "ifruset";
+static char *progver = "2.93";
+static char fdebug = 0;
+static char fpicmg = 0;
+static char fonlybase = 0;
+static char fonlyhsc = 0;
+static char fdevsdrs = 0;
+static char fshowlen = 0;
+static char fgetfru = 0;
+static char fdoanyway = 0;
+static char fset_mc = 0;
+static char fcanonical = 0;
+static char fdump = 0;
+static char frestore = 0;
+static int fwritefru = 0;
+static int prod_id, vend_id = 0;
+static char bdelim = ':';
+static char *binfile = NULL;
+static uchar bmc_sa = BMC_SA; /*defaults to 0x20*/
+static uchar guid[17] = "";
+static uchar *frubuf = NULL;
+static uchar *newdata = NULL; /* new FRU data, including the product area */
+ /* usually 4*64 + 3 = 259 bytes */
+static int sfru = 0;
+static int chassis_offset = -1;
+static int chassis_len = 0;
+static char chassis_name[FIELD_LEN] = {0};
+static int product_num = NUM_PRODUCT_FIELDS;
+typedef struct {
+ int offset;
+ int len;
+ char tag[FIELD_LEN];
+ } FIELDTYPE;
+static FIELDTYPE prodarea[NUM_PRODUCT_FIELDS] = {
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0} };
+static FIELDTYPE prodnew[NUM_PRODUCT_FIELDS] = {
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0},
+ -1, 0, {0} };
+static int maxprod = 0;
+static int ctype;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = 0;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static uchar g_fruid = 0; /* default to fruid 0 */
+static uchar g_frutype = 0;
+/* g_frutype values (detected), see also FruTypeString
+ * --TAG---- FRU IPMB
+ * Baseboard = 0x0c 0x07
+ * PowerSply = 0x0a
+ * PowerCage = 0x15
+ * DIMM = 0x20
+ * HotSwapCt = 0x0f
+ * ME = 0x2e
+ * Component = * * (all others)
+ */
+
+#define MAX_CTYPE 26
+char *ctypes[MAX_CTYPE] = { "", "Other", "Unknown", "Desktop",
+ "Low Profile Desktop", "Pizza Box", "Mini-Tower", "Tower",
+ "Portable", "Laptop", "Notebook", "Handheld", "Docking Station",
+ "All-in-One", "Sub-Notebook", "Space-saving", "Lunch Box",
+ "Main Server Chassis", "Expansion Chassis", "SubChassis",
+ "Bus Expansion Chassis", "Peripheral Chassis",
+ "RAID Chassis", /*0x17=23.*/ "Rack-Mount Chassis",
+ "New24" , "New25"};
+ /* what about bladed chassies? */
+char *ctype_hdr =
+"Chassis Type ";
+char *chassis[NUM_CHASSIS_FIELDS] = {
+"Chassis Part Number ",
+"Chassis Serial Num ",
+"Chassis OEM Field " };
+char *board[NUM_BOARD_FIELDS] = {
+"Board Manufacturer ",
+"Board Product Name ",
+"Board Serial Number ",
+"Board Part Number ",
+"Board FRU File ID ",
+"Board OEM Field " };
+char *product[NUM_PRODUCT_FIELDS] = {
+"Product Manufacturer",
+"Product Name ",
+"Product Part Number ",
+"Product Version ",
+"Product Serial Num ",
+"Product Asset Tag ",
+"Product FRU File ID ",
+"Product OEM Field " };
+char *asset_hdr =
+" Asset Tag Length ";
+
+#if 0
+typedef struct {
+ uchar len :6;
+ uchar type:2;
+ } TYPE_LEN; /*old, assumes lo-hi byte order*/
+#else
+typedef struct {
+ uchar len;
+ uchar type;
+ } TYPE_LEN;
+#endif
+
+void
+free_fru(void)
+{
+ if (frubuf != NULL) {
+ free(frubuf);
+ frubuf = NULL;
+ }
+ if (newdata != NULL) {
+ free(newdata);
+ newdata = NULL;
+ }
+ return;
+}
+
+int
+load_fru(uchar sa, uchar frudev, uchar frutype)
+{
+ int ret = 0;
+ uchar indata[16];
+ uchar resp[18];
+ int sresp;
+ uchar cc;
+ int sz;
+ char fwords;
+ ushort fruoff = 0;
+ int i;
+ int chunk;
+
+ indata[0] = frudev;
+ sresp = sizeof(resp);
+ if (fdebug) printf("load_fru: sa = %02x, frudev = %02x\n",sa,frudev);
+ ret = ipmi_cmd_mc(GET_FRU_INV_AREA,indata,1,resp,&sresp,&cc,fdebug);
+ if (fdebug) printf("load_fru: inv ret = %d, cc = %x\n",ret,cc);
+ if (ret != 0) return(ret);
+ if (cc != 0) { ret = (cc & 0x00ff); return(ret); }
+
+ sz = resp[0] + (resp[1] << 8);
+ if (resp[2] & 0x01) { fwords = 1; sz = sz * 2; }
+ else fwords = 0;
+
+ frubuf = malloc(sz);
+ if (frubuf == NULL) return(get_errno());
+ sfru = sz;
+
+ /* Loop on READ_FRU_DATA */
+ for (i = 0, chunk=FRUCHUNK_SZ; i < sz; i+=chunk)
+ {
+ if ((i+chunk) >= sz) chunk = sz - i;
+ indata[0] = frudev; /* FRU Device ID */
+ if (fwords) {
+ indata[3] = chunk / 2;
+ fruoff = (i/2);
+ } else {
+ indata[3] = chunk;
+ fruoff = i;
+ }
+ indata[1] = fruoff & 0x00FF;
+ indata[2] = (fruoff & 0xFF00) >> 8;
+ sresp = sizeof(resp);
+ ret = ipmi_cmd_mc(READ_FRU_DATA,indata,4,resp,&sresp,&cc,fdebug);
+ if (ret != 0) break;
+ else if (cc != 0) {
+ if (i == 0) ret = cc & 0x00ff;
+ if (fdebug) printf("read_fru[%d]: ret = %d cc = %x\n",i,ret,cc);
+ break;
+ }
+ memcpy(&frubuf[i],&resp[1],chunk);
+ }
+ if ((frudev == 0) && (sa == bmc_sa)) { /*main system fru*/
+ sresp = sizeof(resp);
+ ret = ipmi_cmd_mc(GET_SYSTEM_GUID,indata,0,resp,&sresp,&cc,fdebug);
+ if ((ret != 0) && !is_remote()) { /* get UUID from SMBIOS */
+ cc = 0; sresp = 16;
+ ret = get_SystemGuid(resp);
+ }
+ if (fdebug) printf("system_guid: ret = %d, cc = %x\n",ret,cc);
+ if (ret == 0 && cc == 0) {
+ if (fdebug) {
+ printf("system guid (%d): ",sresp);
+ for (i=0; i<16; i++) printf("%02x ",resp[i]);
+ printf("\n");
+ }
+ memcpy(&guid,&resp,16);
+ guid[16] = 0;
+ }
+ } /*endif*/
+
+ return(ret);
+}
+
+static void decode_string(unsigned char type,
+ unsigned char language_code,
+ unsigned char *source,
+ int slen,
+ char *target,
+ int tsize)
+{
+ static const char bcd_plus[] = "0123456789 -.:,_";
+ unsigned char *s = &source[0];
+ unsigned char *d = &target[0];
+ int len, i, j, k;
+ union { uint32_t bits; char chars[4]; } u;
+
+ if (slen == 0 || slen == 1) return;
+ switch(type) {
+ case STRING_DATA_TYPE_BINARY: /* 00: binary/unspecified */
+ len = (slen*2); break; /* hex dump -> 2x length */
+ case STRING_DATA_TYPE_SIX_BIT_ASCII: /*type 2 6-bit ASCII*/
+ /* 4 chars per group of 1-3 bytes */
+ len = ((((slen+2)*4)/3) & ~3); break;
+ case STRING_DATA_TYPE_LANG_DEPENDENT: /* 03 language dependent */
+ case STRING_DATA_TYPE_BCD_PLUS: /* 01b: BCD plus */
+ default:
+ len = slen; break;
+ }
+ if (len >= tsize) len = tsize - 1;
+ memset(target, 0, len);
+ if (type == STRING_DATA_TYPE_BCD_PLUS) { /*type 1 BCD plus*/
+ for (k=0; k<len; k++)
+ target[k] = bcd_plus[(s[k] & 0x0f)];
+ target[k] = '\0';
+ } else if (type == STRING_DATA_TYPE_SIX_BIT_ASCII) { /*type 2 6-bit ASCII*/
+ for (i=j=0; i<slen; i+=3) {
+ u.bits = 0;
+ k = ((slen-i) < 3 ? (slen-i) : 3);
+#if WORDS_BIGENDIAN
+ u.chars[3] = s[i];
+ u.chars[2] = (k > 1 ? s[i+1] : 0);
+ u.chars[1] = (k > 2 ? s[i+2] : 0);
+#define CHAR_IDX 3
+#else
+ memcpy((void *)&u.bits, &s[i], k);
+#define CHAR_IDX 0
+#endif
+ for (k=0; k<4; k++) {
+ target[j++] = ((u.chars[CHAR_IDX] & 0x3f) + 0x20);
+ u.bits >>= 6;
+ }
+ }
+ target[j] = '\0';
+ } else if (type == STRING_DATA_TYPE_LANG_DEPENDENT) { /*type 3*/
+ if ((language_code == 0x00) || (language_code == 0x25) ||
+ (language_code == 0x19)) {
+ memcpy(target, source, len);
+ target[len] = 0x0;
+ } else {
+ printf("Language 0x%x dependent decode not supported\n",language_code);
+ }
+ } else if (type == STRING_DATA_TYPE_BINARY) { /* 00: binary/unspecified */
+ strncpy(target, buf2str(s, slen), len);
+ } else { /* other */
+ printf("Unable to decode type 0x%.2x\n",type);
+ }
+ return;
+}
+
+uchar calc_cksum(uchar *pbuf,int len)
+{
+ int i;
+ uchar cksum;
+ uchar sum = 0;
+
+ for (i = 0; i < len; i++) sum += pbuf[i];
+ cksum = 0 - sum;
+ return(cksum);
+}
+
+static void dumpbuf(uchar *pbuf,int sz)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) { j = 0; printf("%s\n %04d: ",line,i); }
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ printf("%02x ",pbuf[i]);
+ }
+ line[j] = 0;
+ printf("%s\n",line);
+ return;
+}
+
+#define NSPDMFG 7
+static struct {
+ uchar id; char *str;
+} spd_mfg[NSPDMFG] = { /* see JEDEC JEP106 doc */
+{ 0x2c, "Micron" },
+{ 0x15, "Philips Semi" },
+{ 0x1c, "Mitsubishi" },
+{ 0xce, "Samsung" },
+{ 0xc1, "Infineon" },
+{ 0x98, "Kingston" },
+{ 0x89, "Intel" }
+};
+
+int ValidTL(uchar typelen)
+{
+ if (vend_id != VENDOR_INTEL) return 1;
+ if ((typelen & 0xC0) == 0xC0) return 1;
+ else return 0;
+}
+
+char * FruTypeString(uchar frutype)
+{
+ char *pstr;
+ switch (frutype) {
+ case 0x07: pstr = "Baseboard"; break; /*IPMB*/
+ case 0x0c: pstr = "Baseboard"; break; /*FRU*/
+ case 0x0a: pstr = "PowerSply"; break; /*FRU*/
+ case 0x15: pstr = "PowerCage"; break; /*FRU*/
+ case 0x20: pstr = "DIMM "; break; /*FRU*/
+ case 0x0f: pstr = "HotSwapCt"; break; /*IPMB*/
+ case 0x2e: pstr = "ME "; break; /*IPMB*/
+ default: pstr = "Component"; break;
+ }
+ return(pstr);
+}
+
+static void
+show_spd(uchar *spd, int lenspd, uchar frudev, uchar frutype)
+{
+ int sz;
+ char *pstr;
+ uchar mrev;
+ int i;
+ char devstr[20];
+
+ sz = spd[0]; /* sz should == lenspd */
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s,%02x] ",FruTypeString(frutype),frudev);
+ printf("%sMemory SPD Size %c %d\n",
+ devstr,bdelim,lenspd);
+ if (spd[2] == 0x07) pstr = "DDR";
+ else /* usu 0x04 */ pstr = "SDRAM";
+ printf("%sMemory Type %c %s\n",
+ devstr,bdelim,pstr);
+ printf("%sModule Density %c %d MB per bank\n",
+ devstr,bdelim, (spd[31] * 4));
+ printf("%sModule Banks %c %d banks\n",
+ devstr,bdelim,spd[5]);
+ printf("%sModule Rows, Cols %c %d rows, %d cols\n",
+ devstr,bdelim, spd[3], spd[4]);
+ if (spd[11] == 0x00) pstr = "Non-parity";
+ else /* usu 0x02 */ pstr = "ECC";
+ printf("%sDIMM Config Type %c %s\n",devstr,bdelim,pstr);
+ for (i = 0; i < NSPDMFG; i++)
+ if (spd_mfg[i].id == spd[64]) break;
+ if (i == NSPDMFG) pstr = ""; /* not found, use null string */
+ else pstr = spd_mfg[i].str;
+ printf("%sManufacturer ID %c %s (0x%02x)\n",
+ devstr,bdelim, pstr, spd[64]);
+ mrev = spd[91]; /* save this byte for later */
+ spd[91] = 0; /*stringify part number */
+ printf("%sManufacturer Part# %c %s\n",
+ devstr,bdelim,&spd[73]);
+ printf("%sManufacturer Rev %c %02x %02x\n",
+ devstr,bdelim,mrev,spd[92]);
+ printf("%sManufacturer Date %c year=%02d week=%02d\n",
+ devstr,bdelim,spd[93],spd[94]);
+ printf("%sAssembly Serial Num %c %02x%02x%02x%02x\n",
+ devstr,bdelim,spd[95], spd[96], spd[97], spd[98]);
+ spd[91] = mrev; /* restore byte, so ok to repeat later */
+ return;
+}
+
+void show_guid(uchar *pguid)
+{
+ char *s;
+ int i;
+ for (i=0; i<16; i++) {
+ if ((i == 4) || (i == 6) || (i == 8) || (i == 10)) s = "-";
+ else s = "";
+ printf("%s%02x",s,pguid[i]);
+ }
+}
+
+static char *volt_desc(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x03: s = "5V"; break;
+ case 0x02: s = "3.3V"; break;
+ case 0x01: s = "-12V"; break;
+ case 0x00:
+ default: s = "12V"; break;
+ }
+ return(s);
+}
+
+static char *mgt_type(uchar b)
+{
+ char *s;
+ switch(b) {
+ case 0x01: s = "SysMgt_URL"; break;
+ case 0x02: s = "SystemName"; break;
+ case 0x03: s = "SysPingAddr"; break;
+ case 0x04: s = "Compon_URL"; break;
+ case 0x05: s = "ComponName"; break;
+ case 0x06: s = "ComponPing"; break;
+ case 0x07:
+ default: s = "SysGUID"; break;
+ }
+ return(s);
+}
+
+static
+void show_fru_multi(char *tag, int midx, uchar mtype, uchar *pdata, int dlen)
+{
+ int vend, i;
+ char mystr[256];
+ char *s1, *s2;
+ int v1, v2, v3, v4, v5, v6, v7, v8;
+ uchar b1, b2;
+
+ if (fdebug) dumpbuf(pdata,dlen); /*multi-record area dump*/
+ sprintf(mystr,"%sMulti[%d] ",tag,midx);
+ i = strlen(mystr);
+ switch(mtype) {
+ case 0x00: /*Power Supply*/
+ printf("%sPower Supply Record %c \n",mystr,bdelim);
+ v1 = pdata[0] + ((pdata[1] & 0x0f) << 8);
+ printf("\t Capacity \t%c %d W\n",bdelim, v1);
+ v2 = pdata[2] + (pdata[3] << 8);
+ printf("\t Peak VA \t%c %d VA\n",bdelim, v2);
+ printf("\t Inrush Current\t%c %d A\n",bdelim, pdata[4]);
+ printf("\t Inrush Interval\t%c %d ms\n",bdelim, pdata[5]);
+ v3 = pdata[6] + (pdata[7] << 8);
+ v4 = pdata[8] + (pdata[9] << 8);
+ printf("\t Input Voltage Range1\t%c %d-%d V\n",
+ bdelim,v3/100,v4/100);
+ v3 = pdata[10] + (pdata[11] << 8);
+ v4 = pdata[12] + (pdata[13] << 8);
+ printf("\t Input Voltage Range2\t%c %d-%d V\n",
+ bdelim,v3/100,v4/100);
+ printf("\t Input Frequency Range\t%c %d-%d Hz\n",
+ bdelim,pdata[14],pdata[15]);
+ printf("\t AC Dropout Tolerance\t%c %d ms\n",bdelim, pdata[16]);
+ b1 = pdata[17];
+ b2 = (b1 & 0x01);
+ if (b2) { /*predictive fail*/
+ if (b1 & 0x10 != 0) s1 = "DeassertFail ";
+ else s1 = "AssertFail ";
+ } else {
+ if (b1 & 0x10 != 0) s1 = "2pulses/rot ";
+ else s1 = "1pulse/rot ";
+ }
+ printf("\t Flags \t%c %s%s%s%s%s\n",bdelim,
+ (b2 ? "PredictFail " : ""),
+ ((b1 & 0x02 == 0) ? "" : "PowerFactorCorrect "),
+ ((b1 & 0x04 == 0) ? "" : "AutoswitchVolt "),
+ ((b1 & 0x08 == 0) ? "" : "Hotswap "), s1);
+ v5 = pdata[18] + ((pdata[19] & 0x0f) << 8);
+ v6 = (pdata[19] & 0xf0) >> 4;
+ printf("\t Peak Capacity \t%c %d W for %d s\n",bdelim, v5,v6);
+ if (pdata[20] == 0) {
+ printf("\t Combined Capacity\t%c not specified\n",bdelim);
+ } else {
+ b1 = pdata[20] & 0x0f;
+ b2 = (pdata[20] & 0xf0) >> 4;
+ v7 = pdata[21] + (pdata[22] << 8);
+ printf("\t Combined Capacity\t%c %d W (%s and %s)\n",
+ bdelim, v7,volt_desc(b1),volt_desc(b2));
+ }
+ if (b2) /*predictive fail*/
+ printf("\t Fan low threshold\t%c %d RPS\n",bdelim,pdata[23]);
+ break;
+ case 0x01: /*DC Output*/
+ b1 = pdata[0] & 0x0f;
+ b2 = (pdata[0] & 0x80 != 0);
+ printf("%sDC Output %c number %d\n",mystr,bdelim,b1);
+ printf("\t Standby power \t%c %s\n", bdelim,
+ (b2 ? "Yes" : "No"));
+ v1 = pdata[1] + (pdata[2] << 8);
+ printf("\t Nominal voltage \t%c %.2f V\n", bdelim, v1 / 100);
+ v2 = pdata[3] + (pdata[4] << 8);
+ v3 = pdata[5] + (pdata[6] << 8);
+ printf("\t Voltage deviation \t%c + %.2f V / - %.2f V\n",
+ bdelim, v3/100, v2/100);
+ v4 = pdata[7] + (pdata[8] << 8);
+ printf("\t Ripple and noise pk-pk \t%c %d mV\n", bdelim, v4);
+ v5 = pdata[9] + (pdata[10] << 8);
+ printf("\t Min current draw \t%c %.3f A\n", bdelim, v5/1000);
+ v6 = pdata[11] + (pdata[12] << 8);
+ printf("\t Max current draw \t%c %.3f A\n", bdelim, v6/1000);
+ break;
+ case 0x02: /*DC Load*/
+ b1 = pdata[0] & 0x0f;
+ printf("%sDC Load %c number %d\n",mystr,bdelim,b1);
+ v1 = pdata[1] + (pdata[2] << 8);
+ printf("\t Nominal voltage \t%c %.2f V\n", bdelim, v1 / 100);
+ v2 = pdata[3] + (pdata[4] << 8);
+ v3 = pdata[5] + (pdata[6] << 8);
+ printf("\t Min voltage allowed \t%c %.2f A\n", bdelim, v2);
+ printf("\t Max voltage allowed \t%c %.2f A\n", bdelim, v3);
+ v4 = pdata[7] + (pdata[8] << 8);
+ printf("\t Ripple and noise pk-pk \t%c %d mV\n", bdelim, v4);
+ v5 = pdata[9] + (pdata[10] << 8);
+ printf("\t Min current load \t%c %.3f A\n", bdelim, v5/1000);
+ v6 = pdata[11] + (pdata[12] << 8);
+ printf("\t Max current load \t%c %.3f A\n", bdelim, v6/1000);
+ break;
+ case 0x03: /*Management Access*/
+ b1 = pdata[0];
+ printf("%sManagemt Access %c %s ",mystr,bdelim,mgt_type(b1));
+ memcpy(mystr,&pdata[1],dlen-1);
+ mystr[dlen-1] = 0;
+ printf("%s\n",mystr);
+ break;
+ case 0x04: /*Base Compatibility*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ printf("%sBasic Compat %c %06x\n",mystr,bdelim,vend);
+ break;
+ case 0x05: /*Extended Compatibility*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ printf("%sExtended Compat %c %06x\n",mystr,bdelim,vend);
+ break;
+ case 0xC0: /*OEM Extension*/
+ vend = pdata[0] + (pdata[1] << 8) + (pdata[2] << 16);
+ if (vend == OEM_PICMG) {
+ printf("%sOEM PICMG %c \n", mystr,bdelim);
+ show_fru_picmg(pdata,dlen);
+ } else
+ printf("%sOEM Ext %c %06x %02x\n",
+ mystr,bdelim, vend, pdata[3]);
+ break;
+ default:
+ printf("%s %02x %c %02x\n", mystr,mtype,bdelim, pdata[0]);
+ break;
+ }
+}
+
+int
+show_fru(uchar sa, uchar frudev, uchar frutype)
+{
+ int ret = 0;
+ int i, j, n, sz;
+ uchar *pfru;
+ uchar lang;
+ TYPE_LEN tl;
+ char newstr[64];
+ int iaoff, ialen, bdoff, bdlen;
+ int proff, prlen, choff, chlen;
+ int moff, mlen;
+ char devstr[24];
+ char *pstr;
+ int extra = 0;
+
+ if (frubuf[0] == 0x80) { /* 0x80 = type for DIMMs (SPD) */
+ /* FRU Header: 80 08 07 0c 0a 01 48 00 (DIMM) */
+ sz = frubuf[0];
+ if (fdebug) {
+ printf("DIMM SPD Body (size=%d/%d): ",sz,sfru);
+ dumpbuf(frubuf,sfru);
+ }
+ show_spd(frubuf,sfru, frudev,frutype);
+ return(ret);
+ }
+
+ pstr = FruTypeString(frutype);
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s,%02x] ",pstr,frudev);
+ printf("%s%s FRU Size %c %d\n",devstr,pstr,bdelim,sfru);
+
+ /*
+ * FRU header:
+ * 0 = format_ver (01 is std, usu 0x80 if DIMM)
+ * 1 = internal_use offset
+ * 2 = chassis_info offset
+ * 3 = board_info offset (usu 6 fields)
+ * 4 = product_info offset (usu 8 fields)
+ * 5 = multirecord offset
+ * 6 = pad (00)
+ * 7 = header checksum (zero checksum)
+ * FRU Header: 01 01 02 09 13 00 00 e0 (BMC)
+ * FRU Header: 01 00 00 00 01 07 00 f7 (Power Cage)
+ */
+ pfru = &frubuf[0];
+ sz = 8; /*minimum for common header*/
+ for (i = 1; i < 6; i++) /* walk thru offsets */
+ if (frubuf[i] != 0) sz = frubuf[i] * 8;
+ if (sz > 8) /* if have at least one section */
+ sz += frubuf[sz+1] * 8; /* add length of last section */
+ /* Now, sz = size used, sfru = total available size */
+ if (sz > sfru) {
+ if (fdebug) {
+ printf("FRU Header: ");
+ for (i = 0; i < 8; i++) printf("%02x ",frubuf[i]);
+ printf("\n");
+ }
+ printf("FRU size out of bounds: available=%d used=%d\n",sfru,sz);
+ printf("Please apply the correct FRU/SDR diskette\n");
+ if (fdoanyway) {
+ extra = sz - sfru;
+ sz = sfru;
+ } else return(ERR_OTHER);
+ }
+ /* internal area offset, length */
+ iaoff = frubuf[1] * 8;
+ ialen = frubuf[iaoff + 1] * 8;
+ /* chassis area offset, length */
+ choff = frubuf[2] * 8;
+ chlen = frubuf[choff + 1] * 8;
+ /* board area offset, length */
+ bdoff = frubuf[3] * 8;
+ bdlen = frubuf[bdoff + 1] * 8;
+ /* product area offset, length */
+ proff = frubuf[4] * 8;
+ prlen = frubuf[proff + 1] * 8;
+ if (extra > 0) { /*do fixup of extra in product area*/
+ prlen -= extra;
+ j = prlen / 8;
+ prlen = j * 8; /*resolve to 8-byte bound*/
+ frubuf[proff + 1] = j;
+ }
+ /* multi-record area offset, length */
+ moff = frubuf[5] * 8;
+ mlen = 0;
+ if (moff > 0) {
+ for (i = moff; i < sfru; ) {
+ j = 5 + frubuf[i+2];
+ mlen += j;
+ if (frubuf[i+1] & 0x80) break;
+ i += j;
+ }
+ }
+
+ if (fdebug) {
+ printf("FRU Header: ");
+ for (i = 0; i < 8; i++) printf("%02x ",frubuf[i]);
+ printf("\n");
+ printf("FRU Body (size=%d/%d): ",sz,sfru);
+ dumpbuf(frubuf,sfru);
+ printf("header, len=%d, cksum0 = %02x, cksum1 = %02x\n",
+ 8,frubuf[7],calc_cksum(&frubuf[0],7));
+ printf("internal off=%d, len=%d, cksum = %02x\n",
+ iaoff,ialen,calc_cksum(&frubuf[iaoff],ialen-1));
+ printf("chassis off=%d, len=%d, cksum = %02x\n",
+ choff,chlen,calc_cksum(&frubuf[choff],chlen-1));
+ printf("board off=%d, len=%d, cksum = %02x\n",
+ bdoff,bdlen,calc_cksum(&frubuf[bdoff],bdlen-1));
+ printf("prod off=%d, len=%d, cksum = %02x\n",
+ proff,prlen,calc_cksum(&frubuf[proff],prlen-1));
+ /* Multi-record area */
+ printf("multi off=%d, len=%d, fru sz=%d\n", moff,mlen,sz);
+ } /*endif fdebug, show header*/
+
+ if (choff != 0) {
+ /* show Chassis area fields */
+ pfru = &frubuf[choff];
+ lang = 25; /* English */
+ ctype = pfru[2]; /*chassis type*/
+ if (fdebug) printf("ctype=%x\n",ctype);
+ if (ctype >= MAX_CTYPE) ctype = MAX_CTYPE - 1;
+ printf("%s%s%c %s\n",devstr, ctype_hdr,bdelim,ctypes[ctype]);
+ pfru += 3; /* skip chassis header */
+ for (i = 0; i < NUM_CHASSIS_FIELDS; i++)
+ {
+ if (pfru[0] == FRU_END) break; /*0xC1 = end of FRU area*/
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],chassis[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ if (i == 2) { /* OEM field for chassis_name */
+ chassis_offset = (int)(pfru - frubuf);
+ chassis_len = tl.len;
+ if (fdebug) printf("chassis oem dtype=%d lang=%d len=%d\n",
+ tl.type,lang,tl.len);
+ }
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, chassis[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug) printf("num Chassis fields = %d\n",i);
+ }
+
+ if (bdoff != 0) {
+ long nMin, nSec;
+ time_t tsec;
+ /* show Board area fields */
+ pfru = &frubuf[bdoff];
+ lang = pfru[2];
+ /* Decode board mfg date-time (num minutes since 1/1/96) */
+ nMin = pfru[3] + (pfru[4] << 8) + (pfru[5] << 16);
+ /* 13674540 min from 1/1/70 to 1/1/96 */
+ nSec = (nMin + 13674540) * 60;
+ tsec = (time_t)(nSec & 0x0ffffffff);
+ // fmt_time(tsec,newstr,sizeof(newstr));
+ printf("%sBoard Mfg DateTime %c %s",devstr,bdelim,ctime(&tsec));
+ pfru += 6; /* skip board header */
+ for (i = 0; i < NUM_BOARD_FIELDS; i++)
+ {
+ if (pfru[0] == FRU_END) break; /*0xC1 = end*/
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],board[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, board[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug) printf("num Board fields = %d\n",i);
+ }
+
+ if (proff != 0) {
+ /* show Product area fields */
+ pfru = &frubuf[proff];
+ maxprod = pfru[1] * 8;
+ lang = pfru[2];
+ pfru += 3; /* skip product header */
+ for (i = 0; i < NUM_PRODUCT_FIELDS; i++)
+ {
+ if (*pfru == FRU_END) { /*0xC1 = end*/
+ /* Wart for known Kontron 1-byte Product Version anomaly. */
+ if ((vend_id == VENDOR_KONTRON) && (i == 3)) ;
+ else break;
+ }
+ if (*pfru == 0) *pfru = FRU_EMPTY_FIELD; /* fix a broken table */
+ if (!ValidTL(pfru[0]))
+ printf(" ERROR - Invalid Type/Length %02x for %s\n",
+ pfru[0],product[i]);
+ tl.type = (pfru[0] & FRU_TYPE_MASK) >> 6;
+ tl.len = pfru[0] & FRU_LEN_MASK;
+ n = (int)(pfru - frubuf);
+ prodarea[i].offset = n;
+ prodarea[i].len = tl.len;
+ memcpy(prodarea[i].tag, &frubuf[n+1] ,tl.len);
+ pfru++;
+ {
+ newstr[0] = 0;
+ decode_string(tl.type,lang,pfru,tl.len,newstr,sizeof(newstr));
+ printf("%s%s%c %s\n",devstr, product[i],bdelim,newstr);
+ }
+ pfru += tl.len;
+ }
+ if (fdebug)
+ printf("num Product fields = %d, last=%x, max = %d\n",
+ i,*pfru,maxprod );
+ product_num = i; /*save number of existing product fields*/
+ if (*pfru == 0x00) *pfru = FRU_END; /* insert end char if broken */
+ }
+
+ if (moff != 0)
+ {
+ /* multi-record area may contain several record headers
+ * 0 = record type id
+ * 1 = 0x02 or 0x80 if End-of-List
+ * 2 = record len
+ * 3 = record chksum
+ * 4 = header chksum
+ */
+ pfru = &frubuf[moff];
+ j = moff;
+ for (i = 0; j < sz; i++)
+ {
+ n = pfru[2]; /* len of this record */
+ show_fru_multi(devstr,i,pfru[0],&pfru[5],n);
+ j += (5 + n);
+ if (pfru[1] & 0x80) j = sz; /*0x80 = end of list*/
+ pfru += (5 + n);
+ }
+ }
+
+ if ((frudev == 0) && (sa == bmc_sa)) {
+ char *s;
+ printf("%sSystem GUID %c ",devstr,bdelim);
+ for (i=0; i<16; i++) {
+ if ((i == 4) || (i == 6) || (i == 8) || (i == 10)) s = "-";
+ else s = "";
+ printf("%s%02x",s,guid[i]);
+ }
+ printf("\n");
+ }
+ return(ret);
+}
+
+static int
+write_fru_data(uchar id, ushort offset, uchar *data, int dlen, char fdebug)
+{
+ int ret = -1;
+ int chunk;
+ ushort fruoff;
+ uchar req[25];
+ uchar resp[16];
+ int sresp;
+ uchar cc;
+ int i, j;
+
+ /* Write the buffer in small 16-byte (FRUCHUNK_SZ) chunks */
+ req[0] = id; /* FRU Device ID (fruid) */
+ fruoff = offset;
+ chunk = FRUCHUNK_SZ;
+ for (i = 0; i < dlen; i += chunk) {
+ req[1] = fruoff & 0x00ff;
+ req[2] = (fruoff & 0xff00) >> 8;
+ if ((i + chunk) > dlen) chunk = dlen - i;
+ memcpy(&req[3],&data[i],chunk);
+ if (fdebug) {
+ printf("write_fru_data[%d] (len=%d): ",i,chunk+3);
+ for (j = 0; j < chunk+3; j++) printf("%02x ",req[j]);
+ printf("\n");
+ }
+ sresp = sizeof(resp);
+ ret = ipmi_cmd_mc(WRITE_FRU_DATA,req,(uchar)(chunk+3),resp,&sresp,
+ &cc,fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc & 0x00ff;
+ if (fdebug && ret == 0)
+ printf("write_fru_data[%d]: %d bytes written\n",i,resp[0]);
+ if (ret != 0) break;
+ fruoff += chunk;
+ }
+ return(ret);
+}
+
+/*
+ * write_product
+ * Updates the FRU Product area only.
+ * Note that this function will always provide >=8 product fields,
+ * even if the original had less than 8.
+ * inputs: prodnew = array of new strings to write
+ * frubuf = contains existing FRU data
+ * newdata = new product area buffer, malloc'd
+ * outputs: returns 0 if successful
+ */
+int
+write_product(void)
+{
+ int ret = -1;
+ uchar req[25];
+ uchar resp[16];
+ int sresp;
+ uchar cc;
+ ushort fruoff;
+ int alen, clen;
+ int snlen, verlen;
+ uchar *pfru0;
+ uchar *pfru;
+ uchar *pnew;
+ int i, j, k, n, plen, newlen, max, plimit;
+ int chas_offset;
+ int prod_offset;
+ int mult_offset, mult_len;
+ uchar chksum;
+ int chunk;
+
+ chas_offset = frubuf[2] * 8; // offset of chassis data
+ prod_offset = frubuf[4] * 8; // offset of product data
+ plen = frubuf[prod_offset+1] * 8; // length of product data
+ mult_offset = frubuf[5] * 8;
+ mult_len = 0;
+ if (mult_offset > 0) {
+ for (i = mult_offset; i < sfru; ) {
+ mult_len += (5 + frubuf[i+2]);
+ if (frubuf[i+1] & 0x80) break;
+ i = mult_len;
+ }
+ }
+ /* Check if asset tag will fit in product data area of FRU. */
+ if (fdebug)
+ printf("write_product: fru[4,p]=[%02x,%02x] prod_off=%d, plen=%d\n",
+ frubuf[4],frubuf[prod_offset+1],prod_offset,plen);
+ if (plen > sfru) return ERR_LENMAX; // product bigger than buffer
+ if (prodnew[IPROD_ASSET].len > plen) return ERR_LENMAX;
+ /* if asset bigger than product data, error. */
+ /* asset comes after sernum, so this check works for both */
+
+ newdata = malloc(sfru); /* but should not need more than plen bytes */
+ if (newdata == NULL) return(get_errno());
+ memset(newdata,0,sfru);
+ pnew = &newdata[0];
+ /* Set pointer to start of chassis area */
+ pfru = &frubuf[chas_offset];
+
+ /* Product Area Header (3 bytes):
+ [0] = 0x01; * format ver 1 *
+ [1] = 0x0a; *product area size (in 8-byte mult)*
+ [2] = 0x00; *lang=english *
+ Usually max product area is 3 + 8*32 = 259 mod 8 = 264.
+ */
+ pfru0 = &frubuf[prod_offset];
+ pfru = &frubuf[prod_offset];
+ j = 3;
+ memcpy(pnew,pfru,j);
+ pfru += j;
+ pnew += j;
+ n = j;
+ if (mult_offset > 0) plimit = plen;
+ else plimit = sfru - prod_offset; /*plen can expand*/
+
+ for (i = 0; i < NUM_PRODUCT_FIELDS; i++)
+ {
+ j = prodarea[i].len; /*new len*/
+ k = pfru[0] & FRU_LEN_MASK; /*old len*/
+ if (k == 1) { /*was 0xC1 FRU_END*/
+ if ((vend_id == VENDOR_KONTRON) && (i == 3) && (j == 1)) {
+ /* fix Kontron 1-byte Version */
+ prodarea[i].tag[1] = ' ';
+ j++;
+ } else
+ k = 0;
+ }
+ /* check for product area overflow */
+ if (n + 2 >= plimit) {
+ if (fdebug) printf("Field %d is at %d, beyond product area size %d\n",
+ i+1,n+2,plimit);
+ break;
+ } else if ((n + 1 + j) >= plimit) {
+ if (fdebug) printf("Field %d at %d + %d, truncated, product size %d\n",
+ i+1,n+1,j,plimit);
+ j = 0;
+ }
+ pnew[0] = (j | FRU_TYPE_MASK); /*add type=3 to len*/
+ memcpy(&pnew[1],prodarea[i].tag,j);
+ if (fdebug) {
+ printf("i=%d frubuf[%d]: %02x %02x %02x, j=%d k=%d n=%d\n",
+ i,(pfru-frubuf),pfru[0],pfru[1],pfru[2],j,k,n);
+ if (i >= product_num)
+ printf("Field %d is beyond existing %d fields\n",i+1,product_num);
+ }
+ pnew += j + 1;
+ pfru += k + 1;
+ n += j + 1;
+ }
+
+ // n = (int)(pnew - newdata); /*new product area index*/
+ k = (int)(pfru - pfru0); /*old product area index*/
+ if (mult_offset > 0) /* do not expand if multi-record area there */
+ max = plen - k;
+ else /* nothing else, can expand product area, up to sfru */
+ max = sfru - (k + prod_offset);
+ if (fdebug)
+ printf("frubuf[%d]: %02x %02x %02x, j=%d k=%d n=%d remainder=%d\n",
+ (pfru-frubuf),pfru[0],pfru[1],pfru[2],j,k,n,max);
+ if (max < 0) max = 0;
+ /* copy trailing fru data from saved copy */
+ for (i = 0; i < max; i++) {
+ pnew[i] = pfru[i];
+ if (pfru[i] == FRU_END) { i++; break; } /*0xC1*/
+ }
+ if (i == max) { /*never found 0xC1 FRU_END*/
+ pnew[0] = FRU_END; /*mark this trailing field as empty*/
+ i = 1;
+ }
+ newlen = n + i;
+ if (fdebug) printf("newbuf[%d]: %02x %02x %02x, j=%d newlen=%d plen=%d\n",
+ n,pnew[0],pnew[1],pnew[2],j,newlen,plen);
+
+ /* round up to next 8-byte boundary */
+ /* need one more byte for checksum, so if j=0, add 8 anyway */
+ j = 8 - (newlen % 8);
+ for (i = 0; i < j; i++) newdata[newlen++] = 0;
+ if (newlen < plen) newlen = plen; /* don't shrink the product area */
+ newdata[1] = newlen / 8; // set length of product data
+
+ /* include new checksum (calc over Product area) */
+ chksum = calc_cksum(&newdata[0],newlen-1);
+ newdata[newlen-1] = chksum;
+
+ if (fdebug) {
+ printf("old prod_area buffer (%d):",plen);
+ dumpbuf(&frubuf[prod_offset],plen);
+ printf("new prod_area buffer (%d):",newlen);
+ dumpbuf(newdata,newlen);
+ }
+ if (prod_offset + newlen >= sfru) return ERR_LENMAX;
+ if ((mult_offset > 0) && (newlen > plen)) return ERR_LENMAX;
+#ifdef TEST
+ newlen = 0; /*don't actually write the new data, if testing*/
+#endif
+
+ ret = write_fru_data(g_fruid, prod_offset, newdata, newlen, fdebug);
+ return(ret);
+}
+
+#define CHUNKSZ 16
+#define LAST_REC 0xffff
+#define STR_OFF 16
+
+int get_sdr(ushort recid, ushort resid, ushort *recnext,
+ uchar *sdr, int *slen, uchar *pcc)
+{
+ uchar idata[6];
+ uchar rdata[64];
+ int sresp;
+ ushort cmd;
+ uchar cc = 0;
+ int len = 0;
+ int rc;
+
+ idata[0] = resid & 0x00ff;
+ idata[1] = (resid & 0xff00) >> 8;
+ idata[2] = recid & 0x00ff;
+ idata[3] = (recid & 0xff00) >> 8;
+ idata[4] = 0; /*offset*/
+ idata[5] = CHUNKSZ; /*bytes to read*/
+ if (fdevsdrs) cmd = GET_DEVICE_SDR;
+ else cmd = GET_SDR;
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] ret = %d cc = %x sresp = %d\n",
+ recid,rc,cc,sresp);
+ if (rc == 0 && cc == 0xCA) {
+ idata[5] = 8; /*bytes to read*/
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] ret = %d cc = %x sresp = %d\n",
+ recid,rc,cc,sresp);
+ }
+ *pcc = cc;
+ if (rc == 0 && cc == 0) {
+ *recnext = rdata[0] + (rdata[1] << 8);
+ memcpy(sdr,&rdata[2],sresp-2);
+ *slen = sdr[6] + 5; /*get actual SDR size*/
+ len = sresp-2;
+ /* if an SDR locator record, get the rest of it. */
+ if (sdr [3] == 0x11 || sdr[3] == 0x12)
+ if (*slen > CHUNKSZ) {
+ idata[0] = resid & 0x00ff;
+ idata[1] = (resid & 0xff00) >> 8;
+ idata[2] = recid & 0x00ff;
+ idata[3] = (recid & 0xff00) >> 8;
+ idata[4] = CHUNKSZ; /*offset*/
+ idata[5] = *slen - CHUNKSZ; /*bytes to read*/
+ sresp = sizeof(rdata);
+ rc = ipmi_cmd_mc(cmd, idata, 6, rdata, &sresp,&cc, fdebug);
+ if (fdebug) printf("get_sdr[%x] 2nd ret=%d cc=%x sresp=%d\n",
+ recid,rc,cc,sresp);
+ if (rc == 0 && cc == 0) {
+ sresp -= 2;
+ memcpy(&sdr[len],&rdata[2],sresp);
+ len += sresp;
+ }
+ }
+ *slen = len;
+ }
+ return(rc);
+}
+
+void show_loadfru_error(uchar sa, uchar fruid, int ret)
+{
+ if (ret == 0) return;
+ switch(ret) {
+ case 0x081: printf("\tFRU(%x,%x) device busy\n",sa,fruid); break;
+ case 0x0C3: printf("\tFRU(%x,%x) timeout, not found\n",sa,fruid); break;
+ case 0x0CB: printf("\tFRU(%x,%x) not present\n",sa,fruid); break;
+ default: printf("load_fru(%x,%x) error = %d (0x%x)\n",
+ sa,fruid,ret,ret);
+ break;
+ }
+ return;
+}
+
+#ifdef METACOMMAND
+int i_ifruset(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret;
+ int c;
+ char DevRecord[16];
+ ushort recid;
+ ushort nextid;
+ ushort rsvid;
+ uchar sdr[40];
+ char biosver[80];
+ uchar cc;
+ uchar sa;
+ uchar fruid = 0;
+ uchar frutype = 0;
+ int len, i;
+ char *s1;
+ FILE *fp;
+
+ printf("%s: version %s\n",progname,progver);
+ parse_lan_options('V',"4",0); /*request admin priv by default*/
+ while ( (c = getopt( argc, argv,"a:bcd:h:i:f:m:n:o:p:r:s:u:v:xyz:T:V:J:EYF:P:N:R:U:Z:?")) != EOF )
+ switch(c) {
+ case 'x': fdebug = 1; break;
+ case 'y': fdoanyway = 1; break;
+ case 'b': fonlybase = 1;
+ g_frutype = 0x07; break;
+ case 'c': fcanonical = 1; bdelim = BDELIM; break;
+#ifdef TEST
+ case 'h':
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ strncpy(chassis_name,optarg,len);
+ if (len == 1) { /* add a space */
+ chassis_name[1] = ' ';
+ chassis_name[2] = 0;
+ }
+ }
+ break;
+#else
+ case 'h': fonlyhsc = 1; /* can use -m00c000s instead */
+ g_frutype = 0x0f; break;
+#endif
+ case 'a':
+ fwritefru |= 0x01;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_ASSET].tag,optarg,len);
+ prodnew[IPROD_ASSET].len = len;
+ }
+ break;
+ case 'f':
+ fwritefru |= 0x04;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_FRUID].tag,optarg,len);
+ prodnew[IPROD_FRUID].len = len;
+ }
+ break;
+ case 'n':
+ fwritefru |= 0x20;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_NAME].tag,optarg,len);
+ prodnew[IPROD_NAME].len = len;
+ }
+ break;
+ case 'o':
+ fwritefru |= 0x10;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_OEM].tag,optarg,len);
+ prodnew[IPROD_OEM].len = len;
+ }
+ break;
+ case 'p':
+ fwritefru |= 0x40;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_PART].tag,optarg,len);
+ prodnew[IPROD_PART].len = len;
+ }
+ break;
+ case 'u':
+ fwritefru |= 0x80;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_MANUF].tag,optarg,len);
+ prodnew[IPROD_MANUF].len = len;
+ }
+ break;
+ case 's':
+ fwritefru |= 0x02;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_SERNUM].tag,optarg,len);
+ prodnew[IPROD_SERNUM].len = len;
+ }
+ break;
+ case 'v':
+ fwritefru |= 0x08;
+ if (optarg) {
+ len = strlen(optarg);
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ /* if (len == 1), handle it in write_product() */
+ strncpy(prodnew[IPROD_VERS].tag,optarg,len);
+ prodnew[IPROD_VERS].len = len;
+ }
+ break;
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'z': /* set local IPMB MC sa */
+ sa = htoi(&optarg[0]); /*device slave address*/
+ ipmi_set_mymc(g_bus, sa, g_lun,ADDR_IPMB);
+ bmc_sa = sa;
+ case 'i': fonlybase = 1; /*specify a fru id*/
+ if (strncmp(optarg,"0x",2) == 0) g_fruid = htoi(&optarg[2]);
+ else g_fruid = htoi(optarg);
+ printf("Using FRU ID 0x%02x\n",g_fruid);
+ break;
+ case 'd': fdump = 1; /*dump fru to a file*/
+ binfile = optarg;
+ break;
+ case 'r': frestore = 1; /*restore fru from a file*/
+ fwritefru = 0x100;
+ binfile = optarg;
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-bcimx -unpvsafo -NUPREFTVY]\n",progname);
+ printf(" -u manu Sets Product Manufacturer (0)\n");
+ printf(" -n name Sets Product Name (1)\n");
+ printf(" -p part Sets Product Part Number (2)\n");
+ printf(" -v vers Sets Product Version (3)\n");
+ printf(" -s snum Sets Product Serial Num (4)\n");
+ printf(" -a tag Sets Product Asset Tag (5)\n");
+ printf(" -f fru Sets Product FRU File ID (6)\n");
+ printf(" -o oem Sets Product OEM Field (7)\n");
+ // printf(" -h chname Sets the Chassis Name \n");
+ printf(" -b Only show Baseboard FRU data\n");
+ printf(" -c show Canonical, delimited output\n");
+ printf(" -d Dump FRU to a file\n");
+ printf(" -r Restore FRU from a file\n");
+ printf(" -i 00 Get/Set a specific FRU ID\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -x Display extra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ // if (is_remote() && fwritefru) parse_lan_options('V',"4",0);
+
+ ret = ipmi_getdeviceid( DevRecord, sizeof(DevRecord),fdebug);
+ if (ret == 0) {
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = DevRecord[4] & 0x0f;
+ ipmi_min = DevRecord[4] >> 4;
+ vend_id = DevRecord[6] + (DevRecord[7] << 8) + (DevRecord[8] << 16);
+ prod_id = DevRecord[9] + (DevRecord[10] << 8);
+ show_devid( DevRecord[2], DevRecord[3], ipmi_maj, ipmi_min);
+ if ((DevRecord[1] & 0x80) == 0x80) fdevsdrs = 1;
+ if (vend_id == VENDOR_NEC) fdevsdrs = 0;
+ else if (vend_id == VENDOR_INTEL) {
+ if (prod_id == 0x003E) {
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ }
+ }
+ } else {
+ goto do_exit;
+ }
+
+ ret = ipmi_getpicmg( DevRecord, sizeof(DevRecord),fdebug);
+ if (ret == 0) fpicmg = 1;
+ if ((vend_id == VENDOR_INTEL) && (!fpicmg))
+ fdevsdrs = 0; /* override, use SDR repository*/
+ if (fdebug) printf("bmc_sa = %02x fdevsdrs = %d\n",bmc_sa,fdevsdrs);
+
+ if (fset_mc) {
+ /* target a specific MC via IPMB (usu a picmg blade) */
+ if (fdebug) printf("set_mc: %02x:%02x:%02x type=%d\n",
+ g_bus,g_sa,g_lun,g_addrtype);
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ fonlybase = 1; /*only show this MC*/
+ } else {
+ g_sa = bmc_sa; /* BMC_SA = 0x20 */
+ }
+ if (g_frutype == 0) {
+ g_frutype = 0x01; /* other = "Component" */
+ }
+
+ if (!fonlybase && !fonlyhsc) {
+ /* loop thru SDRs to find FRU devices */
+#ifdef NOT_YET
+ { /* get SDR Repository Info (needs to be copied here)*/
+ ret = GetSDRRepositoryInfo(&j,&fdevsdrs);
+ if (fdebug) printf("GetSDRRepositoryInfo: ret=%x nSDRs=%d\n",ret,j);
+ }
+#endif
+ { /* reserve the SDR repository */
+ uchar resp[16];
+ int sresp;
+ uchar cc;
+ ushort cmd;
+ sresp = sizeof(resp);
+ if (fdevsdrs) cmd = RESERVE_DEVSDR_REP;
+ else cmd = RESERVE_SDR_REP;
+ ret = ipmi_cmd_mc(cmd, NULL, 0, resp, &sresp, &cc, 0);
+ if (fdebug) printf("ipmi_cmd RESERVE status = %d, cc = %x\n",ret,cc);
+ rsvid = resp[0] + (resp[1] << 8);
+ }
+ recid = 0;
+ while (recid != LAST_REC)
+ {
+ char idstr[32];
+ int ilen;
+
+ len = sizeof(sdr); /*sizeof(sdr); get 32 sdr bytes*/
+ ret = get_sdr(recid,rsvid,&nextid,sdr,&len,&cc);
+ if ((ret != 0) || (cc != 0)) {
+ printf("SDR[%04x] error %d ccode = %x\n",recid,ret,cc);
+ break;
+ }
+ fgetfru = 0;
+ if ((sdr[3] == 0x11) || (sdr[3] == 0x12)) /* SDR FRU or IPMB type */
+ {
+ if (len > STR_OFF) {
+ ilen = len - STR_OFF;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[STR_OFF],ilen);
+ idstr[ilen] = 0;
+ } else idstr[0] = 0;
+ sa = sdr[5]; /* usu 0x20 for bmc_sa */
+ /* Get its FRU data */
+ if ((sdr[3] == 0x11) && (sdr[7] & 0x80)) { /* FRU SDRs */
+ /* It is a logical FRU device */
+ if (fcanonical)
+ printf("SDR[%04x] FRU %c %s\n", recid, bdelim, idstr);
+ else
+ printf("SDR[%04x] FRU %02x %02x %02x %02x %s\n", recid,
+ sdr[5],sdr[6],sdr[12],sdr[13],idstr);
+ fruid = sdr[6];
+ frutype = sdr[12];
+ if (sa == bmc_sa && fruid == 0) /*do this below*/;
+ else
+ switch(sdr[12]) /*FRU entity id*/
+ {
+ case 0x0a: /*Power Supply*/
+ case 0x20: /*DIMM*/
+ case 0x15: /*Power Cage*/
+ default:
+ fgetfru = 1;
+ break;
+ }
+ } else if (sdr[3] == 0x12) { /* IPMB SDRs (DLRs for MCs) */
+ if (fcanonical)
+ printf("SDR[%04x] IPMB %c %s\n", recid, bdelim, idstr);
+ else
+ printf("SDR[%04x] IPMB %02x %02x %02x %02x %s\n", recid,
+ sdr[5],sdr[6],sdr[12],sdr[13],idstr);
+ fruid = 0; /*every MC must have fruid 0*/
+ frutype = sdr[12];
+ if (sa == bmc_sa && fruid == 0) { /*do bmc_sa,0 below*/
+ if (fdebug) printf("do bmc_sa %02x below\n",sa);
+ g_frutype = frutype;
+ } else if (frutype == 0x2e) { /*skip ME*/
+ if (fdebug) printf("skipping ME sa %02x, %02x\n",sa,fruid);
+ } else if (sa == 0x28) { /*do nothing for Bridge Ctlr sa=0x28*/
+ if (fdebug) printf("skipping IPMB sa %02x, %02x\n",sa,fruid);
+ } else if (sa == 0xC0) { /* HotSwap Backplane (sa=0xC0) */
+ /* Note: Loading sa 0xC0 over ipmi lan gives a timeout
+ * error, but it works locally. */
+ fgetfru = 1;
+ } else { /* other misc sa,fruid */
+ fgetfru = 1;
+ }
+ }
+ if (fgetfru) {
+ uchar adrtype;
+ adrtype = g_addrtype;
+ if (fdebug) printf("set_mc %02x:%02x:%02x type=%d fruid=%02x\n",
+ g_bus,sa,g_lun,adrtype,fruid);
+ ipmi_set_mc(g_bus, sa, g_lun,adrtype);
+ ret = load_fru(sa,fruid,frutype);
+ if (ret != 0) {
+ show_loadfru_error(sa,fruid,ret);
+ free_fru();
+ } else {
+ ret = show_fru(sa,fruid,frutype);
+ if (ret != 0) printf("show_fru error = %d\n",ret);
+ free_fru();
+ }
+ ipmi_restore_mc();
+ }
+ } /*endif FRU/IPMB SDR */
+ recid = nextid;
+ } /*end while sdrs*/
+ } /*endif not fonlybase*/
+
+ /* load the FRU data for Baseboard (address 0x20) */
+ printf("\n");
+ sa = g_sa; /* bmc_sa = BMC_SA = 0x20 */
+ if (fonlyhsc) { sa = 0xC0; g_addrtype = ADDR_SMI;
+ ipmi_set_mc(g_bus,sa,g_lun,g_addrtype);
+ }
+ if (g_addrtype == ADDR_IPMB)
+ ipmi_set_mc(g_bus,sa,g_lun,g_addrtype);
+ ret = load_fru(sa,g_fruid,g_frutype);
+ if (ret != 0) {
+ show_loadfru_error(sa,g_fruid,ret);
+ free_fru();
+ goto do_exit;
+ }
+
+ /* display the Baseboard FRU data */
+ ret = show_fru(sa,g_fruid,g_frutype);
+ if (ret != 0) printf("show_fru error = %d\n",ret);
+
+ if (!is_remote()) {
+ char devstr[24];
+ if (fcanonical) devstr[0] = 0; /*default is empty string*/
+ else sprintf(devstr,"[%s,%02x] ",FruTypeString(g_frutype),g_fruid);
+ i = get_BiosVersion(biosver);
+ if (i == 0)
+ printf("%sBIOS Version %c %s\n",devstr,bdelim,biosver);
+ }
+
+ if (fdump && ret == 0) {
+ /* Dump FRU to a binary file */
+ fp = fopen(binfile,"w");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ } else {
+ printf("Writing FRU size %d to %s ...\n",sfru,binfile);
+ len = fwrite(frubuf, 1, sfru, fp);
+ fclose(fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d writing file %s\n",ret,binfile);
+ } else ret = 0;
+ }
+ } else if (frestore) {
+ uchar cksum;
+ /* Restore FRU from a binary file */
+ fp = fopen(binfile,"r");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ } else {
+ ret = 0;
+ /* sfru and frubuf were set from load_fru above. */
+ len = fread(frubuf, 1, sfru, fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d reading file %s\n",ret,binfile);
+ sfru = 0; /*for safety*/
+ }
+ fclose(fp);
+ if (fdebug) {
+ printf("FRU buffer from file (%d):",sfru);
+ dumpbuf(frubuf,sfru);
+ }
+ /* Do some validation of the FRU buffer header */
+ cksum = calc_cksum(&frubuf[0],7);
+ if (fdebug)
+ printf("header, len=8, cksum0 = %02x, cksum1 = %02x\n",
+ frubuf[7],cksum);
+ if (frubuf[7] != cksum) {
+ printf("Not a valid FRU file\n");
+ ret = ERR_BAD_FORMAT;
+ free_fru();
+ }
+ if (ret == 0) { /*successfully read data*/
+ printf("Writing FRU size %d from %s ...\n",sfru,binfile);
+ ret = write_fru_data(g_fruid, 0, frubuf, sfru, fdebug);
+ free_fru();
+ if (ret != 0) printf("write_fru error %d (0x%02x)\n",ret,ret);
+ else { /* successful, show new data */
+ ret = load_fru(sa,g_fruid,g_frutype);
+ if (ret != 0) show_loadfru_error(sa,g_fruid,ret);
+ else ret = show_fru(sa,g_fruid,g_frutype);
+ free_fru();
+ }
+ }
+ }
+ } /*end-else frestore */
+ else if ((fwritefru != 0) && ret == 0) {
+ printf("\nWriting new product data (%s,%s,%s,%s,%s,%s,%s,%s) ...\n",
+ prodnew[0].tag, prodnew[1].tag, prodnew[2].tag,
+ prodnew[3].tag, prodnew[4].tag, prodnew[5].tag,
+ prodnew[6].tag, prodnew[7].tag);
+ for (i = 0; i < NUM_PRODUCT_FIELDS; i++) {
+ len = prodnew[i].len;
+ if (len > 0) {
+ if (len >= FIELD_LEN) len = FIELD_LEN - 1;
+ if (len == 1) {
+ prodnew[i].tag[1] = ' ';
+ len++;
+ }
+ prodarea[i].len = len;
+ memcpy(prodarea[i].tag,prodnew[i].tag,len);
+ }
+ }
+ ret = write_product();
+ free_fru();
+ if (ret != 0) printf("write_product error %d (0x%02x)\n",ret,ret);
+ else { /* successful, show new data */
+ ret = load_fru(sa,g_fruid,g_frutype);
+ if (ret != 0) show_loadfru_error(sa,g_fruid,ret);
+ else ret = show_fru(sa,g_fruid,g_frutype);
+ free_fru();
+ }
+ }
+ else
+ free_fru();
+
+do_exit:
+ ipmi_close_();
+ show_outcome(progname,ret);
+ return(ret);
+}
+
+/* end ifruset.c */
diff --git a/util/ifwum.c b/util/ifwum.c
new file mode 100644
index 0000000..1e7d547
--- /dev/null
+++ b/util/ifwum.c
@@ -0,0 +1,1697 @@
+/*
+ * ifwum.c
+ * Handle firmware update manager IPMI command functions
+ *
+ * Change history:
+ * 08/20/2010 ARCress - ported from ipmitool/lib/ipmi_fwum.c
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2004 Kontron Canada, Inc. All Rights Reserved.
+ *
+ * Base on code from
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#include "getopt.h"
+#elif defined(HPUX)
+/* getopt defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#ifdef LINUX
+#include <unistd.h>
+#endif
+#include "ipmicmd.h"
+#include "ifwum.h"
+
+/******************************************************************************
+* HISTORY
+* ===========================================================================
+* 2007-01-11 [FI]
+* - Incremented to version 1.3
+* - Added lan packet size reduction mechanism to workaround fact
+* that lan iface will not return C7 on excessive length
+*
+*****************************************************************************/
+
+extern int verbose; /*see ipmilanplus.c*/
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+// extern int ipmi_sendrecv(struct ipmi_rq * req, uint8_t *rsp, int *rsp_len);
+extern char * get_mfg_str(uchar *rgmfg, int *pmfg); /*ihealth.c*/
+#ifndef HAVE_LANPLUS
+/* define these routines here if no lanplus/helper.c */
+extern uint16_t buf2short(uint8_t * buf); /*ipmilanplus.c*/
+// const char * val2str(uint16_t val, const struct valstr *vs);
+#endif
+
+#define VERSION_MAJ 1
+#define VERSION_MIN 3
+
+/* global variables */
+static char * progname = "ifwum";
+static char * progver = "1.3";
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+typedef enum eKFWUM_Task
+{
+ KFWUM_TASK_INFO,
+ KFWUM_TASK_STATUS,
+ KFWUM_TASK_DOWNLOAD,
+ KFWUM_TASK_UPGRADE,
+ KFWUM_TASK_START_UPGRADE,
+ KFWUM_TASK_ROLLBACK,
+ KFWUM_TASK_TRACELOG
+}tKFWUM_Task;
+
+typedef enum eKFWUM_BoardList
+{
+ KFWUM_BOARD_KONTRON_UNKNOWN = 0,
+ KFWUM_BOARD_KONTRON_5002 = 5002,
+}tKFWUM_BoardList;
+
+typedef enum eKFWUM_IanaList
+{
+ KFWUM_IANA_KONTRON = 15000,
+}tKFWUM_IanaList;
+
+typedef struct sKFWUM_BoardInfo
+{
+ tKFWUM_BoardList boardId;
+ tKFWUM_IanaList iana;
+}tKFWUM_BoardInfo;
+
+
+#define KFWUM_STATUS_OK 0
+#define KFWUM_STATUS_ERROR -1
+typedef int tKFWUM_Status;
+//typedef enum eKFWUM_Status
+//{
+// KFWUM_STATUS_OK,
+// KFWUM_STATUS_ERROR
+//}tKFWUM_Status;
+
+typedef enum eKFWUM_DownloadType
+{
+ KFWUM_DOWNLOAD_TYPE_ADDRESS = 0,
+ KFWUM_DOWNLOAD_TYPE_SEQUENCE,
+}tKFWUM_DownloadType;
+
+typedef enum eKFWUM_DownloadBuffferType
+{
+ KFWUM_SMALL_BUFFER_TYPE = 0,
+ KFUMW_BIG_BUFFER_TYPE
+}tKFWUM_DownloadBuffferType;
+
+typedef struct sKFWUM_InFirmwareInfo
+{
+ unsigned long fileSize;
+ unsigned short checksum;
+ unsigned short sumToRemoveFromChecksum;
+ /* Since the checksum is added in the bin
+ after the checksum is calculated, we
+ need to remove the each byte value. This
+ byte will contain the addition of both bytes*/
+ tKFWUM_BoardList boardId;
+ unsigned char deviceId;
+ unsigned char tableVers;
+ unsigned char implRev;
+ unsigned char versMajor;
+ unsigned char versMinor;
+ unsigned char versSubMinor;
+ unsigned char sdrRev;
+ tKFWUM_IanaList iana;
+}tKFWUM_InFirmwareInfo;
+
+typedef struct sKFWUM_SaveFirmwareInfo
+{
+ tKFWUM_DownloadType downloadType;
+ unsigned char bufferSize;
+ unsigned char overheadSize;
+}tKFWUM_SaveFirmwareInfo;
+
+#define KFWUM_SMALL_BUFFER 32 /* Minimum size (IPMB/IOL/old protocol) */
+#define KFWUM_BIG_BUFFER 32 /* Maximum size on KCS interface */
+
+#define KFWUM_OLD_CMD_OVERHEAD 6 /*3 address + 1 size + 1 checksum + 1 command*/
+#define KFWUM_NEW_CMD_OVERHEAD 4 /*1 sequence+ 1 size + 1 checksum + 1 command*/
+#define KFWUM_PAGE_SIZE 256
+
+static unsigned char fileName[512];
+static unsigned char firmBuf[1024*512];
+static tKFWUM_SaveFirmwareInfo saveFirmwareInfo;
+
+static void KfwumOutputHelp(void);
+static int KfwumMain(void * intf, tKFWUM_Task task);
+static tKFWUM_Status KfwumGetFileSize(unsigned char * pFileName,
+ unsigned long * pFileSize);
+static tKFWUM_Status KfwumSetupBuffersFromFile(unsigned char * pFileName,
+ unsigned long fileSize);
+static void KfwumShowProgress( const unsigned char * task,
+ unsigned long current, unsigned long total);
+static unsigned short KfwumCalculateChecksumPadding(unsigned char * pBuffer,
+ unsigned long totalSize);
+
+
+static tKFWUM_Status KfwumGetInfo(void * intf, unsigned char output,
+ unsigned char *pNumBank);
+static tKFWUM_Status KfwumGetDeviceInfo(void * intf,
+ unsigned char output, tKFWUM_BoardInfo * pBoardInfo);
+static tKFWUM_Status KfwumGetStatus(void * intf);
+static tKFWUM_Status KfwumManualRollback(void * intf);
+static tKFWUM_Status KfwumStartFirmwareImage(void * intf,
+ unsigned long length,unsigned short padding);
+static tKFWUM_Status KfwumSaveFirmwareImage(void * intf,
+ unsigned char sequenceNumber, unsigned long address,
+ unsigned char *pFirmBuf, unsigned char * pInBufLength);
+static tKFWUM_Status KfwumFinishFirmwareImage(void * intf,
+ tKFWUM_InFirmwareInfo firmInfo);
+static tKFWUM_Status KfwumUploadFirmware(void * intf,
+ unsigned char * pBuffer, unsigned long totalSize);
+static tKFWUM_Status KfwumStartFirmwareUpgrade(void * intf);
+
+static tKFWUM_Status KfwumGetInfoFromFirmware(unsigned char * pBuf,
+ unsigned long bufSize, tKFWUM_InFirmwareInfo * pInfo);
+static void KfwumFixTableVersionForOldFirmware(tKFWUM_InFirmwareInfo * pInfo);
+
+static tKFWUM_Status KfwumGetTraceLog(void * intf);
+
+tKFWUM_Status KfwumValidFirmwareForBoard(tKFWUM_BoardInfo boardInfo,
+ tKFWUM_InFirmwareInfo firmInfo);
+static void KfwumOutputInfo(tKFWUM_BoardInfo boardInfo,
+ tKFWUM_InFirmwareInfo firmInfo);
+
+
+/* ipmi_fwum_main - entry point for this ipmitool mode
+ *
+ * @intf: ipmi interface
+ * @arc : number of arguments
+ * @argv : point to argument array
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+int ipmi_fwum_main(void * intf, int argc, char ** argv)
+{
+ int rv = ERR_USAGE; /*1*/
+ printf("FWUM extension Version %d.%d\n", VERSION_MAJ, VERSION_MIN);
+ if ((!argc) || ( !strncmp(argv[0], "help", 4)))
+ {
+ KfwumOutputHelp();
+ }
+ else
+ {
+ if (!strncmp(argv[0], "info", 4))
+ {
+ rv = KfwumMain(intf, KFWUM_TASK_INFO);
+ }
+ else if (!strncmp(argv[0], "status", 6))
+ {
+ rv = KfwumMain(intf, KFWUM_TASK_STATUS);
+ }
+ else if (!strncmp(argv[0], "rollback", 8))
+ {
+ rv = KfwumMain(intf, KFWUM_TASK_ROLLBACK);
+ }
+ else if (!strncmp(argv[0], "download", 8))
+ {
+ if((argc >= 2) && (strlen(argv[1]) > 0))
+ {
+ /* There is a file name in the parameters */
+ if(strlen(argv[1]) < 512)
+ {
+ strcpy((char *)fileName, argv[1]);
+ printf("Firmware File Name : %s\n", fileName);
+
+ rv = KfwumMain(intf, KFWUM_TASK_DOWNLOAD);
+ }
+ else
+ {
+ fprintf(stderr,"File name must be smaller than 512 bytes\n");
+ }
+ }
+ else
+ {
+ fprintf(stderr,"A path and a file name must be specified\n");
+ }
+ }
+ else if (!strncmp(argv[0], "upgrade", 7))
+ {
+ if((argc >= 2) && (strlen(argv[1]) > 0))
+ {
+ /* There is a file name in the parameters */
+ if(strlen(argv[1]) < 512)
+ {
+ strcpy((char *)fileName, argv[1]);
+ printf("Upgrading using file name %s\n", fileName);
+ rv = KfwumMain(intf, KFWUM_TASK_UPGRADE);
+ }
+ else
+ {
+ fprintf(stderr,"File name must be smaller than 512 bytes\n");
+ }
+ }
+ else
+ {
+ rv = KfwumMain(intf, KFWUM_TASK_START_UPGRADE);
+ }
+
+ }
+ else if (!strncmp(argv[0], "tracelog", 8))
+ {
+ rv = KfwumMain(intf, KFWUM_TASK_TRACELOG);
+ }
+ else
+ {
+ printf("Invalid KFWUM command: %s\n", argv[0]);
+ }
+ }
+ return rv;
+}
+
+
+static void KfwumOutputHelp(void)
+{
+ printf("KFWUM Commands: info status download upgrade rollback tracelog\n");
+}
+
+
+/****************************************/
+/** private definitions and macros **/
+/****************************************/
+typedef enum eFWUM_CmdId
+{
+ KFWUM_CMD_ID_GET_FIRMWARE_INFO = 0,
+ KFWUM_CMD_ID_KICK_IPMC_WATCHDOG = 1,
+ KFWUM_CMD_ID_GET_LAST_ANSWER = 2,
+ KFWUM_CMD_ID_BOOT_HANDSHAKE = 3,
+ KFWUM_CMD_ID_REPORT_STATUS = 4,
+ KFWUM_CMD_ID_GET_FIRMWARE_STATUS = 7,
+ KFWUM_CMD_ID_START_FIRMWARE_UPDATE = 9,
+ KFWUM_CMD_ID_START_FIRMWARE_IMAGE = 0x0a,
+ KFWUM_CMD_ID_SAVE_FIRMWARE_IMAGE = 0x0b,
+ KFWUM_CMD_ID_FINISH_FIRMWARE_IMAGE = 0x0c,
+ KFWUM_CMD_ID_READ_FIRMWARE_IMAGE = 0x0d,
+ KFWUM_CMD_ID_MANUAL_ROLLBACK = 0x0e,
+ KFWUM_CMD_ID_GET_TRACE_LOG = 0x0f,
+ KFWUM_CMD_ID_STD_MAX_CMD,
+ KFWUM_CMD_ID_EXTENDED_CMD = 0xC0
+} tKFWUM_CmdId;
+
+
+
+/****************************************/
+/** global/static variables definition **/
+/****************************************/
+
+/****************************************/
+/** functions definition **/
+/****************************************/
+
+/*******************************************************************************
+*
+* Function Name: KfwumMain
+*
+* Description: This function implements the upload of the firware data
+* received as parameters.
+*
+* Restriction: Called only from main
+*
+* Input: unsigned char * pBuffer[] : The buffers
+* unsigned long bufSize : The size of the buffers
+*
+* Output: None
+*
+* Global: none
+*
+* Return: tIFWU_Status (success or failure)
+*
+*******************************************************************************/
+static int KfwumMain(void * intf, tKFWUM_Task task)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ tKFWUM_BoardInfo boardInfo;
+ tKFWUM_InFirmwareInfo firmInfo = { 0 };
+ unsigned long fileSize = 0;
+ static unsigned short padding;
+
+ if((status == KFWUM_STATUS_OK) && (task == KFWUM_TASK_INFO))
+ {
+ unsigned char notUsed;
+ if(verbose)
+ {
+ printf("Getting Kontron FWUM Info\n");
+ }
+ status = KfwumGetDeviceInfo(intf, 1, &boardInfo);
+ status = KfwumGetInfo(intf, 1, &notUsed);
+
+ }
+
+
+ if((status == KFWUM_STATUS_OK) && (task == KFWUM_TASK_STATUS))
+ {
+ if(verbose)
+ {
+ printf("Getting Kontron FWUM Status\n");
+ }
+ status = KfwumGetStatus(intf);
+ }
+
+ if( (status == KFWUM_STATUS_OK) && (task == KFWUM_TASK_ROLLBACK) )
+ {
+ status = KfwumManualRollback(intf);
+ }
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_DOWNLOAD)
+ )
+ )
+ {
+ status = KfwumGetFileSize(fileName, &fileSize);
+ if(status == KFWUM_STATUS_OK)
+ {
+ status = KfwumSetupBuffersFromFile(fileName, fileSize);
+ if(status == KFWUM_STATUS_OK)
+ {
+ padding = KfwumCalculateChecksumPadding(firmBuf, fileSize);
+ }
+ }
+ if(status == KFWUM_STATUS_OK)
+ {
+ status = KfwumGetInfoFromFirmware(firmBuf, fileSize, &firmInfo);
+ }
+ if(status == KFWUM_STATUS_OK)
+ {
+ status = KfwumGetDeviceInfo(intf, 0, &boardInfo);
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ status = KfwumValidFirmwareForBoard(boardInfo,firmInfo);
+ }
+
+ if (status == KFWUM_STATUS_OK)
+ {
+ unsigned char notUsed;
+ KfwumGetInfo(intf, 0, &notUsed);
+ }
+
+ KfwumOutputInfo(boardInfo,firmInfo);
+ }
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_DOWNLOAD)
+ )
+ )
+ {
+ status = KfwumStartFirmwareImage(intf, fileSize, padding);
+ }
+
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_DOWNLOAD)
+ )
+ )
+ {
+ status = KfwumUploadFirmware(intf, firmBuf, fileSize);
+ }
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_DOWNLOAD)
+ )
+ )
+ {
+ status = KfwumFinishFirmwareImage(intf, firmInfo);
+ }
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_DOWNLOAD)
+ )
+ )
+ {
+ status = KfwumGetStatus(intf);
+ }
+
+ if(
+ (status == KFWUM_STATUS_OK) &&
+ (
+ (task == KFWUM_TASK_UPGRADE) || (task == KFWUM_TASK_START_UPGRADE)
+ )
+ )
+ {
+ status = KfwumStartFirmwareUpgrade(intf);
+ }
+
+ if((status == KFWUM_STATUS_OK) && (task == KFWUM_TASK_TRACELOG))
+ {
+ status = KfwumGetTraceLog(intf);
+ }
+
+ return(status);
+}
+
+/* KfwumGetFileSize - gets the file size
+ *
+ * @pFileName : filename ptr
+ * @pFileSize : output ptr for filesize
+ *
+ * returns KFWUM_STATUS_OK or KFWUM_STATUS_ERROR
+ */
+static tKFWUM_Status KfwumGetFileSize(unsigned char * pFileName,
+ unsigned long * pFileSize)
+{
+ tKFWUM_Status status = KFWUM_STATUS_ERROR;
+ FILE * pFileHandle;
+
+ pFileHandle = fopen((const char *)pFileName, "rb");
+
+ if(pFileHandle)
+ {
+ if(fseek(pFileHandle, 0L , SEEK_END) == 0)
+ {
+ *pFileSize = ftell(pFileHandle);
+
+ if( *pFileSize != 0)
+ {
+ status = KFWUM_STATUS_OK;
+ }
+ }
+ fclose(pFileHandle);
+ }
+
+ return(status);
+}
+
+/* KfwumSetupBuffersFromFile - small buffers are used to store the file data
+ *
+ * @pFileName : filename ptr
+ * unsigned long : filesize
+ *
+ * returns KFWUM_STATUS_OK or KFWUM_STATUS_ERROR
+ */
+#define MAX_FW_BUFFER_SIZE 1024*16
+static tKFWUM_Status KfwumSetupBuffersFromFile(unsigned char * pFileName,
+ unsigned long fileSize)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ FILE * pFileHandle;
+
+ pFileHandle = fopen((const char *)pFileName, "rb");
+
+ if(pFileHandle)
+ {
+ int count = fileSize / MAX_FW_BUFFER_SIZE;
+ int modulus = fileSize % MAX_FW_BUFFER_SIZE;
+ int qty =0;
+
+ rewind(pFileHandle);
+
+ for(qty=0;qty<count;qty++)
+ {
+ KfwumShowProgress((const unsigned char *)"Reading Firmware from File", qty, count );
+ if(fread(&firmBuf[qty*MAX_FW_BUFFER_SIZE], 1, MAX_FW_BUFFER_SIZE ,pFileHandle)
+ == MAX_FW_BUFFER_SIZE)
+ {
+ status = KFWUM_STATUS_OK;
+ }
+ }
+ if( modulus )
+ {
+ if(fread(&firmBuf[qty*MAX_FW_BUFFER_SIZE], 1, modulus, pFileHandle) == modulus)
+ {
+ status = KFWUM_STATUS_OK;
+ }
+ }
+ if(status == KFWUM_STATUS_OK)
+ {
+ KfwumShowProgress((const unsigned char *)"Reading Firmware from File", 100, 100);
+ }
+ fclose(pFileHandle);
+ }
+ return(status);
+}
+
+/* KfwumShowProgress - helper routine to display progress bar
+ *
+ * Converts current/total in percent
+ *
+ * *task : string identifying current operation
+ * current: progress
+ * total : limit
+ */
+#define PROG_LENGTH 42
+void KfwumShowProgress( const unsigned char * task, unsigned long current ,
+ unsigned long total)
+{
+ static unsigned long staticProgress=0xffffffff;
+ unsigned char spaces[PROG_LENGTH + 1];
+ unsigned short hash;
+ float percent = ((float)current/total);
+ unsigned long progress;
+
+ progress = 100*((unsigned long)percent);
+ if(staticProgress == progress)
+ {
+ /* We displayed the same last time.. so don't do it */
+ }
+ else
+ {
+ staticProgress = progress;
+
+
+ printf("%-25s : ",task); /* total 20 bytes */
+
+ hash = ( (unsigned short)percent * PROG_LENGTH );
+ memset(spaces,'#', hash);
+ spaces[ hash ] = '\0';
+ printf("%s", spaces );
+
+ memset(spaces,' ',( PROG_LENGTH - hash ) );
+ spaces[ ( PROG_LENGTH - hash ) ] = '\0';
+ printf("%s", spaces );
+
+
+ printf(" %3ld %%\r",progress); /* total 7 bytes */
+
+ if( progress == 100 )
+ {
+ printf("\n");
+ }
+ fflush(stdout);
+ }
+}
+
+/* KfwumCalculateChecksumPadding
+ *
+ * TBD
+ *
+ */
+static unsigned short KfwumCalculateChecksumPadding(unsigned char * pBuffer,
+ unsigned long totalSize)
+{
+ unsigned short sumOfBytes = 0;
+ unsigned short padding;
+ unsigned long counter;
+
+ for(counter = 0; counter < totalSize; counter ++ )
+ {
+ sumOfBytes += pBuffer[counter];
+ }
+
+ padding = 0 - sumOfBytes;
+ return padding;
+}
+
+/******************************************************************************
+******************************* COMMANDS **************************************
+******************************************************************************/
+#pragma pack(1)
+struct KfwumGetInfoResp {
+ unsigned char protocolRevision;
+ unsigned char controllerDeviceId;
+ struct
+ {
+ unsigned char mode:1;
+ unsigned char seqAdd:1;
+ unsigned char res : 6;
+ } byte;
+ unsigned char firmRev1;
+ unsigned char firmRev2;
+ unsigned char numBank;
+}; // __attribute__ ((packed));
+#pragma pack()
+
+
+/* KfwumGetInfo - Get Firmware Update Manager (FWUM) information
+ *
+ * * intf : IPMI interface
+ * output : when set to non zero, queried information is displayed
+ * pNumBank: output ptr for number of banks
+ */
+static tKFWUM_Status KfwumGetInfo(void * intf, unsigned char output,
+ unsigned char *pNumBank)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ static struct KfwumGetInfoResp *pGetInfo;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ int dtype;
+ uchar bus, sa, lun, mtype;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_GET_FIRMWARE_INFO;
+ req.msg.data_len = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("FWUM Firmware Get Info returned %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ pGetInfo = (struct KfwumGetInfoResp *) rsp;
+ if(output)
+ {
+ printf("\nFWUM info\n");
+ printf("=========\n");
+ printf("Protocol Revision : %02Xh\n",
+ pGetInfo->protocolRevision);
+ printf("Controller Device Id : %02Xh\n",
+ pGetInfo->controllerDeviceId);
+ printf("Firmware Revision : %u.%u%u",
+ pGetInfo->firmRev1, pGetInfo->firmRev2 >> 4,
+ pGetInfo->firmRev2 & 0x0f);
+ if(pGetInfo->byte.mode != 0)
+ {
+ printf(" - DEBUG BUILD\n");
+ }
+ else
+ {
+ printf("\n");
+ }
+ printf("Number Of Memory Bank : %u\n",pGetInfo->numBank);
+ }
+ * pNumBank = pGetInfo->numBank;
+
+ /* Determine wich type of download to use: */
+ /* Old FWUM or Old IPMC fw (data_len < 7) -->
+ Address with small buffer size */
+ if ( (pGetInfo->protocolRevision) <= 0x05 || (rsp_len < 7 ) )
+ {
+ saveFirmwareInfo.downloadType = KFWUM_DOWNLOAD_TYPE_ADDRESS;
+ saveFirmwareInfo.bufferSize = KFWUM_SMALL_BUFFER;
+ saveFirmwareInfo.overheadSize = KFWUM_OLD_CMD_OVERHEAD;
+
+ if(verbose)
+ {
+ printf("Protocol Revision :");
+ printf(" <= 5 detected, adjusting buffers\n");
+ }
+ }
+ else /* Both fw are using the new protocol */
+ {
+ saveFirmwareInfo.downloadType = KFWUM_DOWNLOAD_TYPE_SEQUENCE;
+ saveFirmwareInfo.overheadSize = KFWUM_NEW_CMD_OVERHEAD;
+ /* Buffer size depending on access type (Local or remote) */
+ /* Look if we run remote or locally */
+
+ if(verbose)
+ {
+ printf("Protocol Revision :");
+ printf(" > 5 optimizing buffers\n");
+ }
+
+ ipmi_get_mc(&bus, &sa, &lun, &mtype);
+ dtype = get_driver_type();
+ if(is_remote()) /* covers lan and lanplus */
+ {
+ saveFirmwareInfo.bufferSize = KFWUM_SMALL_BUFFER;
+ if(verbose)
+ {
+ printf("IOL payload size : %d\r\n" ,
+ saveFirmwareInfo.bufferSize);
+ }
+ } else if ( (dtype == DRV_MV) && (sa != IPMI_BMC_SLAVE_ADDR) &&
+ (mtype == ADDR_IPMB) )
+ {
+ saveFirmwareInfo.bufferSize = KFWUM_SMALL_BUFFER;
+ if(verbose)
+ {
+ printf("IPMB payload size : %d\r\n" ,
+ saveFirmwareInfo.bufferSize);
+ }
+ }
+ else
+ {
+ saveFirmwareInfo.bufferSize = KFWUM_BIG_BUFFER;
+ if(verbose)
+ {
+ printf("SMI payload size : %d\r\n",
+ saveFirmwareInfo.bufferSize);
+ }
+ }
+ }
+ }
+ return status;
+}
+
+/* KfwumGetDeviceInfo - Get IPMC/Board information
+ *
+ * * intf : IPMI interface
+ * output : when set to non zero, queried information is displayed
+ * tKFWUM_BoardInfo: output ptr for IPMC/Board information
+ */
+static tKFWUM_Status KfwumGetDeviceInfo(void * intf,
+ unsigned char output, tKFWUM_BoardInfo * pBoardInfo)
+{
+ struct ipm_devid_rsp *pGetDevId;
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ char *mstr;
+
+ /* Send Get Device Id */
+ if(status == KFWUM_STATUS_OK)
+ {
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_DEVICE_ID;
+ req.msg.data_len = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error in Get Device Id Command %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ pGetDevId = (struct ipm_devid_rsp *) rsp;
+ pBoardInfo->iana = IPM_DEV_MANUFACTURER_ID(pGetDevId->manufacturer_id);
+ pBoardInfo->boardId = buf2short(pGetDevId->product_id);
+ if(output)
+ {
+ mstr = get_mfg_str(pGetDevId->manufacturer_id,NULL);
+ printf("\nIPMC Info\n");
+ printf("=========\n");
+ printf("Manufacturer Id : %u \t%s\n",pBoardInfo->iana,mstr);
+ printf("Board Id : %u\n",pBoardInfo->boardId);
+ printf("Firmware Revision : %u.%u%u",
+ pGetDevId->fw_rev1, pGetDevId->fw_rev2 >> 4,
+ pGetDevId->fw_rev2 & 0x0f);
+ if(
+ (
+ ( pBoardInfo->iana == KFWUM_IANA_KONTRON)
+ &&
+ (pBoardInfo->boardId == KFWUM_BOARD_KONTRON_5002)
+ )
+ )
+ {
+ printf(" SDR %u\n", pGetDevId->aux_fw_rev[0]);
+ }
+ else
+ {
+ printf("\n");
+ }
+ }
+ }
+
+ return status;
+}
+
+#pragma pack(1)
+struct KfwumGetStatusResp {
+ unsigned char bankState;
+ unsigned char firmLengthLSB;
+ unsigned char firmLengthMid;
+ unsigned char firmLengthMSB;
+ unsigned char firmRev1;
+ unsigned char firmRev2;
+ unsigned char firmRev3;
+}; // __attribute__ ((packed));
+#pragma pack()
+
+const struct valstr bankStateValS[] = {
+ { 0x00, "Not programmed" },
+ { 0x01, "New firmware" },
+ { 0x02, "Wait for validation" },
+ { 0x03, "Last Known Good" },
+ { 0x04, "Previous Good" }
+};
+
+/* KfwumGetStatus - Get (and prints) FWUM banks information
+ *
+ * * intf : IPMI interface
+ */
+static tKFWUM_Status KfwumGetStatus(void * intf)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct KfwumGetStatusResp *pGetStatus;
+ unsigned char numBank;
+ unsigned char counter;
+
+ if(verbose)
+ {
+ printf(" Getting Status!\n");
+ }
+
+ /* Retreive the number of bank */
+ status = KfwumGetInfo(intf, 0, &numBank);
+
+ for(
+ counter = 0;
+ (counter < numBank) && (status == KFWUM_STATUS_OK);
+ counter ++
+ )
+ {
+ /* Retreive the status of each bank */
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_GET_FIRMWARE_STATUS;
+ req.msg.data = &counter;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("FWUM Firmware Get Status Error %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ pGetStatus = (struct KfwumGetStatusResp *) rsp;
+ printf("\nBank State %d : %s\n", counter, val2str(
+ pGetStatus->bankState, bankStateValS));
+ if(pGetStatus->bankState)
+ {
+ unsigned long firmLength;
+ firmLength = pGetStatus->firmLengthMSB;
+ firmLength = firmLength << 8;
+ firmLength |= pGetStatus->firmLengthMid;
+ firmLength = firmLength << 8;
+ firmLength |= pGetStatus->firmLengthLSB;
+
+ printf("Firmware Length : %ld bytes\n", firmLength);
+ printf("Firmware Revision : %u.%u%u SDR %u\n",
+ pGetStatus->firmRev1, pGetStatus->firmRev2 >> 4,
+ pGetStatus->firmRev2 & 0x0f, pGetStatus->firmRev3);
+ }
+ }
+ }
+ printf("\n");
+ return status;
+}
+#pragma pack(1)
+struct KfwumManualRollbackReq{
+ unsigned char type;
+}; // __attribute__ ((packed));
+#pragma pack()
+
+
+/* KfwumManualRollback - Ask IPMC to rollback to previous version
+ *
+ * * intf : IPMI interface
+ */
+static tKFWUM_Status KfwumManualRollback(void * intf)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct KfwumManualRollbackReq thisReq;
+
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_MANUAL_ROLLBACK;
+
+ thisReq.type = 0; /* Wait BMC shutdown */
+
+ req.msg.data = (unsigned char *) &thisReq;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error in FWUM Manual Rollback Command %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ printf("FWUM Starting Manual Rollback \n");
+ }
+ return status;
+}
+
+#pragma pack(1)
+struct KfwumStartFirmwareDownloadReq{
+ unsigned char lengthLSB;
+ unsigned char lengthMid;
+ unsigned char lengthMSB;
+ unsigned char paddingLSB;
+ unsigned char paddingMSB;
+ unsigned char useSequence;
+}; // __attribute__ ((packed));
+struct KfwumStartFirmwareDownloadResp {
+ unsigned char bank;
+}; // __attribute__ ((packed));
+#pragma pack()
+
+static tKFWUM_Status KfwumStartFirmwareImage(void * intf,
+ unsigned long length,unsigned short padding)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct KfwumStartFirmwareDownloadResp *pResp;
+ struct KfwumStartFirmwareDownloadReq thisReq;
+
+ thisReq.lengthLSB = (uchar)(length & 0x000000ff);
+ thisReq.lengthMid = (uchar)((length >> 8) & 0x000000ff);
+ thisReq.lengthMSB = (uchar)((length >> 16) & 0x000000ff);
+ thisReq.paddingLSB = padding & 0x00ff;
+ thisReq.paddingMSB = (padding>> 8) & 0x00ff;
+ thisReq.useSequence = 0x01;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_START_FIRMWARE_IMAGE;
+ req.msg.data = (unsigned char *) &thisReq;
+
+ /* Look for download type */
+ if ( saveFirmwareInfo.downloadType == KFWUM_DOWNLOAD_TYPE_ADDRESS )
+ {
+ req.msg.data_len = 5;
+ }
+ else
+ {
+ req.msg.data_len = 6;
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("FWUM Firmware Start Firmware Image Download returned %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ pResp = (struct KfwumStartFirmwareDownloadResp *) rsp;
+ printf("Bank holding new firmware : %d\n", pResp->bank);
+ os_usleep(5,0);
+ }
+ return status;
+}
+
+#pragma pack(1)
+struct KfwumSaveFirmwareAddressReq
+{
+ unsigned char addressLSB;
+ unsigned char addressMid;
+ unsigned char addressMSB;
+ unsigned char numBytes;
+ unsigned char txBuf[KFWUM_SMALL_BUFFER-KFWUM_OLD_CMD_OVERHEAD];
+}; // __attribute__ ((packed));
+
+struct KfwumSaveFirmwareSequenceReq
+{
+ unsigned char sequenceNumber;
+ unsigned char txBuf[KFWUM_BIG_BUFFER];
+}; // __attribute__ ((packed));
+#pragma pack()
+
+
+#define FWUM_SAVE_FIRMWARE_NO_RESPONSE_LIMIT ((unsigned char)6)
+
+static tKFWUM_Status KfwumSaveFirmwareImage(void * intf,
+ unsigned char sequenceNumber, unsigned long address, unsigned char *pFirmBuf,
+ unsigned char * pInBufLength)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char out = 0;
+ unsigned char retry = 0;
+ unsigned char noResponse = 0 ;
+
+ struct KfwumSaveFirmwareAddressReq addressReq;
+ struct KfwumSaveFirmwareSequenceReq sequenceReq;
+
+ do
+ {
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_SAVE_FIRMWARE_IMAGE;
+
+ if (saveFirmwareInfo.downloadType == KFWUM_DOWNLOAD_TYPE_ADDRESS )
+ {
+ addressReq.addressLSB = (uchar)(address & 0x000000ff);
+ addressReq.addressMid = (uchar)((address >> 8) & 0x000000ff);
+ addressReq.addressMSB = (uchar)((address >> 16) & 0x000000ff);
+ addressReq.numBytes = (* pInBufLength);
+ memcpy(addressReq.txBuf, pFirmBuf, (* pInBufLength));
+ req.msg.data = (unsigned char *) &addressReq;
+ req.msg.data_len = (* pInBufLength)+4;
+ }
+ else
+ {
+ sequenceReq.sequenceNumber = sequenceNumber;
+ memcpy(sequenceReq.txBuf, pFirmBuf, (* pInBufLength));
+ req.msg.data = (unsigned char *) &sequenceReq;
+ req.msg.data_len = (* pInBufLength)+sizeof(unsigned char); /* + 1 => sequenceNumber*/
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf("Error in FWUM Firmware Save Firmware Image Download Command\n");
+
+ out = 0;
+ status = KFWUM_STATUS_OK;
+
+ /* With IOL, we don't receive "C7" on errors, instead we receive
+ nothing */
+ if(is_remote())
+ {
+ noResponse++;
+
+ if(noResponse < FWUM_SAVE_FIRMWARE_NO_RESPONSE_LIMIT )
+ {
+ (* pInBufLength) -= 1;
+ out = 0;
+ }
+ else
+ {
+ printf("Error, too many commands without response\n");
+ (* pInBufLength) = 0 ;
+ out = 1;
+ }
+ } /* For other interface keep trying */
+ }
+ else if (rv > 0) /*ccode*/
+ {
+ if(rv == 0xc0)
+ {
+ status = KFWUM_STATUS_OK;
+ os_usleep(1,0);
+ }
+ else if(
+ (rv == 0xc7)
+ ||
+ (
+ (rv == 0xC3) &&
+ (sequenceNumber == 0)
+ )
+ )
+ {
+ (* pInBufLength) -= 1;
+ status = KFWUM_STATUS_OK;
+ retry = 1;
+ }
+ else if(rv == 0x82)
+ {
+ /* Double sent, continue */
+ status = KFWUM_STATUS_OK;
+ out = 1;
+ }
+ else if(rv == 0x83)
+ {
+ if(retry == 0)
+ {
+ retry = 1;
+ status = KFWUM_STATUS_OK;
+ }
+ else
+ {
+ status = rv; // KFWUM_STATUS_ERROR
+ out = 1;
+ }
+ }
+ else if(rv == 0xcf) /* Ok if receive duplicated request */
+ {
+ retry = 1;
+ status = KFWUM_STATUS_OK;
+ }
+ else if(rv == 0xC3)
+ {
+ if(retry == 0)
+ {
+ retry = 1;
+ status = KFWUM_STATUS_OK;
+ }
+ else
+ {
+ status = rv; // KFWUM_STATUS_ERROR
+ out = 1;
+ }
+ }
+ else
+ {
+ printf("FWUM Firmware Save Firmware Image Download returned %x\n",
+ rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ out = 1;
+ }
+ }
+ else
+ {
+ out = 1;
+ }
+ }while(out == 0);
+ return status;
+}
+
+#pragma pack(1)
+struct KfwumFinishFirmwareDownloadReq{
+ unsigned char versionMaj;
+ unsigned char versionMinSub;
+ unsigned char versionSdr;
+ unsigned char reserved;
+}; // __attribute__ ((packed));
+#pragma pack()
+static tKFWUM_Status KfwumFinishFirmwareImage(void * intf,
+ tKFWUM_InFirmwareInfo firmInfo)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct KfwumFinishFirmwareDownloadReq thisReq;
+
+ thisReq.versionMaj = firmInfo.versMajor;
+ thisReq.versionMinSub = ((firmInfo.versMinor <<4) | firmInfo.versSubMinor);
+ thisReq.versionSdr = firmInfo.sdrRev;
+ thisReq.reserved = 0;
+ /* Byte 4 reserved, write 0 */
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_FINISH_FIRMWARE_IMAGE;
+ req.msg.data = (unsigned char *) &thisReq;
+ req.msg.data_len = 4;
+
+ do
+ {
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ }while (rv == 0xc0);
+
+ if (rv < 0)
+ {
+ printf("Error in FWUM Firmware Finish Firmware Image Download Command\n");
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+ else if (rv > 0)
+ {
+ printf("FWUM Firmware Finish Firmware Image Download returned %x\n",
+ rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ return status;
+}
+
+
+#define FWUM_MAX_UPLOAD_RETRY 6
+static tKFWUM_Status KfwumUploadFirmware(void * intf,
+ unsigned char * pBuffer, unsigned long totalSize)
+{
+ tKFWUM_Status status = KFWUM_STATUS_ERROR;
+ unsigned long address = 0x0;
+ unsigned char writeSize;
+ unsigned char oldWriteSize;
+ unsigned long lastAddress = 0;
+ unsigned char sequenceNumber = 0;
+ unsigned char retry = FWUM_MAX_UPLOAD_RETRY;
+ // unsigned char isLengthValid = 1;
+
+ do
+ {
+ writeSize = saveFirmwareInfo.bufferSize - saveFirmwareInfo.overheadSize;
+
+ /* Reach the end */
+ if( address + writeSize > totalSize )
+ {
+ writeSize = (uchar)(totalSize - address);
+ }
+ /* Reach boundary end */
+ else if(((address % KFWUM_PAGE_SIZE) + writeSize) > KFWUM_PAGE_SIZE)
+ {
+ writeSize = (KFWUM_PAGE_SIZE - (uchar)(address % KFWUM_PAGE_SIZE));
+ }
+
+ oldWriteSize = writeSize;
+ status = KfwumSaveFirmwareImage(intf, sequenceNumber, address,
+ &pBuffer[address], &writeSize);
+
+ if((status != KFWUM_STATUS_OK) && (retry-- != 0))
+ {
+ address = lastAddress;
+ status = KFWUM_STATUS_OK;
+ }
+ else if( writeSize == 0 )
+ {
+ status = KFWUM_STATUS_ERROR;
+ }
+ else
+ {
+ if(writeSize != oldWriteSize)
+ {
+ printf("Adjusting length to %d bytes \n", writeSize);
+ saveFirmwareInfo.bufferSize -= (oldWriteSize - writeSize);
+ }
+
+ retry = FWUM_MAX_UPLOAD_RETRY;
+ lastAddress = address;
+ address+= writeSize;
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ if((address % 1024) == 0)
+ {
+ KfwumShowProgress((const unsigned char *)\
+ "Writing Firmware in Flash",address,totalSize);
+ }
+ sequenceNumber++;
+ }
+
+ }while((status == KFWUM_STATUS_OK) && (address < totalSize ));
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ KfwumShowProgress((const unsigned char *)\
+ "Writing Firmware in Flash", 100 , 100 );
+ }
+
+ return(status);
+}
+
+static tKFWUM_Status KfwumStartFirmwareUpgrade(void * intf)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char upgType = 0 ; /* Upgrade type, wait BMC shutdown */
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_START_FIRMWARE_UPDATE;
+ req.msg.data = (unsigned char *) &upgType;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf("Error in FWUM Firmware Start Firmware Upgrade Command\n");
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+ else if (rv > 0)
+ {
+ if(rv == 0xd5)
+ {
+ printf("No firmware available for upgrade. Download Firmware first\n");
+ }
+ else
+ {
+ printf("FWUM Firmware Start Firmware Upgrade returned %x\n",
+ rv);
+ }
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ return status;
+}
+
+#define TRACE_LOG_CHUNK_COUNT 7
+#define TRACE_LOG_CHUNK_SIZE 7
+#define TRACE_LOG_ATT_COUNT 3
+/* String table */
+/* Must match eFWUM_CmdId */
+static const char* CMD_ID_STRING[] = {
+ "GetFwInfo",
+ "KickWatchdog",
+ "GetLastAnswer",
+ "BootHandshake",
+ "ReportStatus",
+ "CtrlIPMBLine",
+ "SetFwState",
+ "GetFwStatus",
+ "GetSpiMemStatus",
+ "StartFwUpdate",
+ "StartFwImage",
+ "SaveFwImage",
+ "FinishFwImage",
+ "ReadFwImage",
+ "ManualRollback",
+ "GetTraceLog" };
+
+static const char* EXT_CMD_ID_STRING[] = {
+ "FwUpgradeLock",
+ "ProcessFwUpg",
+ "ProcessFwRb",
+ "WaitHSAfterUpg",
+ "WaitFirstHSUpg",
+ "FwInfoStateChange" };
+
+
+static const char* CMD_STATE_STRING[] = {
+ "Invalid",
+ "Begin",
+ "Progress",
+ "Completed" };
+
+
+static tKFWUM_Status KfwumGetTraceLog(void * intf)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char chunkIdx;
+ unsigned char cmdIdx;
+
+ if(verbose)
+ {
+ printf(" Getting Trace Log!\n");
+ }
+
+ for( chunkIdx = 0; (chunkIdx < TRACE_LOG_CHUNK_COUNT) && (status == KFWUM_STATUS_OK); chunkIdx++ )
+ {
+ /* Retreive each log chunk and print it */
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_FIRMWARE;
+ req.msg.cmd = KFWUM_CMD_ID_GET_TRACE_LOG;
+ req.msg.data = &chunkIdx;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("FWUM Firmware Get Trace Log returned %d (0x%02x)\n",rv,rv);
+ status = rv; // KFWUM_STATUS_ERROR
+ }
+
+ if(status == KFWUM_STATUS_OK)
+ {
+ for (cmdIdx=0; cmdIdx < TRACE_LOG_CHUNK_SIZE; cmdIdx++)
+ {
+ /* Don't diplay commands with an invalid state */
+ if ( (rsp[TRACE_LOG_ATT_COUNT*cmdIdx+1] != 0) &&
+ (rsp[TRACE_LOG_ATT_COUNT*cmdIdx] < KFWUM_CMD_ID_STD_MAX_CMD))
+ {
+ printf(" Cmd ID: %17s -- CmdState: %10s -- CompCode: %2x\n",
+ CMD_ID_STRING[rsp[TRACE_LOG_ATT_COUNT*cmdIdx]],
+ CMD_STATE_STRING[rsp[TRACE_LOG_ATT_COUNT*cmdIdx+1]],
+ rsp[TRACE_LOG_ATT_COUNT*cmdIdx+2]);
+ }
+ else if ( (rsp[TRACE_LOG_ATT_COUNT*cmdIdx+1] != 0) &&
+ (rsp[TRACE_LOG_ATT_COUNT*cmdIdx] >= KFWUM_CMD_ID_EXTENDED_CMD))
+ {
+ printf(" Cmd ID: %17s -- CmdState: %10s -- CompCode: %2x\n",
+ EXT_CMD_ID_STRING[rsp[TRACE_LOG_ATT_COUNT*cmdIdx] - KFWUM_CMD_ID_EXTENDED_CMD],
+ CMD_STATE_STRING[rsp[TRACE_LOG_ATT_COUNT*cmdIdx+1]],
+ rsp[TRACE_LOG_ATT_COUNT*cmdIdx+2]);
+ }
+ }
+ }
+ }
+ printf("\n");
+ return status;
+}
+
+
+/*******************************************************************************
+* Function Name: KfwumGetInfoFromFirmware
+*
+* Description: This function retreive from the firmare the following info :
+*
+* o Checksum
+* o File size (expected)
+* o Board Id
+* o Device Id
+*
+* Restriction: None
+*
+* Input: char * fileName - File to get info from
+*
+* Output: pInfo - container that will hold all the informations gattered.
+* see structure for all details
+*
+* Global: None
+*
+* Return: IFWU_SUCCESS - file ok
+* IFWU_ERROR - file error
+*
+*******************************************************************************/
+#define IN_FIRMWARE_INFO_OFFSET_LOCATION 0x5a0
+#define IN_FIRMWARE_INFO_SIZE 20
+#define IN_FIRMWARE_INFO_OFFSET_FILE_SIZE 0
+#define IN_FIRMWARE_INFO_OFFSET_CHECKSUM 4
+#define IN_FIRMWARE_INFO_OFFSET_BOARD_ID 6
+#define IN_FIRMWARE_INFO_OFFSET_DEVICE_ID 8
+#define IN_FIRMWARE_INFO_OFFSET_TABLE_VERSION 9
+#define IN_FIRMWARE_INFO_OFFSET_IMPLEMENT_REV 10
+#define IN_FIRMWARE_INFO_OFFSET_VERSION_MAJOR 11
+#define IN_FIRMWARE_INFO_OFFSET_VERSION_MINSUB 12
+#define IN_FIRMWARE_INFO_OFFSET_SDR_REV 13
+#define IN_FIRMWARE_INFO_OFFSET_IANA0 14
+#define IN_FIRMWARE_INFO_OFFSET_IANA1 15
+#define IN_FIRMWARE_INFO_OFFSET_IANA2 16
+
+#define KWUM_GET_BYTE_AT_OFFSET(pBuffer,os) pBuffer[os]
+
+tKFWUM_Status KfwumGetInfoFromFirmware(unsigned char * pBuf,
+ unsigned long bufSize, tKFWUM_InFirmwareInfo * pInfo)
+{
+ tKFWUM_Status status = KFWUM_STATUS_ERROR;
+
+ if(bufSize >= (IN_FIRMWARE_INFO_OFFSET_LOCATION + IN_FIRMWARE_INFO_SIZE))
+ {
+ unsigned long offset = IN_FIRMWARE_INFO_OFFSET_LOCATION;
+
+ /* Now, fill the structure with read informations */
+ pInfo->checksum = (unsigned short)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+0+IN_FIRMWARE_INFO_OFFSET_CHECKSUM ) << 8;
+ pInfo->checksum |= (unsigned short)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+1+IN_FIRMWARE_INFO_OFFSET_CHECKSUM );
+
+
+ pInfo->sumToRemoveFromChecksum=
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_CHECKSUM);
+
+ pInfo->sumToRemoveFromChecksum+=
+ KWUM_GET_BYTE_AT_OFFSET(pBuf ,
+ offset+IN_FIRMWARE_INFO_OFFSET_CHECKSUM+1);
+
+ pInfo->fileSize =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf ,
+ offset+IN_FIRMWARE_INFO_OFFSET_FILE_SIZE+0) << 24;
+ pInfo->fileSize |=
+ (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_FILE_SIZE+1) << 16;
+ pInfo->fileSize |=
+ (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_FILE_SIZE+2) << 8;
+ pInfo->fileSize |=
+ (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_FILE_SIZE+3);
+
+ pInfo->boardId =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_BOARD_ID+0) << 8;
+ pInfo->boardId |=
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_BOARD_ID+1);
+
+ pInfo->deviceId =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_DEVICE_ID);
+
+ pInfo->tableVers =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_TABLE_VERSION);
+ pInfo->implRev =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_IMPLEMENT_REV);
+ pInfo->versMajor =
+ (KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_VERSION_MAJOR)) & 0x0f;
+ pInfo->versMinor =
+ (KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_VERSION_MINSUB)>>4) & 0x0f;
+ pInfo->versSubMinor =
+ (KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_VERSION_MINSUB)) & 0x0f;
+ pInfo->sdrRev =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_SDR_REV);
+ pInfo->iana =
+ KWUM_GET_BYTE_AT_OFFSET(pBuf ,
+ offset+IN_FIRMWARE_INFO_OFFSET_IANA2) << 16;
+ pInfo->iana |=
+ (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_IANA1) << 8;
+ pInfo->iana |=
+ (unsigned long)KWUM_GET_BYTE_AT_OFFSET(pBuf,
+ offset+IN_FIRMWARE_INFO_OFFSET_IANA0);
+
+ KfwumFixTableVersionForOldFirmware(pInfo);
+
+ status = KFWUM_STATUS_OK;
+ }
+ return(status);
+}
+
+
+void KfwumFixTableVersionForOldFirmware(tKFWUM_InFirmwareInfo * pInfo)
+{
+ switch(pInfo->boardId)
+ {
+ case KFWUM_BOARD_KONTRON_UNKNOWN:
+ pInfo->tableVers = 0xff;
+ break;
+ default:
+ /* pInfo->tableVers is already set for the right version */
+ break;
+ }
+}
+
+
+tKFWUM_Status KfwumValidFirmwareForBoard(tKFWUM_BoardInfo boardInfo,
+ tKFWUM_InFirmwareInfo firmInfo)
+{
+ tKFWUM_Status status = KFWUM_STATUS_OK;
+
+ if(boardInfo.iana != firmInfo.iana)
+ {
+ printf("Board IANA does not match firmware IANA\n");
+ status = KFWUM_STATUS_ERROR;
+ }
+
+ if(boardInfo.boardId != firmInfo.boardId)
+ {
+ printf("Board IANA does not match firmware IANA\n");
+ status = KFWUM_STATUS_ERROR;
+ }
+
+ if(status == KFWUM_STATUS_ERROR)
+ {
+ printf("Firmware invalid for target board. Download of upgrade aborted\n");
+ }
+ return status;
+}
+
+
+static void KfwumOutputInfo(tKFWUM_BoardInfo boardInfo,
+ tKFWUM_InFirmwareInfo firmInfo)
+{
+ printf("Target Board Id : %u\n",boardInfo.boardId);
+ printf("Target IANA number : %u\n",boardInfo.iana);
+ printf("File Size : %lu bytes\n",firmInfo.fileSize);
+ printf("Firmware Version : %d.%d%d SDR %d\n",firmInfo.versMajor,
+ firmInfo.versMinor, firmInfo.versSubMinor, firmInfo.sdrRev);
+}
+
+#ifdef METACOMMAND
+int i_fwum(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"m:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 1; verbose = 1;
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ KfwumOutputHelp();
+ return ERR_USAGE;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rc = ipmi_fwum_main(intf, argc, argv);
+
+ ipmi_close_();
+ // show_outcome(progname,rc);
+ return rc;
+}
diff --git a/util/ifwum.h b/util/ifwum.h
new file mode 100644
index 0000000..e6c228c
--- /dev/null
+++ b/util/ifwum.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_KFWUM_H
+#define IPMI_KFWUM_H
+
+// #include <inttypes.h>
+// #include <ipmitool/ipmi.h>
+
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+
+#define IPMI_NETFN_APP 0x6
+#define IPMI_NETFN_FIRMWARE 0x8
+
+#define IPMI_BMC_SLAVE_ADDR 0x20
+
+#define BMC_GET_DEVICE_ID 0x1
+
+#define IPM_DEV_MANUFACTURER_ID(x) \
+ ((uint32_t) ((x[2] & 0x0F) << 16 | x[1] << 8 | x[0]))
+
+//struct valstr {
+ // uint16_t val;
+ // const char * str;
+//};
+
+#pragma pack(1)
+struct ipm_devid_rsp {
+ uint8_t device_id;
+ uint8_t device_revision;
+ uint8_t fw_rev1;
+ uint8_t fw_rev2;
+ uint8_t ipmi_version;
+ uint8_t adtl_device_support;
+ uint8_t manufacturer_id[3];
+ uint8_t product_id[2];
+ uint8_t aux_fw_rev[4];
+}; // __attribute__ ((packed));
+#pragma pack()
+
+/* routines from lib/lanplus/helper.c */
+uint16_t buf2short(uint8_t * buf);
+//const char * val2str(uint16_t val, const struct valstr * vs);
+
+#endif /* IPMI_KFWUM_H */
diff --git a/util/igetevent.c b/util/igetevent.c
new file mode 100644
index 0000000..6e2fe27
--- /dev/null
+++ b/util/igetevent.c
@@ -0,0 +1,1439 @@
+/*
+ * igetevent.c
+ *
+ * This utility waits for IPMI Event Messages.
+ * Some server management functions want to trigger custom actions or
+ * alerts when IPMI hardware-related events occur, but do not want to
+ * track all events, just newly occurring events.
+ * The IPMI events also include BIOS events such as Memory and POST errors,
+ * which would not be captured by reading the IPMI sensors.
+ * This utility waits a specified timeout period for any events, and
+ * returns interpreted output for each event. It is designed as a
+ * scriptable command-line utility, but if the timeout is infinite
+ * (-t 0), then this code could be used for a sample service as well.
+ *
+ * There are several methods to do this which are implemented here.
+ * The SEL method (-s):
+ * This method polls the SEL once a second, keeps track of the last
+ * SEL event read, and only new events are processed. This ensures
+ * that in a series of rapid events, all events are received in order,
+ * however, some transition-to-OK events may not be configured to
+ * write to the SEL on certain platforms.
+ * This method is used if getevent -s is specified.
+ * The ReadEventMessageBuffer method (-m getmessage option):
+ * This uses an IPMI Message Buffer in the BMC firmware to read
+ * each new event. This receives any event, but if two events
+ * occur nearly simultaneously, only the most recent of the two
+ * will be returned with this method. An example of simultaneous
+ * events might be, if a fan stops/fails, both the non-critical
+ * and critical fan threshold events would occur at that time.
+ * This is the default method for getevent. It would be used
+ * locally with the Intel IMB driver or with direct/driverless.
+ * The OpenIPMI custom method (-m getmessage_mv option if DRV_MV):
+ * Different IPMI drivers may have varying behavior. For instance,
+ * the OpenIPMI driver uses the IPMI GetMessage commands internally
+ * and does not allow client programs to use those commands. It has
+ * its own custom mechanism, see getevent_mv().
+ * This method is used locally if the OpenIPMI driver is detected.
+ * The Async Event method (-a):
+ * This only gets certain Asynchronous events, like a shutdown
+ * request from the BMC to an SMS OS service, and get_software_id.
+ * This is supported for Intel IMB driver and OpenIPMI driver only.
+ * This method is only used locally if getevent option -a is used,
+ * and if either MV (openipmi) or IMB driver is loaded.
+ * The ipmiutil_asy init script controls the getevent -a service.
+ * (see DO_ASYNC compile flag comments)
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2005-2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 02/11/05 Andy Cress - created
+ * 05/18/05 Andy Cress - modified bmc_enable bits
+ * 05/26/05 Andy Cress - added call to decode_sel_entry
+ * 09/09/05 Andy Cress - added sensor_type filtering & return type.
+ * 03/16/05 Andy Cress - added loop, and -o for frunOnce
+ * 06/27/06 Andy Cress 1.1 - specific message for cc=0x80 (no data)
+ * 07/18/06 Andy Cress 1.1 - added getevent_mv, etc.
+ * 07/26/06 Andy Cress 1.1 - added msgout() routine for fflush
+ * 08/08/06 Andy Cress 1.2 - added -s for SEL method
+ * 08/08/06 Andy Cress 1.2 - added -s for SEL method
+ * 08/22/06 Andy Cress 1.3 - direct IOs added with ipmiutil-1.7.5
+ * 09/13/06 Andy Cress 1.4 - handle empty SEL (0xCB),
+ * call syncevent_sel after every new event.
+ * 09/21/07 Andy Cress 1.21 - implemented IMB Async method for remote
+ * OS shutdown via SMS requests.
+ */
+/*M*
+Copyright (c) 2009 Kontron America, Inc.
+Copyright (c) 2013 Andy Cress <arcress at users.sourceforge.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#include <unistd.h>
+#endif
+#include <pthread.h>
+#include <sys/utsname.h>
+#endif
+#include <string.h>
+#ifdef SOLARIS
+/* Solaris */
+#define HandleType long
+#elif WIN32
+#include "imb_api.h"
+#define DO_ASYNC 1
+#elif LINUX
+#define LINUX 1
+#include "imb_api.h"
+#define DO_ASYNC 1
+#define DO_MVL 1
+#elif BSD
+#define DO_MVL 1
+#define HandleType long
+#else
+/* other OS */
+#define HandleType long
+#endif
+#include "ipmicmd.h"
+
+#define THREADS_OK 1
+#define IMBPTIMEOUT 200 /*200 ms*/
+// #define IPMB_CHANNEL 0x00
+// #define LAN_CHANNEL 0x02
+#define ulong unsigned long
+#define uint unsigned int
+#define ushort unsigned short
+#define uchar unsigned char
+
+#define CMD_GET_SOFTWARE_ID 0x00
+#define CMD_SMS_OS_REQUEST 0x10
+
+extern int decode_sel_entry(uchar *evt, char *obuf, int sz); /*see ievents.c*/
+extern void set_sel_opts(int sensdesc, int canon, void *sdrs, char fdbg, char utc); /* ievents.c */
+extern char *get_sensor_type_desc(uchar stype); /*see ievents.c*/
+extern int write_syslog(char *msg); /*see isel.c*/
+extern char *show_driver_type(int idx); /*see ipmicmd.h*/
+extern int get_sdr_cache(uchar **pret); /*see isensor.c*/
+extern void free_sdr_cache(uchar *pret); /*see isensor.c*/
+
+/*
+ * Global variables
+ */
+static char * progname = "igetevent";
+static char * progver = "2.93";
+static char fdebug = 0;
+static char fipmilan = 0;
+static char frunonce = 0;
+static char futc = 0;
+static char fAsync = 0;
+static char fAsyncOK = 0; /*=1 if drvtype detected for it*/
+static char fAsyncNOP = 0; /*=1 if skip Async actions*/
+static char fbackground = 0;
+static char frunscript = 0;
+static char fcanonical = 0;
+static char fsettime = 0; /* =1 if timeout is set by -t */
+static uchar evt_stype = 0xff; /* event sensor type, 0xff = get any events */
+static uchar evt_snum = 0xff; /* event sensor num, 0xff = get any events */
+static int timeout = 120; /* 120 seconds default timeout */
+static int wait_interval = 1; /* 1 second between calls */
+static FILE *fdout = NULL;
+static char *run_script = NULL;
+static uchar ipmi_maj = 0;
+static uchar ipmi_min = 0;
+static HandleType imb_handle = 0;
+static int drvtype = 0; /* driver_type from ipmicmd.h: 1=Intel_imb, 3=MV_OpenIPMI */
+static int vend_id = 0;
+static int prod_id = 0;
+static char fselevts = 0;
+static char fmsgevts = 0;
+static ushort sel_recid = 0;
+static uint sel_time = 0;
+static uchar sms_sa = 0x81;
+static uchar *sdrs = NULL;
+#define LAST_REC 0xFFFF
+#ifdef WIN32
+#define IDXFILE "ipmi_evt.idx"
+static char idxfile[80] = IDXFILE;
+static char idxfile2[80] = "c:\\ipmi_evt.idx";
+static char outfile[80] = "c:\\ipmiutil_evt.log";
+#define SHUTDOWN_CMD "shutdown -s -d p:01:01 -t 10"
+#define REBOOT_CMD "shutdown -r -d p:01:01 -t 10"
+#else
+static char idxfile[80] = "/var/lib/ipmiutil/evt.idx";
+static char idxfile2[80] = "/usr/share/ipmiutil/evt.idx";
+static char outfile[80] = "/var/log/ipmiutil_evt.log";
+#define SHUTDOWN_CMD "init 0" // or shutdown now
+#define REBOOT_CMD "init 6"
+#endif
+#ifdef METACOMMAND
+extern FILE *fpdbg; /*from ipmicmd.c*/
+extern FILE *fperr; /*from ipmicmd.c*/
+#endif
+/* prototypes */
+static void iclose(void);
+static void ievt_siginit(void);
+static void ievt_cleanup(void);
+
+#define METHOD_UNKNOWN 0
+#define METHOD_SEL_EVTS 1
+#define METHOD_MSG_GET 2
+#define METHOD_MSG_MV 3
+#define METHOD_ASYNC_MV 4
+#define METHOD_ASYNC_IMB 5
+static char *methodstr[6] = {
+ "unknown",
+ "SEL_events",
+ "GetMessage",
+ "GetMessage_mv",
+ "Async_mv",
+ "Async_imb" };
+
+static int do_wait(int nsec)
+{
+ int rv = 0;
+ if (nsec > 0) os_usleep(nsec,0); /*declared in ipmicmd.h*/
+ return(rv);
+}
+
+static int get_event_receiver(uchar *sa, uchar *lun)
+{
+ uchar rdata[30];
+ int rlen;
+ uchar ccode;
+ int ret;
+
+ rlen = 2;
+#if 0
+ ret = ipmi_cmdraw( 0x01,NETFN_SEVT,BMC_SA,PUBLIC_BUS,BMC_LUN,
+ idata,0, rdata,&rlen,&ccode, fdebug);
+#endif
+ ret = ipmi_cmd(GET_EVENT_RECEIVER,NULL,0, rdata,&rlen,&ccode, 0);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ if (ret == 0) {
+ *sa = rdata[0];
+ *lun = rdata[1];
+ }
+ return(ret);
+}
+
+static int get_msg_flags(uchar *flags)
+{
+ uchar rdata[8];
+ int rlen = 1;
+ uchar ccode;
+ int ret;
+ ret = ipmi_cmdraw( 0x31,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN,
+ NULL,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ if ((ret == 0) && (flags != NULL)) *flags = rdata[0];
+ return(ret);
+}
+
+static int set_bmc_enables(uchar enab)
+{
+ uchar idata[8];
+ uchar rdata[30];
+ int rlen;
+ uchar ccode;
+ int ret;
+
+ idata[0] = enab;
+ rlen = 1;
+ ret = ipmi_cmdraw( 0x2E,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN,
+ idata,1, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+}
+
+static int get_bmc_enables(uchar *enab)
+{
+ uchar rdata[30];
+ int rlen;
+ uchar ccode;
+ int ret;
+
+ rlen = 1;
+ ret = ipmi_cmdraw( 0x2F,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN,
+ NULL,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+
+ if (ret == 0) *enab = rdata[0];
+ return(ret);
+}
+
+/*
+ * msgout
+ * wrapper for printf() to include fflush
+ */
+void msgout(char *pattn, ...)
+{
+ va_list arglist;
+
+ if (fdout == NULL) return;
+ va_start( arglist, pattn );
+ vfprintf( fdout, pattn, arglist );
+ va_end( arglist );
+ fflush( fdout );
+}
+
+#ifdef DO_ASYNC
+/* The DO_ASYNC flag enables the IMB Async Message method via get_imb_event.
+ * This requires the Intel IMB driver, and is used only for remote shutdown
+ * and software ID events. */
+
+/* The LANDesk library has the same function names as the imbapi.c */
+#ifdef LINK_LANDESK
+#define StartAsyncMesgPoll ia_StartAsyncMesgPoll
+#define SendAsyncImbpRequest ia_SendAsyncImbpRequest
+#define GetAsyncImbpMessage ia_GetAsyncImbpMessage
+#define GetAsyncImbpMessage_Ex ia_GetAsyncImbpMessage_Ex
+#define IsAsyncMessageAvailable ia_IsAsyncMessageAvailable
+#define RegisterForImbAsyncMessageNotification ia_RegisterForImbAsyncMessageNotification
+#define UnRegisterForImbAsyncMessageNotification ia_UnRegisterForImbAsyncMessageNotification
+#define SendTimedLanMessageResponse_Ex ia_SendTimedLanMessageResponse_Ex
+#define SendTimedEmpMessageResponse_Ex ia_SendTimedEmpMessageResponse_Ex
+#endif /*endif LINK_LANDESK*/
+
+typedef struct {
+ uchar rsSa;
+ uchar nfLn;
+ uchar cSum1;
+ uchar rqSa;
+ uchar seqLn;
+ uchar cmd;
+ uchar data[1];
+} AsyImbPacket;
+
+#ifdef THREADS_OK
+ char message[32];
+#ifdef WIN32
+ HANDLE threadid = NULL;
+#else
+ pthread_t threadid = 0;
+#endif
+#endif
+
+#ifdef WIN32
+#define ThreadRType DWORD
+ThreadRType WINAPI pollThread( LPVOID p)
+#else
+#define ThreadRType void *
+ThreadRType pollThread(void *p)
+#endif
+{
+ int i;
+ int ret, limit;
+#ifdef THREADS_OK
+ limit = 0;
+#else
+ limit = 30;
+#endif
+ for (i = 0; (limit == 0) || (i < limit); i++)
+ {
+ ret = StartAsyncMesgPoll();
+ if (fdebug && i < 5)
+ msgout("StartAsyncMesgPoll [%d] ret = %d\n",i,ret);
+ // os_usleep(0,5000); /* poll interval 5 msec */
+ os_usleep(1,0); /* poll interval 1 sec */
+ }
+ return((ThreadRType)0);
+}
+
+static int GetBmcLanChannel(uchar *chan)
+{
+ int ret = 0;
+ int j;
+ int rlen;
+ uchar iData[2];
+ uchar rData[10];
+ uchar cc;
+ uchar mtype;
+ uchar chn = 1;
+
+ if (vend_id == VENDOR_INTEL) {
+ if (prod_id == 0x000C || prod_id == 0x001B) {
+ *chan = 7;
+ return(ret);
+ }
+ }
+ for (j = 1; j < 12; j++) {
+ rlen = sizeof(rData);
+ iData[0] = (uchar)j; /*channel #*/
+ memset(rData,0,9); /*initialize recv data*/
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug);
+ if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */
+ continue;
+ if (ret != 0) {
+ if (fdebug) printf("get_chan_info rc = %x\n",ret);
+ break;
+ }
+ mtype = rData[1]; /* channel medium type */
+ if (mtype == 4) { /* 802.3 LAN type*/
+ if (fdebug) printf("chan[%d] = lan\n",j);
+ chn = (uchar)j;
+ break;
+ }
+ }
+ *chan = chn;
+ return(ret);
+}
+
+int SoftwareIdResponse(uchar *buf, int blen, uchar hnd, uchar chan)
+{
+ int rv = 0;
+ uchar resp[12] = {0,0xa6,0,0,0,1,0,0x00,0x01,0x57,0x00,0x01};
+#ifdef WIN32
+ /* check OS version & arch (32/64) */
+#else
+ struct utsname uts;
+ rv = uname(&uts);
+ // uts.release=`uname -r` uts.machine=x86_64,ia64,i586,i386
+ // kver <= 24 bytes, mach/arch <= 6 bytes
+#endif
+
+#ifdef USE_LANMSG
+ rv = SendTimedLanMessageResponse_Ex( (ImbPacket *)buf, (char *)(&resp), 12,
+ IMBPTIMEOUT, hnd, chan);
+#else
+ rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, (char *)(&resp), 12,
+ IMBPTIMEOUT, hnd,chan);
+#endif
+ if (fdebug) msgout("SoftwareIdResponse(%d) ret = %d\n",chan,rv);
+ return(rv);
+}
+
+
+int SmsOsResponse(uchar *buf, int blen, uchar func, uchar hnd, uchar chan)
+{
+ int rv = 0;
+ char cc = 0;
+ if (frunscript) {
+ write_syslog("igetevent -a running script\n");
+ rv = system(run_script);
+ if (fdebug) msgout("run(%s) ret = %d\n",run_script,rv);
+ }
+ switch(func) /*data byte has function*/
+ {
+ case 0x01: /*shutdown & power down*/
+ rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, &cc,1,
+ IMBPTIMEOUT, hnd,chan);
+ if (fdebug) msgout("OsResponse(%d) ret = %d\n",chan,rv);
+ if (!fAsyncNOP) {
+ write_syslog("igetevent -a initiating OS shutdown\n");
+ rv = system(SHUTDOWN_CMD);
+ if (fdebug) msgout("shutdown ret = %d\n",rv);
+ }
+ break;
+ case 0x02: /*shutdown & reset*/
+ rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, &cc,1,
+ IMBPTIMEOUT, hnd,chan);
+ if (fdebug) msgout("OsResponse(%d) ret = %d\n",chan,rv);
+ if (!fAsyncNOP) {
+ write_syslog("igetevent -a initiating OS reboot\n");
+ rv = system(REBOOT_CMD);
+ if (fdebug) msgout("reboot ret = %d\n",rv);
+ }
+ break;
+ default:
+ if (fdebug) msgout("igetevent -a unknown function %d\n",func);
+ rv = 1;
+ break;
+ }
+ return(rv);
+}
+
+/*
+ * get_imb_event
+ * This only gets certain IMB events, like
+ * OS requests (e.g. shutdown), and get_software_id
+ */
+static int get_imb_event(uchar etype, int timeout, uchar *evt)
+{
+ int ret = -1;
+ int i;
+ int done = 0;
+ ulong mlen;
+ uchar buffer[512];
+ uchar sendbuf[18];
+ static uint asyseqnum = 0;
+ uchar chan;
+ uchar sessHandle = 0;
+ uchar privilege = 0;
+ uchar cmd, func;
+ // uchar *pbuf;
+
+ ret = GetBmcLanChannel(&chan);
+
+ /* clean out pre-existing async messages */
+ while(1) {
+ mlen = sizeof(buffer);
+ if (GetAsyncImbpMessage((ImbPacket *)buffer,&mlen, IMBPTIMEOUT,
+ &asyseqnum, IPMB_CHANNEL) != 0)
+ break;
+ if (fdebug) msgout("cleaned out an IPMB message seq=%d\n",asyseqnum);
+ }
+ while(1) {
+ mlen = sizeof(buffer);
+ if (GetAsyncImbpMessage((ImbPacket *)buffer,&mlen, IMBPTIMEOUT,
+ &asyseqnum, LAN_CHANNEL) != 0)
+ break;
+ if (fdebug) msgout("cleaned out a LAN message seq=%d\n",asyseqnum);
+ }
+ ret = RegisterForImbAsyncMessageNotification(&imb_handle);
+ if (fdebug)
+ msgout("RegisterForImbAsync ret=%d, handle=%x\n",ret,imb_handle);
+ if (ret != 0) {
+ msgout("RegisterAsync error %d\n",ret);
+ return(ret);
+ }
+
+ for (i = 0; (timeout == 0) || (i < timeout); i++)
+ { /*get one imb event*/
+ if (fdebug) msgout("IsAsyncMessageAvailable ...\n");
+ if (IsAsyncMessageAvailable(imb_handle) == 0)
+ {
+ if (fdebug) msgout("Async Message is Available\n");
+ mlen = sizeof(buffer);
+ ret = GetAsyncImbpMessage_Ex ((ImbPacket *)buffer, &mlen,
+ IMBPTIMEOUT, &asyseqnum, ANY_CHANNEL,
+ &sessHandle, &privilege);
+ /* Hack: buffer contains an extra byte to return channel */
+ if (fdebug)
+ msgout("GetAsync(%d,%d) ret = %d, newchan=%x\n",
+ asyseqnum,chan,ret,buffer[mlen]);
+ if (ret == 0) {
+ /* get the async message command */
+ if (fdebug) dump_buf("async msg",buffer,mlen+1,0);
+ chan = buffer[mlen];
+ if (mlen > 16) mlen = 16;
+ if (buffer[0] == sms_sa) {
+ memcpy(&sendbuf[0],buffer,mlen);
+ } else { /* handle shorter format for some BMCs */
+ sendbuf[0] = sms_sa;
+ memcpy(&sendbuf[1],buffer,mlen);
+ }
+ cmd = sendbuf[5]; func = sendbuf[6];
+ msgout("got async msg: cmd=%02x len=%d\n",cmd,mlen);
+ memcpy(evt,sendbuf,mlen);
+
+ switch(cmd) {
+ case CMD_GET_SOFTWARE_ID: /*Get Software ID*/
+ ret = SoftwareIdResponse(sendbuf,mlen,sessHandle,chan);
+ break;
+ case CMD_SMS_OS_REQUEST: /*SMS OS Request*/
+ ret = SmsOsResponse(sendbuf,mlen,func,sessHandle,chan);
+ if (ret == 0) done = 1;
+ break;
+ default:
+ ret = LAN_ERR_INVPARAM;
+ msgout("SmsOS cmd %02x unknown, ret = %d\n",cmd,ret);
+ }
+ if (fdebug)
+ msgout("async msg cmd=%02x ret = %d\n",cmd,ret);
+ if (done == 1) {
+ if (func == 0x01) msgout("shutting down\n");
+ else msgout("rebooting\n");
+ ret = 0x81;
+ break;
+ }
+ }
+ } /*endif have an event*/
+ else ret = 0x80; /* no event yet */
+ } /*loop for one event*/
+ if (fdebug) msgout("Unregister for imb events\n");
+ UnRegisterForImbAsyncMessageNotification (imb_handle,0);
+ return(ret);
+}
+#endif
+ /*endif DO_ASYNC*/
+
+#ifdef DO_MVL
+/* Linux, enable MV OpenIPMI interface */
+extern int register_async_mv(uchar cmd, uchar netfn); /*see ipmimv.c*/
+extern int unregister_async_mv(uchar cmd, uchar netfn); /*see ipmimv.c*/
+extern int getevent_mv(uchar *evt_data, int *evt_len, uchar *cc, int t);
+extern int ipmi_rsp_mv(uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, char fdebugcmd);
+
+static int send_mv_asy_resp(uchar *evt)
+{
+ uchar cmd, sa, bus, cc;
+ uchar data0[12] = {0,0xa6,0,0,0,1,0,0x00,0x01,0x57,0x00,0x01};
+ uchar data1[1] = { 0x00 };
+ uchar rdata[80];
+ int sdata, rlen, i;
+ uchar *pdata;
+ int rv = -1;
+
+ cmd = evt[2];
+ sa = sms_sa; /* sa = SMS_SA (0x81) */
+ bus = 0x01; /* usu lan_ch == 1 */
+ switch(cmd) {
+ case CMD_GET_SOFTWARE_ID: /*software id*/
+ pdata = &data0[0];
+ sdata = sizeof(data0);
+ break;
+ case CMD_SMS_OS_REQUEST: /*restart*/
+ pdata = &data1[0];
+ sdata = sizeof(data1);
+ break;
+ default: rv = LAN_ERR_INVPARAM; return (rv);
+ break;
+ }
+ rv = ipmi_rsp_mv(cmd, (NETFN_APP | 0x01), sa, bus, BMC_LUN,
+ pdata,sdata, fdebug);
+ if (rv == 0) {
+ for (i = 0; i < 5; i++)
+ {
+ rlen = sizeof(rdata);
+ rv = getevent_mv(rdata,&rlen,&cc,1);
+ if (fdebug) msgout("send_mv_asy_resp: rv=%d cc=%x\n",rv,cc);
+ if (rv == 0 && cc == 0) {
+ if (fdebug) msgout("got rsp ccode: type=%02x len=%d cc=%x\n",
+ rdata[0],rlen,rdata[3]);
+ if (rlen > 0) rv = rdata[3]; /*cc*/
+ break;
+ }
+ os_usleep(0,5000); /*wait 5 ms*/
+ }
+ }
+ return (rv);
+}
+
+static int get_mv_asy_event(uchar cmd, int timeout, uchar *evt)
+{
+ int ret = -1;
+ int rv = -1;
+ uchar cc = 0;
+ uchar rdata[120];
+ int rlen, i;
+
+ rv = register_async_mv(cmd,NETFN_APP); /*reserved,GetSoftwareID*/
+ if (rv != 0) return(rv);
+
+ for (i = 0; (timeout == 0) || (i < timeout); i++)
+ { /*get one async event*/
+ rv = getevent_mv(rdata,&rlen,&cc,timeout);
+ if (fdebug)
+ msgout("get_mv_asy_event: i=%d cmd=%x rv=%d cc=%x\n",i,cmd,rv,cc);
+ if (rv == 0 && cc == 0) {
+ msgout("got async msg: type=%02x cmd=%x len=%d\n",
+ rdata[0],rdata[2],rlen);
+ if (fdebug) dump_buf("async msg",rdata,rlen,0);
+ /* check recv_type == 3 (IPMI_CMD_RECV_TYPE) */
+ if (rdata[0] == 3 && rdata[2] == cmd) {
+ if (rlen > 16) rlen = 16;
+ memcpy(evt,rdata,rlen);
+ break;
+ } else { /*else msg, but no match*/
+ rv = ERR_BAD_PARAM;
+ break;
+ }
+ }
+ else do_wait(wait_interval); /*wait 1 sec*/
+ }
+ ret = unregister_async_mv(cmd,NETFN_APP); /*reserved,GetSoftwareID*/
+ return(rv);
+}
+#endif
+
+static int get_evt_method(char *evtmethod)
+{
+ int method = METHOD_UNKNOWN;
+ if (fAsync) {
+ if (drvtype == DRV_MV) method = METHOD_ASYNC_MV;
+ else /* if (drvtype == DRV_IMB) */ method = METHOD_ASYNC_IMB;
+ } else if (fselevts) method = METHOD_SEL_EVTS;
+ else { /*fmsgevts*/
+ if (drvtype == DRV_MV) method = METHOD_MSG_MV;
+ else method = METHOD_MSG_GET;
+ }
+ if (evtmethod != NULL)
+ strcpy(evtmethod,methodstr[method]);
+ return(method);
+}
+
+static int get_sel_entry(ushort recid, ushort *nextid, uchar *rec)
+{
+ uchar ibuf[6];
+ uchar rbuf[32];
+ int rlen;
+ ushort xid, id = 0;
+ uchar cc;
+ int rv;
+
+ ibuf[0] = 0;
+ ibuf[1] = 0;
+ ibuf[2] = (recid & 0x00ff);
+ ibuf[3] = (recid & 0xff00) >> 8;
+ ibuf[4] = 0;
+ ibuf[5] = 0xFF; /*get entire record*/
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmd(GET_SEL_ENTRY, ibuf, 6, rbuf, &rlen, &cc, fdebug);
+ if (rv == 0) {
+ if (cc != 0) rv = cc;
+ else { /*success*/
+ xid = rbuf[0] + (rbuf[1] << 8); /*next rec id*/
+ memcpy(rec,&rbuf[2],16);
+ *nextid = xid;
+ id = rbuf[2] + (rbuf[3] << 8); /*curr rec id*/
+ /* recid (requested) should match newid (received) */
+ if (fdebug) {
+ if ((recid != id) && (recid != LAST_REC) && (recid != 0)) {
+ /* the OpenIPMI driver does this sometimes */
+ msgout("get_sel MISMATCH: recid=%x newid=%x next=%x\n",
+ recid,id,xid);
+ dump_buf("get_sel cmd",ibuf,6,0);
+ dump_buf("get_sel rsp",rbuf,rlen,0);
+ }
+ }
+ }
+ }
+ if (fdebug) msgout("get_sel(%x) rv=%d cc=%x id=%x next=%x\n",
+ recid,rv,cc,id,*nextid);
+ return(rv);
+}
+
+static int startevent_sel(ushort *precid, uint *ptime)
+{
+ FILE *fd;
+ uchar rec[24];
+ uint t = 0;
+ ushort r = 0;
+ ushort r2 = 0;
+ int rv = -1;
+
+ fd = fopen(idxfile,"r");
+ if (fd == NULL) fd = fopen(idxfile2,"r"); /*handle old location*/
+ if (fdebug) msgout("start: idxfile=%s fd=%p\n",idxfile,fd);
+ if (fd != NULL) {
+ // Read the file, get savtime & savid
+ rv = fscanf(fd,"%x %x",&t,&r);
+ fclose(fd);
+ if (r == LAST_REC) r = 0;
+ rv = 0; /*read it, success*/
+ } else { /* treat as first time */
+ r = LAST_REC;
+ rv = get_sel_entry(r,&r2,rec);
+ if (rv == 0) {
+ memcpy(&t,&rec[3],4);
+ r = rec[0] + (rec[1] << 8); /*use current rec id*/
+ } else r = 0;
+ rv = 1; /*first time*/
+ }
+ if (fdebug) msgout("start: recid=%x time=%x\n",r,t);
+ *ptime = t;
+ *precid = r;
+ return(rv);
+}
+
+static int syncevent_sel(ushort recid, uint itime)
+{
+ FILE *fd;
+ int rv;
+ // Rewrite the saved time & record id
+ if (fdebug) msgout("sync: recid=%x time=%x\n",recid,itime);
+ fd = fopen(idxfile,"w");
+ if (fd == NULL) {
+ msgout("syncevent: cannot open %s for writing\n",idxfile);
+ rv = -1;
+ } else {
+ fprintf(fd,"%x %x\n",itime,recid);
+ fclose(fd);
+ rv = 0;
+ }
+ return(rv);
+}
+
+int getevent_sel(uchar *rdata, int *rlen, uchar *ccode)
+{
+ uchar rec[24];
+ int rv = 0;
+ ushort newid;
+ ushort nextid;
+ ushort recid;
+
+ /* get current last record */
+ recid = sel_recid;
+ rv = get_sel_entry(recid,&nextid,rec);
+ if (rv == 0xCB && recid == 0) { /* SEL is empty */
+ *ccode = (uchar)rv; /* save the real ccode */
+ rv = 0x80; /* this is ok, just keep waiting */
+ }
+ if (rv == 0) {
+ if (fdebug) msgout("sel ok, id=%x next=%x\n",recid,nextid);
+ if ((nextid == LAST_REC) || (recid == nextid)) {
+ *ccode = 0x80; /*nothing new*/
+ } else {
+ recid = nextid; /* else get new one */
+ rv = get_sel_entry(recid,&nextid,rec);
+ if (rv == 0) { /* new event */
+ newid = rec[0] + (rec[1] << 8);
+ if (drvtype == DRV_MV && recid != newid) {
+ /* handle MV driver bug, try to get next one. */
+ if (fdebug) msgout("%s bug, record mismatch\n",
+ show_driver_type(DRV_MV));
+ }
+ if (fdebug) msgout("recid=%x newid=%x next=%x\n",
+ recid,newid,nextid);
+ memcpy(rdata,rec,16);
+ *rlen = 16;
+ *ccode = 0;
+ sel_recid = recid; /*or newid*/
+ memcpy(&sel_time,&rec[3],4);
+ }
+ }
+ }
+ else { /* Error reading last recid saved */
+ if (fdebug) msgout("sel recid %x error, rv = %d\n",recid,rv);
+ /* We want to set sel_recid = 0 here for some errors. */
+ if (rv == 0xCB || rv == 0xCD) { /* empty, or wrong SDR id */
+ sel_recid = 0;
+ *ccode = (uchar)rv;
+ rv = 0x80; /* wait again */
+ }
+ }
+ return(rv);
+}
+
+static int get_event(uchar etype, uchar snum, int timeout,
+ uchar *evt, uchar *stype)
+{
+ int ret = 0;
+ uchar rdata[64];
+ int rlen;
+ uchar ccode;
+ int fretry;
+ int i;
+
+ for (i = 0; (timeout == 0) || (i < timeout); i++)
+ {
+ rlen = sizeof(rdata);
+ fretry = 0; ccode = 0;
+ if (fselevts) {
+ ret = getevent_sel(rdata,&rlen,&ccode);
+ } else
+#ifdef DO_MVL
+ if (drvtype == DRV_MV) { /* if MV OpenIPMI driver (Linux only) */
+ if (timeout == 0) wait_interval = 0;
+ /* use special MV API instead (see ipmimv.c) */
+ ret = getevent_mv(rdata,&rlen,&ccode,timeout);
+ } else
+#endif
+ ret = ipmi_cmd(READ_EVENT_MSGBUF,NULL,0,rdata,&rlen,&ccode,fdebug);
+ /* now we have an event from one of the above methods*/
+
+ /* IPMI 1.5 spec, section 18.8 says cc 0x80 means
+ * "data not available (queue/buffer empty)" */
+ if (ret == 0 && ccode != 0) { ret = ccode; }
+ if (ret == 0x80) {
+ fretry = 1;
+ do_wait(wait_interval); /*wait 1 sec*/
+ } else {
+ if (ret == 0) {
+ char ismatch = 0;
+ /* parse event types for a specified type */
+ /* etype param == 0xff means get any event */
+ /* rdata[10] is sensor_type, rdata[11] is sensor_num */
+ if ((etype == 0xff) || (etype == rdata[10])) ismatch++;
+ if ((snum == 0xff) || (snum == rdata[11])) ismatch++;
+ if (ismatch == 2) {
+ /*event sensor type matches*/
+ memcpy(evt,rdata,rlen);
+ *stype = rdata[10]; /* return sensor type */
+ } else { /* keep looking */
+ do_wait(wait_interval);
+ continue;
+ }
+ }
+ /* if here, either got one, or need to return error */
+ break;
+ }
+ } /*end for loop*/
+ return(ret);
+}
+
+int send_nmi(void)
+{
+ uchar idata[8];
+ uchar rdata[30];
+ int rlen;
+ uchar ccode;
+ int ret;
+
+ idata[0] = 4; /* do NMI */
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw( CHASSIS_CTL, NETFN_CHAS, BMC_SA,PUBLIC_BUS,BMC_LUN,
+ idata,1, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+}
+
+void show_event(uchar *evt,char *obuf, int sz)
+{
+ int i;
+ char sysbuf[250];
+ /* obuf should be 132 chars or more */
+
+ msgout("event data: ");
+ for (i=0; i<16; i++) msgout("%02x ",evt[i]);
+ msgout("\n");
+
+ decode_sel_entry(evt,obuf,sz);
+ msgout(obuf); /*writes to outfile*/
+ /* write the message to syslog also. */
+ snprintf(sysbuf,sizeof(sysbuf),"%s: %s",progname,obuf);
+ write_syslog(sysbuf);
+}
+
+static void ievt_cleanup(void)
+{
+ char obuf[48];
+ if (fselevts) syncevent_sel(sel_recid,sel_time);
+ snprintf(obuf,sizeof(obuf),"%s exiting.\n",progname);
+ msgout(obuf);
+ write_syslog(obuf);
+ free_sdr_cache(sdrs);
+ iclose();
+ exit(EXIT_SUCCESS);
+}
+
+#if defined(WIN32) | defined(DOS)
+/* no daemon code */
+static void ievt_siginit(void) { return; }
+#else
+/* Linux daemon code */
+#include <signal.h>
+static void ievt_sighnd(int sig)
+{
+ ievt_cleanup();
+ exit(EXIT_SUCCESS);
+}
+
+static void ievt_siginit(void);
+static void ievt_siginit(void)
+{
+ struct sigaction sact;
+
+ /* handle signals for cleanup */
+ sact.sa_handler = ievt_sighnd;
+ sact.sa_flags = 0;
+ sigemptyset(&sact.sa_mask);
+ sigaction(SIGINT, &sact, NULL);
+ sigaction(SIGQUIT, &sact, NULL);
+ sigaction(SIGTERM, &sact, NULL);
+}
+
+static int mkdaemon(int fchdir, int fclose);
+static int mkdaemon(int fchdir, int fclose)
+{
+ int fdlimit = sysconf(_SC_OPEN_MAX); /*fdlimit usu = 1024.*/
+ int fd = 0;
+
+
+ fdlimit = fileno(stderr); /*only close files up to stderr*/
+ switch (fork()) {
+ case 0: break;
+ case -1: return -1;
+ default: _exit(0); /* exit the original process */
+ }
+ if (setsid() < 0) return -1; /* shouldn't fail */
+ switch (fork()) {
+ case 0: break;
+ case -1: return -1;
+ default: _exit(0); /* exit the original process */
+ }
+ if (fchdir) {
+ chdir("/");
+ /* umask(0022); * leave file creation mask at default (0022) & 0777 */
+ }
+ if (fclose) {
+ /* Close stdin,stdout,stderr and replace them with /dev/null */
+ for (fd = 0; fd < fdlimit; fd++) close(fd);
+ open("/dev/null",O_RDWR);
+ dup(0); dup(0);
+ }
+ return 0;
+}
+#endif
+
+static void iclose()
+{
+ /* close out any IPMI handles or sessions */
+#ifdef THREADS_OK
+#ifdef WIN32
+ if (threadid != NULL) CloseHandle(threadid);
+#else
+ /* thread close not needed in Linux */
+#endif
+#endif
+ ipmi_close_();
+ if (fbackground && fdout != NULL) fclose(fdout);
+}
+
+#ifdef METACOMMAND
+int i_getevt(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int c, j;
+ uchar devrec[16];
+ uchar event[16];
+ uchar sa, lun;
+ uchar enables = 0;
+ uchar fevmsgok = 0;
+ uchar sensor_type = 0;
+ uchar msg_flags = 0;
+ FILE *fp;
+ char outbuf[160];
+ char tmpout[20];
+ char *sdesc;
+
+ fdout = stdout;
+ msgout("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt(argc,argv,"abce:lmn:or:st:uvT:V:J:YEF:P:N:R:U:Z:x?")) != EOF )
+ switch(c) {
+ case 'a': fAsync = 1; /* imb async message method */
+ /* chenge the output log filename */
+ sdesc = strstr(outfile,"evt.log");
+ if (sdesc != NULL) strcpy(sdesc,"asy.log");
+ break;
+ case 'b': fbackground = 1; break; /* background */
+ case 'c': fcanonical = 1; break; /* canonical */
+ case 'e': /* event sensor type */
+ if (strncmp(optarg,"0x",2) == 0)
+ evt_stype = htoi(&optarg[2]);
+ else evt_stype = atob(optarg);
+ break;
+ case 'l': fAsyncNOP = 1; break; /* do not reset (for testing)*/
+ case 'm': fmsgevts = 1; break; /* use local getmessage method */
+ case 'n': /* event sensor num, always hex */
+ if (strncmp(optarg,"0x",2) == 0)
+ evt_snum = htoi(&optarg[2]);
+ else evt_snum = htoi(&optarg[0]);
+ break;
+ case 'o': frunonce = 1; break; /* only run once for first event */
+ case 'r': /* run script (or binary) on an event */
+ run_script = optarg;
+ fp = fopen(run_script,"r");
+ if (fp == NULL) {
+ printf("cannot open %s\n",run_script);
+ ret = ERR_FILE_OPEN;
+ goto do_exit;
+ } else {
+ fclose(fp);
+ frunscript = 1;
+ }
+ break;
+ case 's': fselevts = 1; break; /* use SEL event method*/
+ case 't': timeout = atoi(optarg); fsettime = 1; break; /*timeout*/
+ case 'u': futc = 1; break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'v': fdebug = 3; break; /* verbose debug with lan */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-abenorsux -t sec -NPRUEFTVY]\n", progname);
+ printf(" where -a use Async method\n");
+ printf(" -b run in Background\n");
+ printf(" -c use Canonical/delimited event format\n");
+ printf(" -e T wait for specific event sensor type T\n");
+ printf(" -n N wait for specific event sensor num N\n");
+ printf(" -o run Once for the first event\n");
+ printf(" -r F Run file F when an event occurs\n");
+ printf(" -s use SEL event method\n");
+ printf(" -t N set timeout to N seconds\n");
+ printf(" -u use raw UTC time\n");
+ printf(" -x show eXtra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ fipmilan = is_remote();
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ if (vend_id == VENDOR_INTEL) {
+ if (prod_id == 0x003E) /* NSN2U or CG2100 Urbanna */
+ sms_sa = 0x41;
+ }
+ }
+
+ /* get event receiver */
+ ret = get_event_receiver(&sa ,&lun);
+ if (ret != 0)
+ msgout("event receiver error %d\n",ret);
+ else msgout("event receiver sa = %02x lun = %02x\n",sa,lun);
+
+ ret = get_bmc_enables(&enables);
+ if (ret != 0) msgout("bmc enables error %d\n",ret);
+ else {
+ msgout("bmc enables = %02x\n",enables);
+ if ((enables & 0x02) == 2) fevmsgok = 1;
+ else fevmsgok = 0;
+ }
+ if (fevmsgok == 0 && !fipmilan) {
+ msgout("Event Message Buffers not enabled.\n");
+ enables |= 0x0f; /* 0x08=SEL, 0x02=EvtMsgBuf, rest is gravy */
+ ret = set_bmc_enables(enables);
+ if (ret != 0) {
+ msgout("set_bmc_enables error 0x%x\n",ret);
+ }
+ else msgout("set_bmc_enables success\n");
+ }
+ if (fipmilan && !fselevts) {
+ msgout("Only the SEL method (-s) is supported over IPMI LAN\n");
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+ }
+ ret = get_msg_flags(&msg_flags);
+ msgout("igetevent reading sensors ...\n");
+ write_syslog("igetevent reading sensors ...\n");
+ ret = get_sdr_cache(&sdrs);
+ // if (!fipmilan) set_sel_opts(1,0, NULL,fdebug);
+ if (fdebug) msgout("get_sdr_cache ret = %d\n",ret);
+ if (ret == 0) set_sel_opts(1, fcanonical, sdrs,fdebug,futc);
+ else ret = 0; /*if error, keep going anyway*/
+
+ if (fselevts) {
+#ifdef WIN32
+ { /*resolve path of idxfile*/
+ char *ipath;
+ ipath = getenv("ipmiutildir"); /*ipmiutil directory path*/
+ if (ipath != NULL) {
+ if (strlen(ipath)+12 < sizeof(idxfile)) {
+ sprintf(idxfile,"%s\\%s",ipath,"\\",IDXFILE);
+ }
+ }
+ }
+#endif
+
+ if (fipmilan) {
+ char *node;
+ node = get_nodename();
+ strcat(idxfile,"-");
+ strcat(idxfile,node);
+ strcat(idxfile2,"-");
+ strcat(idxfile2,node);
+ strcat(outfile,"-");
+ strcat(outfile,node);
+ }
+ ret = startevent_sel(&sel_recid,&sel_time);
+ ret = 0; /*ignore any earlier errors, keep going*/
+ }
+
+ drvtype = get_driver_type();
+ if (fdebug) msgout("driver_type = %d (%s)\n",
+ drvtype,show_driver_type(drvtype));
+
+ if (evt_stype == 0xFF) sdesc = "any event";
+ else sdesc = get_sensor_type_desc(evt_stype);
+ if (evt_snum == 0xFF) tmpout[0] = 0;
+ else sprintf(tmpout,"with snum %02x",evt_snum);
+ if (evt_stype != 0xFF || evt_snum != 0xFF)
+ msgout("Look for event sensor type %02x (%s) %s\n", evt_stype,sdesc,tmpout);
+
+#ifdef TEST_SEL
+ /* This is used to verify that the interface returns valid next ids,
+ * and that the get_sel_entry is ok. */
+ {
+ int i;
+ ushort r, r1, r2;
+ uchar rec[40];
+ int rv;
+ r = 0;
+ for (i = 0; i < 4; i++)
+ {
+ rv = get_sel_entry(r,&r2,rec);
+ if (rv == 0) {
+ r1 = rec[0] + (rec[1] << 8); /*get current rec id*/
+ if (fdebug) msgout("get_sel: r=%x r1=%x rnext=%x\n",r,r1,r2);
+ show_event(&rec[0],outbuf,sizeof(outbuf));
+ r = r2;
+ } else break;
+ }
+ }
+#endif
+ if (drvtype == DRV_IMB) fAsyncOK = 1;
+ else if (drvtype == DRV_MV) {
+ if (fsettime == 0) timeout = 0; /*DRV_MV default to infinite*/
+ fAsyncOK = 1;
+ } else fAsyncOK = 0;
+
+ if (fAsync && (!fAsyncOK)) {
+ msgout("Cannot open %s or %s driver, required for -a\n",
+ show_driver_type(DRV_IMB),show_driver_type(DRV_MV));
+ ret = ERR_NO_DRV;
+ goto do_exit;
+ }
+
+ if (fbackground) { /* convert to a daemon if background */
+#ifdef WIN32
+ msgout("Background not implemented for Windows\n");
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+#elif defined(DOS)
+ msgout("Background not implemented for DOS\n");
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+#else
+ /* make sure we can open the log file before doing mkdaemon */
+ fdout = fopen(outfile,"a");
+ if (fdout == NULL)
+ printf("%s: Cannot open %s\n", progname,outfile);
+ else {
+ pid_t p;
+ fclose(fdout);
+
+ ret = mkdaemon(1,1);
+ if (ret != 0) {
+ msgout("%s: Cannot become daemon, ret = %d\n", progname,ret);
+ goto do_exit;
+ }
+ /* open a log file for messages, set fdout */
+ fdout = fopen(outfile,"a");
+#ifdef METACOMMAND
+ /* make sure driver debug also goes to log */
+ fpdbg = fdout;
+ fperr = fdout;
+#endif
+ p = getpid();
+ msgout("PID %d: %s ver %s\n",p,progname,progver); /*log start message*/
+ }
+#endif
+ }
+ ievt_siginit();
+
+ if (fAsync && (fAsyncOK)) /*use imb/mv async messages*/
+ {
+ msgout("Wait for an async event\n"); /* no timeout */
+ if (drvtype == DRV_IMB)
+ {
+#ifdef DO_ASYNC
+#ifdef THREADS_OK
+#ifdef WIN32
+ /* Windows threads */
+ threadid = CreateThread(NULL, 0, &pollThread, NULL, 0, NULL);
+ if (threadid == NULL) pollThread(NULL);
+#else
+ /* Linux threads */
+ ret = pthread_create( &threadid, NULL, pollThread, (void*) message);
+ // if (ret == 0) pthread_join( threadid, NULL);
+ // if (ret == 0) pthread_detach( threadid);
+#endif
+ if (fdebug) msgout("pollThread create ret=%d handle=%x\n",ret,threadid);
+#else
+ /* no threads */
+ pollThread(NULL);
+#endif
+ while (ret == 0)
+ { /*wait for imb message events*/
+ msgout("Waiting %d seconds for an async event ...\n",timeout);
+ ret = get_imb_event(0xff,timeout,event);
+ if (ret == 0x81) { /*ok, shutting down OS*/
+ ret = 0;
+ break;
+ }
+ if (frunonce) break;
+ if (timeout == 0 && ret == 0x80) { /*0x80 = no data yet */
+ if (fdebug) msgout("get_event timeout, no event yet.\n");
+ do_wait(wait_interval);
+ ret = 0; /*ok, keep going*/
+ }
+ }
+#endif
+ } /*endif DRV_IMB*/
+#ifdef DO_MVL
+ else { /*DRV_MV*/
+ int stage;
+ stage = 0;
+ while (stage < 3)
+ { /*wait for mv message events*/
+ if (fdebug) msgout("Waiting for async_mv event, stage %d\n",stage);
+ if (stage == 0) {
+ ret = get_mv_asy_event(CMD_GET_SOFTWARE_ID,timeout,event);
+ if (fdebug) msgout("got SmsOS GetSWID event ret = %d\n",ret);
+ /* send a reply */
+ if (ret == 0) ret = send_mv_asy_resp(event);
+ if (ret == 0) stage = 1; /* got the SoftwareID request/response */
+ else stage = 0;
+ }
+ if (stage == 1) {
+ /* get the reset command */
+ memset(event,0,sizeof(event));
+ ret = get_mv_asy_event(CMD_SMS_OS_REQUEST,timeout,event);
+ if (fdebug) msgout("got SmsOS GetSmsOS event ret = %d\n",ret);
+ if (ret == 0) ret = send_mv_asy_resp(event);
+ if (ret == 0) stage = 2;
+ else stage = 0;
+ }
+ if (stage == 2) { /* got the SmsOs request in event */
+ uchar cmd, func;
+ cmd = event[2];
+ func = event[3];
+ if (cmd != CMD_SMS_OS_REQUEST) { /*cmd*/
+ ret = LAN_ERR_INVPARAM;
+ if (fdebug) msgout("SmsOS cmd %x ret = %d\n",cmd,ret);
+ } else {
+ if (frunscript) {
+ write_syslog("igetevent -a running script\n");
+ ret = system(run_script);
+ if (fdebug) msgout("run(%s) ret = %d\n",run_script,ret);
+ }
+ if (!fAsyncNOP)
+ switch(func) { /*subfunction*/
+ case 0x01: /*shutdown & power down*/
+ write_syslog("igetevent -a OS shutdown\n");
+ ret = system(SHUTDOWN_CMD);
+ msgout("SmsOs shutdown, ret = %d\n",ret);
+ break;
+ case 0x02: /*shutdown & reboot*/
+ write_syslog("igetevent -a OS reboot\n");
+ ret = system(REBOOT_CMD);
+ msgout("SmsOs reboot, ret = %d\n",ret);
+ break;
+ case 0x03: /*send NMI locally*/
+ write_syslog("igetevent -a NMI\n");
+ ret = send_nmi();
+ msgout("SmsOs NMI, ret = %d\n",ret);
+ default:
+ ret = LAN_ERR_INVPARAM;
+ msgout("SmsOS func %02x, ret = %d\n",func,ret);
+ break;
+ }
+ }
+ if (ret == 0) stage = 3; /*done, exit loop*/
+ else {
+ if (fdebug) msgout("SmsOS error = %d, start over\n",ret);
+ stage = 0; /*start over*/
+ }
+ } /*endif stage 2*/
+ } /*end-while*/
+ } /*end else DRV_MV*/
+#endif
+
+ } else { /*not Async, std IPMI events */
+ if (fselevts) {
+ msgout("Get IPMI SEL events after ID %04x\n",sel_recid);
+ } else
+ msgout("Get IPMI events from %s driver\n",show_driver_type(drvtype));
+ j = get_evt_method(tmpout);
+ sprintf(outbuf,"igetevent waiting for events via method %d (%s)\n",
+ j, tmpout);
+ msgout(outbuf);
+ write_syslog(outbuf);
+
+ /* loop on events here, like a daemon would. */
+ while (ret == 0)
+ { /*wait for bmc message events*/
+ msgout("Waiting %d seconds for an event ...\n",timeout);
+ /* note: could also get message flags here */
+ ret = get_event(evt_stype,evt_snum,timeout,event,&sensor_type);
+ if (fdebug) msgout("get_event ret = %d\n",ret);
+ if (ret == 0) { /* got an event successfully */
+ msgout("got event id %04x, sensor_type = %02x\n",
+ sel_recid, sensor_type);
+ show_event(event,outbuf,sizeof(outbuf));
+ if (fselevts) syncevent_sel(sel_recid,sel_time);
+ if (frunscript) { /*run some script for each event*/
+ char run_cmd[256];
+ sprintf(run_cmd,"%s \"%s\"\n",run_script,outbuf);
+ j = system(run_cmd);
+ msgout("run(%s $1), ret = %d\n",run_script,j);
+ ret = j; /*if that failed, exit loop*/
+ }
+ } else {
+ if (ret == 0x80) msgout("get_event timeout\n");
+ else msgout("get_event error: ret = 0x%x\n",ret);
+ }
+ if (frunonce) break;
+ if (timeout == 0 && ret == 0x80) { /*0x80 = no data yet */
+ if (fdebug) msgout("get_event timeout, no data yet.\n");
+ do_wait(wait_interval);
+ ret = 0; /*ok, keep going*/
+ }
+ } /*end while loop*/
+ }
+
+do_exit:
+ ievt_cleanup();
+ if (ret == 0x80) ret = 0;
+ // show_outcome(progname,ret); /*inert if background*/
+ return(ret);
+} /* end main()*/
+
+/* end getevent.c */
diff --git a/util/ihealth.c b/util/ihealth.c
new file mode 100644
index 0000000..6f6f0e1
--- /dev/null
+++ b/util/ihealth.c
@@ -0,0 +1,1153 @@
+/*
+ * ihealth.c (was bmchealth.c)
+ *
+ * This tool checks the health of the BMC via IPMI.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 03/22/06 Andy Cress - created
+ * 06/20/06 Andy Cress 0.6 - more vendor strings, add ping_node() stub for now
+ * 10/20/06 Andy Cress 1.1 - added -g for guid
+ * 01/10/07 Andy Cress 1.4 - added product strings
+ * 02/25/07 Andy Cress 2.8 - added more Chassis Status decoding
+ */
+/*M*
+Copyright (c) 2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include "ipmicmd.h"
+#include "oem_intel.h"
+
+#define SELFTEST_STATUS 0x04
+#define GET_POWER_STATE 0x07
+extern int get_BiosVersion(char *str);
+extern int get_SystemGuid(uchar *guid);
+extern int GetSDR(int id, int *next, uchar *recdata, int srecdata, int *rlen);
+extern int get_device_guid(char *pbuf, int *sz); /*subs.c*/
+extern int oem_supermicro_get_health(char *pstr, int sz); /*oem_supermicro.c*/
+extern int oem_supermicro_get_firmware_str(char *pstr, int sz); /*oem_supermicro.c*/
+
+/*
+ * Global variables
+ */
+static char * progname = "ihealth";
+static char * progver = "2.93";
+static char fdebug = 0;
+static char fipmilan = 0;
+static char fcanonical = 0;
+static char do_hsc = 0;
+static char do_me = 0;
+static char do_frusdr = 0;
+static char do_guid = 0;
+static char do_powerstate = 1;
+static char do_lanstats = 0;
+static char do_session = 0;
+static char do_systeminfo = 0;
+static char set_restore = 0;
+static char set_name = 0;
+static char set_os = 0;
+static char set_os2 = 0;
+static uchar restore_policy = 0;
+static uchar bChan = 0x0e;
+static char fmBMC = 0;
+static char bdelim = '='; /*delimiter to separate name/value pairs*/
+static char bcomma = ','; /*comma delimiter, may change if CSV*/
+static char lan_ch_restrict = 0;
+static int kcs_loops = 0;
+static int vend_id = 0;
+static int prod_id = 0;
+static char *pname = NULL;
+static char *pos = NULL;
+static char *pos2 = NULL;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+
+int oem_get_health(char *pstr, int sz)
+{
+ int rv;
+ switch(vend_id) {
+ case VENDOR_PEPPERCON:
+ case VENDOR_SUPERMICRO:
+ rv = oem_supermicro_get_health(pstr, sz);
+ break;
+ case VENDOR_SUPERMICROX:
+ rv = oem_supermicro_get_firmware_str(pstr,sz);
+ break;
+ default:
+ rv = LAN_ERR_NOTSUPPORT;
+ break;
+ }
+ if (fdebug) printf("oem_get_health rv = %d\n",rv);
+ return rv;
+}
+
+int get_lan_stats(uchar chan)
+{
+ uchar idata[2];
+ uchar rdata[20];
+ int rlen, rv;
+ uchar cc;
+ ushort *rw;
+
+ /* get BMC LAN Statistics */
+ idata[0] = chan;
+ idata[1] = 0x00; /*do not clear stats*/
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(GET_LAN_STATS, idata,2, rdata,&rlen, &cc, fdebug);
+ if (fdebug) printf("get_lan_stats: rv = %d, cc = %02x\n",rv,cc);
+ if (rv == 0) {
+ if (cc == 0) { /*success, show BMC LAN stats*/
+ rw = (ushort *)&rdata[0];
+ printf("IPMI LAN channel %d statistics: \n",chan);
+ printf(" \tReceived IP Packets %c %d\n",bdelim,rw[0]);
+ printf(" \tRecvd IP Header errors %c %d\n",bdelim,rw[1]);
+ printf(" \tRecvd IP Address errors %c %d\n",bdelim,rw[2]);
+ printf(" \tRecvd IP Fragments %c %d\n",bdelim,rw[3]);
+ printf(" \tTransmitted IP Packets %c %d\n",bdelim,rw[4]);
+ printf(" \tReceived UDP Packets %c %d\n",bdelim,rw[5]);
+ printf(" \tReceived Valid RMCP Pkts %c %d\n",bdelim,rw[6]);
+ printf(" \tReceived UDP Proxy Pkts %c %d\n",bdelim,rw[7]);
+ printf(" \tDropped UDP Proxy Pkts %c %d\n",bdelim,rw[8]);
+ } else if (cc == 0xc1) {
+ printf("IPMI LAN channel %d statistics: not supported\n",chan);
+ }
+ }
+ return(rv);
+}
+
+int get_session_info(uchar idx, int hnd, uchar *rdata, int *len)
+{
+ uchar idata[5];
+ int ilen, rlen, rv;
+ uchar cc;
+
+ ilen = 1;
+ idata[0] = idx;
+ if (idx == 0xFE) {
+ idata[1] = (uchar)hnd;
+ ilen = 2;
+ } else if (idx == 0xFF) {
+ idata[1] = (uchar)(hnd & 0x000000FF);
+ idata[2] = (uchar)((hnd & 0x0000FF00) >> 8);
+ idata[3] = (uchar)((hnd & 0x00FF0000) >> 16);
+ idata[4] = (uchar)((hnd & 0xFF000000) >> 24);
+ ilen = 5;
+ }
+ rlen = *len;
+ *len = 0;
+ rv = ipmi_cmdraw(CMD_GET_SESSION_INFO,NETFN_APP,
+ g_sa, g_bus, g_lun,
+ idata,ilen, rdata,&rlen,&cc, fdebug);
+ if (fdebug) printf("get_lan_stats: rv = %d, cc = %02x\n",rv,cc);
+ if (rv == 0) *len = rlen;
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ return(rv);
+}
+
+static char *sesstype_str(uchar c)
+{
+ uchar b;
+ char *s;
+ b = ((c & 0xf0) >> 4);
+ switch(b) {
+ case 0: s = "IPMIv1.5"; break;
+ case 1: s = "IPMIv2/RMCP+"; break;
+ default: s = "Other"; break;
+ }
+ return s;
+}
+
+static void show_session_info(uchar idx, uchar *sinfo,int len)
+{
+ int i;
+ char lan_type = 1;
+ if (fdebug) {
+ printf("Raw Session Info[%d]: ",idx);
+ for (i = 0; i < len; i++) printf("%02x ",sinfo[i]);
+ printf("\n");
+ }
+
+ printf("Session Info[%d]:\n",idx);
+ printf("\tSession Handle %c %d\n",bdelim,sinfo[0]);
+ printf("\tSession Slot Count %c %d\n",bdelim,(sinfo[1] & 0x3f));
+ printf("\tActive Sessions %c %d\n",bdelim,(sinfo[2] & 0x3f));
+ if (len <= 3) return;
+ printf("\tUser ID %c %d\n",bdelim,(sinfo[3] & 0x3f));
+ printf("\tPrivilege Level %c %d\n",bdelim,(sinfo[4] & 0x0f));
+ printf("\tSession Type %c %s\n",bdelim,sesstype_str(sinfo[5]));
+ printf("\tChannel Number %c %d\n",bdelim,(sinfo[5] & 0x0f));
+ if (len <= 6) return;
+ if (lan_type) {
+ printf("\tConsole IP %c %d.%d.%d.%d\n",bdelim,
+ sinfo[6],sinfo[7],sinfo[8],sinfo[9]);
+ printf("\tConsole MAC %c %02x:%02x:%02x:%02x:%02x:%02x\n",bdelim,
+ sinfo[10], sinfo[11], sinfo[12],
+ sinfo[13], sinfo[14], sinfo[15]);
+ printf("\tConsole Port %c %d\n",bdelim,
+ sinfo[16]+ (sinfo[17] << 8));
+ }
+}
+
+int get_session_info_all(void)
+{
+ int rv, len, nslots, i;
+ uchar sinfo[24];
+ nslots = 1;
+ for (i = 1; i <= nslots; i++) {
+ len = sizeof(sinfo);
+ rv = get_session_info(i,0,sinfo,&len);
+ if (fdebug) printf("get_session_info(%d): rv = %d\n",i,rv);
+ if (rv != 0) {
+ if ((rv == 0xCB) || (rv == 0xCC)) {
+ if (len >= 3) show_session_info(i,sinfo,len);
+ if (i > 1) rv = 0; /*no such idx, end */
+ }
+ break;
+ }
+ nslots = (sinfo[1] & 0x3F);
+ show_session_info(i,sinfo,len);
+ }
+ return(rv);
+}
+
+static int get_selftest_status(uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmdraw( SELFTEST_STATUS, NETFN_APP,
+ g_sa, g_bus, g_lun,
+ idata,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_selftest_status()*/
+
+static int get_last_selftest(uchar *val, int vlen)
+{
+ uchar idata[4];
+ uchar rdata[16];
+ int rlen;
+ uchar ccode;
+ int ret;
+
+ if (val == NULL) return(ERR_BAD_PARAM);
+ idata[0] = 0; /*0=first, 1=next*/
+ memset(rdata,0xFF,2); /*initial value = end-of-list*/
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw( 0x16, 0x30, g_sa, g_bus, g_lun,
+ idata,1, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ if (ret == 0) {
+ if (rlen <= 0) ret = LAN_ERR_BADLENGTH;
+ else {
+ if (rlen > vlen) rlen = vlen; /*truncate if too long*/
+ memcpy(val,rdata,rlen);
+ }
+ }
+ return(ret);
+}
+
+static int get_chassis_status(uchar *rdata, int *rsz)
+{
+ uchar idata[4];
+ uchar ccode;
+ int rlen;
+ int ret;
+
+ rlen = *rsz;
+ ret = ipmi_cmdraw( CHASSIS_STATUS, NETFN_CHAS,
+ g_sa, g_bus, g_lun,
+ idata,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ if (ret == 0) *rsz = rlen;
+ return(ret);
+} /*end chassis_status()*/
+
+static void show_chs_status(uchar *sbuf, int slen)
+{
+ char chs_strbuf[80];
+ char *pstr;
+ uchar state, b2, b3, b4;
+
+ pstr = &chs_strbuf[0];
+ state = sbuf[0] & 0x7f;
+ b2 = sbuf[1];
+ b3 = sbuf[2];
+ sprintf(pstr,"%s",(state & 0x01) ? "on" : "off");
+ printf("Chassis Status %c %02x %02x %02x %02x (%s, see below)\n",
+ bdelim,state,sbuf[1],sbuf[2],sbuf[3],pstr);
+ sprintf(pstr,"\tchassis_power %c ",bdelim);
+ if (state & 0x01) strcat(pstr,"on");
+ else strcat(pstr,"off");
+ if (state & 0x02) strcat(pstr,", overload");
+ if (state & 0x04) strcat(pstr,", interlock");
+ if (state & 0x08) strcat(pstr,", fault");
+ if (state & 0x10) strcat(pstr,", control error");
+ printf("%s\n",pstr);
+
+ sprintf(pstr,"\tpwr_restore_policy %c ",bdelim);
+ if (state & 0x20) strcat(pstr,"last_state");
+ else if (state & 0x40) strcat(pstr,"turn_on");
+ else strcat(pstr,"stay_off");
+ printf("%s\n",pstr);
+
+ if (b2 != 0) {
+ sprintf(pstr,"\tlast_power_event %c ",bdelim);
+ if (b2 & 0x10) strcat(pstr,"IPMI ");
+ if (b2 & 0x08) strcat(pstr,"fault ");
+ if (b2 & 0x04) strcat(pstr,"interlock ");
+ if (b2 & 0x02) strcat(pstr,"overload ");
+ if (b2 & 0x01) strcat(pstr,"ACfailed");
+ printf("%s\n",pstr);
+ }
+ printf("\tchassis_intrusion %c %s\n", bdelim,
+ (b3 & 0x01) ? "active":"inactive");
+ printf("\tfront_panel_lockout %c %s\n", bdelim,
+ (b3 & 0x02) ? "active":"inactive");
+ printf("\tdrive_fault %c %s\n", bdelim,
+ (b3 & 0x04) ? "true":"false");
+ printf("\tcooling_fan_fault %c %s\n", bdelim,
+ (b3 & 0x08) ? "true":"false");
+ if (slen > 3) {
+ b4 = sbuf[3];
+ if (b4 & 0x80) {
+ printf("\tFP sleep_button_disable %c allowed, button %s\n",bdelim,
+ (b4 & 0x08) ? "disabled":"enabled");
+ }
+ if (b4 & 0x40) {
+ printf("\tFP diag_button_disable %c allowed, button %s\n",bdelim,
+ (b4 & 0x04) ? "disabled":"enabled");
+ }
+ if (b4 & 0x20) {
+ printf("\tFP reset_button_disable %c allowed, button %s\n",bdelim,
+ (b4 & 0x02) ? "disabled":"enabled");
+ }
+ if (b4 & 0x10) {
+ printf("\tFP power_button_disable %c allowed, button %s\n",bdelim,
+ (b4 & 0x01) ? "disabled":"enabled");
+ }
+ }
+ return;
+}
+
+static int get_power_state(uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmdraw( GET_POWER_STATE, NETFN_APP,
+ g_sa, g_bus, g_lun,
+ idata,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_power_state()*/
+
+static char *pwr_string(uchar pstate)
+{
+ char *pstr;
+ switch(pstate) {
+ case 0x00: pstr = "S0: working"; break;
+ case 0x01: pstr = "S1: clock stopped, context ok"; break;
+ case 0x02: pstr = "S2: clock stopped, context lost"; break;
+ case 0x03: pstr = "S3: suspend-to-RAM"; break;
+ case 0x04: pstr = "S4: suspend-to-Disk"; break;
+ case 0x05: pstr = "S5: soft off"; break;
+ case 0x06: pstr = "S4/S5: soft off, either S4 or S5"; break;
+ case 0x07: pstr = "G3: mechanical off"; break;
+ case 0x08: pstr = "S1-S3: sleeping"; break;
+ case 0x09: pstr = "S1-S4: sleeping"; break;
+ case 0x0A: pstr = "S5/o: soft off by override"; break;
+ case 0x20: pstr = "legacy on"; break;
+ case 0x21: pstr = "legacy soft-off"; break;
+ case 0x2a: /* not initialized or device lost track of state */
+ default: pstr = "unknown"; break;
+ }
+ return(pstr);
+}
+
+#ifdef PING_OK
+extern int ping_bmc(char *node, char fdebug);
+
+static int ping_node(char *node)
+{
+ int rv = 0;
+ /* verify that the BMC LAN channel is configured & active */
+ /* send rmcp_ping to node's BMC */
+ rv = ping_bmc(node,fdebug);
+ return(rv);
+}
+#endif
+
+#define MIN_SDR_SZ 8
+static int get_frusdr_version(char *pver, int sver)
+{
+ ushort recid;
+ int recnext;
+ int ret, sz, i, len;
+ uchar sdr[MAX_BUFFER_SIZE];
+ char verstr[30];
+ char fIntel;
+ int verlen;
+
+ recid = 0;
+ verstr[0] = 0;
+ verlen = 0;
+ while (recid != 0xffff)
+ {
+ memset(sdr,0,sizeof(sdr));
+ ret = GetSDR(recid,&recnext,sdr,sizeof(sdr),&sz);
+ if (fdebug)
+ printf("GetSDR[%04x]: ret = %x, next=%x\n",recid,ret,recnext);
+ if (ret != 0) {
+ if (ret > 0) { /* ret is a completion code error */
+ if (fdebug)
+ printf("%04x GetSDR error 0x%02x %s, rlen=%d\n",recid,ret,
+ decode_cc((ushort)0,(uchar)ret),sz);
+ } else printf("%04x GetSDR error %d, rlen = %d\n", recid,ret,sz);
+ if (sz < MIN_SDR_SZ) { /* don't have recnext, so abort */
+ break;
+ } /* else fall through & continue */
+ } else { /*got SDR */
+ len = sdr[4] + 5;
+ if (sdr[3] == 0xC0) { /* OEM SDR */
+ /* check for Intel mfg id */
+ if ((sdr[5] == 0x57) && (sdr[6] == 0x01) && (sdr[7] == 0x00))
+ fIntel = 1;
+ else fIntel = 0;
+ if (sdr[8] == 0x53) { /*Intel OEM subtype, ASCII 'S' */
+ verlen = 0;
+ for (i = 8; i < len; i++) {
+ if (sdr[i] == 0) break;
+ if (i >= sizeof(verstr)) break;
+ verstr[verlen++] = sdr[i];
+ }
+ verstr[verlen] = 0; /*stringify*/
+ /* continue on past SDR File, get SDR Package version */
+ // break;
+ }
+ } /*endif OEM SDR*/
+ }
+ if (recnext == recid) recid = 0xffff; /*break;*/
+ else recid = (ushort)recnext;
+ }
+ if (verlen > sver) verlen = sver;
+ if (fdebug)
+ printf("get_frusdr_version: verstr=%s, verlen=%d\n",verstr,verlen);
+ strncpy(pver,verstr,verlen);
+ return(ret);
+}
+
+static int get_hsc_devid(uchar *rdata, int rlen)
+{
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmdraw( 0x01, /*(GET_DEVICEID & 0x00ff)*/
+ NETFN_APP, 0xC0,PUBLIC_BUS,BMC_LUN,
+ NULL,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_hsc_devid*/
+
+static int get_chan_auth(uchar chan, uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+
+ idata[0] = chan; /*0x0e = this channel*/
+ idata[1] = 0x02; /*priv level = user*/
+ ret = ipmi_cmdraw( 0x38, NETFN_APP, /*CMD_GET_CHAN_AUTH_CAP*/
+ g_sa, g_bus, g_lun,
+ idata,2, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_chan_auth*/
+
+void show_chan_auth(char *tag, uchar *rec, int srec)
+{
+ char pstr[40];
+ pstr[0] = 0;
+ if (rec[1] & 0x01) strcat(pstr,"None ");
+ if (rec[1] & 0x02) strcat(pstr,"MD2 ");
+ if (rec[1] & 0x04) strcat(pstr,"MD5 ");
+ if (rec[1] & 0x10) strcat(pstr,"Straight_Passwd ");
+ if (rec[1] & 0x20) strcat(pstr,"OEM ");
+ printf("Chan %d AuthTypes %c %s\n",rec[0],bdelim,pstr);
+ if (do_hsc) /*only show this if extra output*/
+ printf("Chan %d Status %c %02x, OEM ID %02x%02x%02x OEM Aux %02x\n",
+ rec[0],bdelim,rec[2],rec[4],rec[5],rec[6],rec[7]);
+}
+
+#define BMC 1
+#define HSC 2
+
+#ifdef MOVED
+/* moved to subs.c*/
+#define N_MFG 41
+struct { int val; char *pstr; } mfgs[N_MFG] = { };
+char * get_iana_str(int mfg);
+#endif
+
+char * get_mfg_str(uchar *rgmfg, int *pmfg)
+{
+ char *mfgstr = "";
+ int mfg;
+ mfg = rgmfg[0] + (rgmfg[1] << 8) + (rgmfg[2] << 16);
+ if (pmfg != NULL) *pmfg = mfg; /*vend_id*/
+ mfgstr = get_iana_str(mfg);
+ return(mfgstr);
+}
+
+/* int get_system_info(uchar parm, char *pbuf, int *szbuf); *see subs.c*/
+/* int set_system_info(uchar parm, uchar *pbuf, int *szbuf); *see subs.c*/
+
+void show_devid_all(int dtype, uchar *devrec, int sdevrec)
+{
+ uchar ipmi_maj = 0;
+ uchar ipmi_min = 0;
+ char *tag;
+ int mfg, prod;
+ char *mfgstr = "";
+ char *prodstr = "";
+ char prodoem[40];
+ char extraver[32];
+ int i, j, k, l, rv;
+
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ prod = devrec[9] + (devrec[10] << 8);
+ mfgstr = get_mfg_str(&devrec[6],&mfg);
+ vend_id = mfg;
+ prod_id = prod;
+ extraver[0] = 0;
+ if (dtype == HSC) tag = "HSC";
+ else {
+ tag = "BMC";
+ /* The product ids below only apply to BMCs */
+ switch(mfg) {
+ case VENDOR_NSC: /*=0x000322*/
+ fmBMC = 1;
+ if (dtype == BMC) tag="mBMC";
+ if (prod == 0x4311) prodstr = "(TIGPT1U)"; /*Intel*/
+ break;
+ case VENDOR_SUN: /*=0x00002a*/
+ if (prod == 0x4701) prodstr = "(X4140)";
+ break;
+ case VENDOR_TYAN: /*=0x0019fd*/
+ switch(prod) { /* show product names for some */
+ case 0x0b41: prodstr = "(M3289)"; break;
+ case 0x0f98: prodstr = "(M3291)"; break;
+ case 0x137d: prodstr = "(S4989)"; break;
+ case 0x13ee: prodstr = "(S5102)"; break;
+ case 0x14fc: prodstr = "(S5372)"; break;
+ default: prodstr = ""; break;
+ }
+ break;
+ case VENDOR_FUJITSU: /*=0x002880*/
+ if (prod >= 0x200) prodstr = "(iRMC S2)";
+ else prodstr = "";
+ break;
+ case VENDOR_CISCO: /*=0x00168b*/
+ if (prod == 0x0005) prodstr = "(UCS C200)";
+ else prodstr = "";
+ if (fipmilan) lan_ch_restrict = 1; /*fw bug, gets 0xC1 on ipmilan*/
+ break;
+ case VENDOR_INTEL: /*=0x000157*/
+ if (do_hsc && (dtype == BMC)) /*if HSC option, also show extra*/
+ sprintf(extraver," (Boot %x.%x PIA %x.%x)", /*BMC extra*/
+ devrec[11],devrec[12],devrec[13],devrec[14]);
+ switch(prod) { /* show product names for some */
+ case 0x000C: prodstr = "(TSRLT2)"; /*SCB2*/
+ bChan = 7; break;
+ case 0x001B: prodstr = "(TIGPR2U)"; /*SWV2*/
+ bChan = 7; break;
+ case 0x0022: prodstr = "(TIGI2U)"; break; /*SJR2*/
+ case 0x0026: prodstr = "(Bridgeport)"; break;
+ case 0x0028: prodstr = "(S5000PAL)"; break; /*Alcolu*/
+ case 0x0029: prodstr = "(S5000PSL)"; break; /*StarLake*/
+ case 0x002B: prodstr = "(S5000VSA)"; break;
+ case 0x002D: prodstr = "(MFSYS25)"; break; /*ClearBay*/
+ case 0x003E: prodstr = "(S5520UR)"; /*CG2100 or NSN2U*/
+ do_me = 1; kcs_loops = URNLOOPS;
+ bChan = 1; break;
+ case 0x0040: prodstr = "(QSSC-S4R)"; /*Stoutland*/
+ do_me = 1; kcs_loops = URNLOOPS;
+ bChan = 1; break;
+ case 0x0100: prodstr = "(Tiger4)"; break;
+ case 0x0103: prodstr = "(McCarran)"; /*BladeCenter*/
+ do_powerstate = 0; break;
+ case 0x0800: prodstr = "(ZT5504)"; /*ZiaTech*/
+ do_powerstate = 0; break;
+ case 0x0808: prodstr = "(MPCBL0001)"; /*ATCA Blade*/
+ do_powerstate = 0; break;
+ case 0x0841: prodstr = "(MPCMM0001)"; /*ATCA CMM*/
+ do_powerstate = 0; break;
+ case 0x0811: prodstr = "(TIGW1U)"; break; /*S5000PHB*/
+ case 0x4311: prodstr = "(NSI2U)"; /*SE7520JR23*/
+ if (dtype == BMC) tag="mBMC";
+ fmBMC = 1; break;
+ default: prodstr = ""; break;
+ }
+ if (is_romley(mfg,prod)) {
+ intel_romley_desc(mfg,prod,&prodstr);
+ snprintf(prodoem,sizeof(prodoem),"(%s)",prodstr);
+ prodstr = prodoem;
+ do_me = 1; kcs_loops = URNLOOPS;
+ do_hsc = 1; /*the HSC is embedded, so not the same*/
+ sprintf(extraver,".%d (Boot %x.%x)", /*BMC extra*/
+ (devrec[13] + (devrec[14] << 8)),devrec[11],devrec[12]);
+ }
+ break;
+ case VENDOR_KONTRON: /*=0x003A98=15000.*/
+ i = devrec[11] + (devrec[12] << 8);
+ j = devrec[13] + (devrec[14] << 8);
+ k = 0; l = 0;
+ { /* get Kontron firmware version with OEM cmd */
+ int rlen;
+ uchar idata[4];
+ uchar rdata[16];
+ uchar cc;
+ rlen = sizeof(rdata);
+ idata[0] = 0;
+ idata[1] = 0;
+ idata[2] = 1;
+ rv = ipmi_cmdraw(0x2f, 0x2c, g_sa, g_bus, g_lun,
+ idata,3,rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc == 0) {
+ k = rdata[1];
+ l = rdata[2];
+ }
+ }
+ sprintf(extraver,".%02d.%02d (FW %x.%x)",i,j,k,l);
+ switch(prod) { /* show product names for some */
+ case 0x1590: prodstr = "(KTC5520)"; break;
+ default: prodstr = ""; break;
+ }
+ break;
+ case VENDOR_PEPPERCON: /*=0x0028c5 Peppercon/Raritan */
+ if (prod == 0x0004) prodstr = "(AOC-IPMI20)"; /*SuperMicro*/
+ else if (prod == 0x0007) prodstr = "(RMM2)"; /*Intel RMM2*/
+ break;
+ case VENDOR_HP: /*=0x00000B*/
+ switch(prod) { /* show product names for some */
+ case 0x2000: prodstr = "(Proliant ML/DL)"; break; /*DL380*/
+ case 0x2020: prodstr = "(Proliant BL)"; break;
+ default: if ((prod & 0xff00) == 0x8300)
+ prodstr = "(Proliant SL)";
+ else prodstr = "";
+ break;
+ }
+ do_powerstate = 0; /*HP does not support get_power_state cmd*/
+ break;
+ case VENDOR_DELL: /*=0x0002A2*/
+ switch(prod) { /* show product names for some */
+ case 0x0100: prodstr = "(PE R610)"; break;
+ default: prodstr = ""; break;
+ }
+ break;
+ case VENDOR_MAGNUM: /* =5593. used by SuperMicro*/
+ switch(prod) { /* show product names for some */
+ case 6: prodstr = "(X8DTL)"; break;
+ default: prodstr = ""; break;
+ }
+ break;
+ case VENDOR_SUPERMICRO: /* =10876. used by SuperMicro*/
+ case VENDOR_SUPERMICROX: /* =47488. used by Winbond/SuperMicro*/
+ switch(prod) { /* decode some SuperMicro product ids */
+ case 4: prodstr = "(X7DBR)"; break;
+ case 6: prodstr = "(X8DTL)"; break;
+ case 1037: prodstr = "(X8SIE)"; break;
+ case 1541: prodstr = "(X8SIL)"; break;
+ case 1547: prodstr = "(X8SIA)"; break; /*0x060b*/
+ case 1549: prodstr = "(X8DTU)"; break;
+ case 1551: prodstr = "(X8DTN)"; break;
+ case 1562: prodstr = "(X8SIU-F)"; break; /*0x061a*/
+ case 1572: prodstr = "(X9SCM)"; break; /*or X9SCL*/
+ case 1576: prodstr = "(X9DRi)"; break;
+ case 1585: prodstr = "(X9SCA)"; break;
+ case 1603: prodstr = "(X9SPU)"; break; /*0x0643*/
+ case 1643: prodstr = "(X9SRL)"; break; /*0x066b*/
+ case 1797: prodstr = "(X9DR7)"; break; /*0x0705*/
+ case 43025: prodstr = "(H8DGU)"; break;
+ case 43707: prodstr = "(X8DTH)"; break;
+ default: prodstr = ""; break;
+ }
+ if (!fipmilan) lan_ch_restrict = 1; /*fw bug, gets 0xd4 locally*/
+ break;
+ case VENDOR_QUANTA: /*=7244.*/
+ switch(prod) { /* show product names for some */
+ case 21401: prodstr = "(S99Q)"; break;
+ default: prodstr = ""; break;
+ }
+ break;
+ default:
+ prodstr = "";
+ break;
+ } /*end switch(prod)*/
+ if (kcs_loops != 0) set_max_kcs_loops(kcs_loops);
+ } /*end-else BMC*/
+
+ printf("%s manufacturer %c %06x (%s)%c product %c %04x %s\n",
+ tag, bdelim,mfg,mfgstr,bcomma,bdelim,prod,prodstr);
+ { /* BMC version */
+ printf("%s version %c %x.%02x%s%c IPMI v%d.%d\n", tag,bdelim,
+ devrec[2],devrec[3],extraver,bcomma,ipmi_maj,ipmi_min);
+ }
+ /* could show product rev, if available (sdevrec > 14) */
+ return;
+}
+
+int GetPowerOnHours(unsigned int *val)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar cc;
+ int rc = -1;
+ int i;
+ unsigned int hrs;
+
+ *val = 0;
+ if (fmBMC) return(rc);
+ sresp = MAX_BUFFER_SIZE;
+ memset(resp,0,6); /* default response size is 5 */
+ rc = ipmi_cmd_mc(GET_POWERON_HOURS, NULL, 0, resp, &sresp, &cc, fdebug);
+ if (rc == 0 && cc == 0) {
+ /* show the hours (32-bits) */
+ hrs = resp[1] | (resp[2] << 8) | (resp[3] << 16) | (resp[4] << 24);
+ if (resp[0] == 60) /*normal*/ i = 1;
+ else {
+ i = 60 / resp[0];
+ hrs = hrs / i;
+ }
+ *val = hrs;
+ }
+ return(rc);
+}
+
+char *decode_selftest(int stat)
+{
+ uchar *s;
+ uchar b;
+ if (stat == 0x0055) s = "(OK)";
+ else {
+ s = "(Error)";
+ if ((stat & 0x00ff) == 0x0057) {
+ b = ((stat & 0xff00) >> 8);
+ if (b & 0x80) s = "(No SEL Access)";
+ if (b & 0x40) s = "(No SDR Access)";
+ if (b & 0x20) s = "(No FRU Access)";
+ if (b & 0x10) s = "(IPMB Error)";
+ if (b & 0x08) s = "(SDR Empty)";
+ if (b & 0x02) s = "(BootCode Corrupt)";
+ if (b & 0x01) s = "(OpCode Corrupt)";
+ }
+ }
+ return(s);
+}
+
+#ifdef METACOMMAND
+int i_health(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int c;
+ uchar selfbuf[16];
+ uchar devrec[30];
+ char biosver[80];
+ uchar cc;
+ int selfstatus;
+ uchar pwr_state;
+ char selfstr[36];
+ char *s;
+ char *s1;
+ int i, sresp;
+ uint n;
+ int rlen, len;
+ uchar idata[4];
+ uchar rdata[16];
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"cfghiln:o:p:q:sT:V:J:YEF:P:N:R:U:Z:x?")) != EOF )
+ switch(c) {
+ case 'c': fcanonical = 1;
+ bdelim = BDELIM; break; /* canonical output */
+ case 'f': do_frusdr = 1; break; /* check the FRUSDR too */
+ case 'g': do_guid = 1; break; /* get the System GUID also */
+ case 'h': do_hsc = 1; break; /* check the HSC too */
+ case 'i': do_systeminfo = 1; break; /* get system info too */
+ case 'l': do_lanstats = 1; break; /* get the LAN stats too */
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'n': set_name = 1; /* set the system name*/
+ pname = optarg;
+ break;
+ case 'o': set_os = 1; /* set the Operating System*/
+ pos = optarg;
+ break;
+ case 'q': set_os2 = 1; /* set the Operating System*/
+ pos2 = optarg;
+ break;
+ case 'p': set_restore = 1; /* set the restore policy */
+ restore_policy = atob(optarg);
+ if (restore_policy > 2) restore_policy = 1;
+ break;
+ case 's': do_session = 1; break; /* get session info too */
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-cfghilnopsx -N node -U user -P/-R pswd -EFTVY]\n", progname);
+ printf(" where -x show eXtra debug messages\n");
+ printf(" -c canonical output\n");
+ printf(" -f get the FRUSDR version also\n");
+ printf(" -g get the System GUID also\n");
+ printf(" -h check the HotSwap Controller also\n");
+ printf(" -i get System Info also: Name and OS\n");
+ printf(" -l get the IPMI LAN statistics also\n");
+ printf(" -n set System Name to this string \n");
+ printf(" -o set Operating System to this string\n");
+ printf(" -p1 set restore policy: 0=off, 1=last, 2=on\n");
+ printf(" -s get the IPMI Session info also\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto health_end;
+ }
+
+ fipmilan = is_remote();
+ if (fipmilan && set_restore)
+ parse_lan_options('V',"4",0); /*if set, request admin priv*/
+
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto health_end;
+ } else {
+ show_devid_all(BMC,devrec,16);
+ }
+
+ if (!fipmilan) { /*get local BIOS version*/
+ biosver[0] = 0;
+ ret = get_BiosVersion(biosver);
+ if (ret == 0) printf("BIOS Version %c %s\n",bdelim,biosver);
+ }
+ if (do_me) { /* ME version for Intel S5500 motherboards */
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw((GET_DEVICE_ID & 0xff), NETFN_APP,ME_SA,ME_BUS,0x00,
+ idata,0,rdata,&rlen,&cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ if (ret == 0) {
+ uchar m,n;
+ m = (rdata[3] & 0xf0) >> 4;
+ n = (rdata[3] & 0x0f);
+ printf("ME Firmware Ver %c %02x.%02x.%02x.%02x%02x\n",bdelim,
+ rdata[2],m,n,rdata[12],rdata[13]);
+ /* If rdata[2] has 0x80 bit on, ME is in update/recovery mode.
+ That can be cleared by removing input power. */
+ } else
+ if (fdebug) printf("GetDeviceID(ME) error ret = %d\n",ret);
+ }
+
+ if (do_hsc) {
+ if (fmBMC) printf("No HSC present\n");
+ else {
+ /* Get HSC status */
+ if (is_romley(vend_id, prod_id)) {
+ uchar maj, min;
+ ret = get_hsbp_version_intel(&maj, &min);
+ if (fdebug) printf("get_hsbp_version_intel ret = %d\n",ret);
+ if (ret == 0)
+ printf("HSC version %c %d.%02d\n", bdelim,maj,min);
+ } else {
+ ret = get_hsc_devid(&devrec[0],sizeof(devrec));
+ if (fdebug) printf("get_hsc_devid ret = %d\n",ret);
+ if (ret == 0) /* only if HSC is detected */
+ show_devid_all(HSC,devrec,14);
+ }
+ }
+ }
+
+ i = get_driver_type();
+ printf("IPMI driver type %c %d (%s)\n",bdelim,i,show_driver_type(i));
+
+ if (do_powerstate)
+ { /* Some BMCs dont support get_power_state*/
+ ret = get_power_state(selfbuf,4);
+ if (ret != 0) {
+ printf("ipmi_getpowerstate error, ret = %d\n",ret);
+ goto health_end;
+ } else {
+ pwr_state = selfbuf[0] & 0x7f;
+ printf("Power State %c %02x (%s)\n",
+ bdelim,pwr_state,pwr_string(pwr_state));
+ }
+ }
+
+ ret = get_selftest_status(&selfbuf[0],sizeof(selfbuf));
+ if (ret != 0) {
+ printf("get_selftest_status error, ret = %x\n",ret);
+ goto health_end;
+ } else {
+ selfstatus = selfbuf[0] + (selfbuf[1] << 8);
+ s = decode_selftest(selfstatus);
+ if (fmBMC) {
+ sprintf(selfstr,"%s",s);
+ } else {
+ ret = get_last_selftest(&selfbuf[0],sizeof(selfbuf));
+ if (fdebug) printf("get_last_selftest ret = %x, %02x%02x\n",
+ ret, selfbuf[1],selfbuf[0]);
+ if (ret == 0 && (selfbuf[0] != 0xFF)) {
+ sprintf(selfstr,"%s, last = %02x%02x",s,selfbuf[1],selfbuf[0]);
+ } else sprintf(selfstr,"%s",s);
+ ret = 0; /*ignore any errors with get_last_selftest*/
+ }
+ printf("Selftest status %c %04x %s\n",bdelim,selfstatus,selfstr);
+ }
+
+ ret = oem_get_health(&selfstr[0],sizeof(selfstr));
+ if (ret == 0) {
+ printf("%s\n",selfstr);
+ }
+
+ rlen = 4;
+ ret = get_chassis_status(selfbuf,&rlen);
+ if (ret != 0) {
+ printf("Cannot do get_chassis_status, ret = %d\n",ret);
+ goto health_end;
+ } else {
+ show_chs_status(selfbuf,rlen);
+ }
+
+ if (vend_id == VENDOR_INTEL) {
+ int pwr_delay = 0;
+ ret = get_power_restore_delay_intel(&pwr_delay);
+ if (fdebug) printf("get_power_restore_delay_intel ret = %d\n",ret);
+ if (ret == 0) {
+ printf("PowerRestoreDelay %c %d seconds\n",bdelim,pwr_delay);
+ } else ret = 0;
+ }
+
+ if (do_guid) {
+ sresp = sizeof(devrec);
+ ret = ipmi_cmd(GET_SYSTEM_GUID,NULL,0,devrec,&sresp,&cc,fdebug);
+ if (ret != 0) {
+ if (!is_remote()) { /* get UUID from SMBIOS */
+ cc = 0; sresp = 16;
+ ret = get_SystemGuid(devrec);
+ } else {
+ cc = 0;
+ sresp = sizeof(devrec);
+ ret = get_device_guid(devrec,&sresp);
+ }
+ }
+ if (fdebug) printf("system_guid: ret = %d, cc = %x\n",ret,cc);
+ if (ret == 0 && cc == 0) {
+ printf("System GUID %c ",bdelim);
+ for (i=0; i<16; i++) {
+ if ((i == 4) || (i == 6) || (i == 8) || (i == 10)) s = "-";
+ else s = "";
+ printf("%s%02x",s,devrec[i]);
+ }
+ printf("\n");
+ }
+ }
+
+ if (bChan != 7) /* do not get first lan chan if set above */
+ ret = get_lan_channel(1,&bChan);
+
+ if (fmBMC == 0) {
+ ret = GetPowerOnHours(&n);
+ if (ret == 0)
+ printf("Power On Hours %c %d hours (%d days)\n",bdelim,n,(n/24));
+ if (ret == 0xC1) ret = 0; /* not supporting poweron hours is ok. */
+
+ printf("BMC LAN Channels %c ",bdelim);
+ for (i = 1; i<= 16; ) {
+ c = get_lan_channel(i,&cc);
+ if (c != 0) break;
+ printf("%d ",cc);
+ i = cc+1;
+ }
+ printf("\n");
+
+ if (lan_ch_restrict) ; /*skip if vendor fw bug*/
+ else {
+ ret = get_chan_auth(bChan,&devrec[0],sizeof(devrec));
+ if (ret == 0)
+ show_chan_auth("Channel Auth Cap",devrec,8);
+ else
+ printf("get_chan_auth error: ret = %x\n",ret);
+ }
+ }
+
+ if (do_systeminfo) {
+ char infostr[64];
+ len = sizeof(infostr);
+ ret = get_system_info(1,infostr,&len); /*Firmware Version*/
+ len = sizeof(infostr);
+ ret = get_system_info(2,infostr,&len);
+ if (ret == 0) {
+ printf("System Name %c %s\n",bdelim,infostr);
+ len = sizeof(infostr);
+ ret = get_system_info(3,infostr,&len);
+ if (ret == 0) printf("Pri Operating System %c %s\n",bdelim,infostr);
+ len = sizeof(infostr);
+ ret = get_system_info(4,infostr,&len);
+ if (ret == 0) printf("Sec Operating System %c %s\n",bdelim,infostr);
+ } else {
+ if (ret == 0xC1) /*only supported on later IPMI 2.0 firmware */
+ printf("GetSystemInfo not supported on this platform\n");
+ }
+ }
+
+ if (do_frusdr) {
+ ret = get_frusdr_version((char *)&devrec[0],sizeof(devrec));
+ if (ret == 0) printf("FRU/SDR Version %c %s\n",bdelim,devrec);
+ else printf("FRU/SDR Version %c error %d\n",bdelim,ret);
+ }
+
+ if (do_lanstats) {
+ ret = get_lan_stats(bChan);
+ }
+
+ if (do_session) {
+ i = get_session_info_all();
+ if (i != 0) printf("get_session_info error %d, %s\n",i,decode_rv(i));
+ }
+
+#ifdef PING_OK
+ {
+ char *node;
+ /* Currently some problems with this:
+ * works first time, but locks up BMC LAN on subsequent attempts.
+ */
+ node = get_nodename();
+ ret = ping_node(node);
+ printf("ping_node(%s): ret = %d\n",node,ret);
+ }
+#endif
+
+ if (set_name) {
+ len = (int)strlen(pname);
+ ret = set_system_info(2,pname,len);
+ printf("Set System Name to '%s', ret = %d\n",pname,ret);
+ if (ret == 0xC1) /*only supported on later IPMI 2.0 firmware */
+ printf("SetSystemInfo not supported on this platform\n");
+ }
+
+ if (set_os) {
+ len = (int)strlen(pos);
+ ret = set_system_info(3,pos,len);
+ printf("Set Pri Operating System to '%s', ret = %d\n",pos,ret);
+ if (ret == 0xC1) /*only supported on later IPMI 2.0 firmware */
+ printf("SetSystemInfo not supported on this platform\n");
+ }
+
+ if (set_os2) {
+ len = (int)strlen(pos2);
+ ret = set_system_info(4,pos2,len);
+ printf("Set Sec Operating System to '%s', ret = %d\n",pos2,ret);
+ if (ret == 0xC1) /*only supported on later IPMI 2.0 firmware */
+ printf("SetSystemInfo not supported on this platform\n");
+ }
+
+ if (set_restore) {
+ idata[0] = restore_policy; /* 1=last_state, 2=turn_on, 0=stay_off*/
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw(0x06 , NETFN_CHAS, g_sa, g_bus, g_lun,
+ idata,1,rdata,&rlen,&cc,fdebug);
+ if (ret == 0 && cc != 0) ret = cc;
+ printf("set_restore_policy(%x): ret = %d\n",restore_policy,ret);
+ }
+
+health_end:
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return (ret);
+} /* end main()*/
+
+/* end bmchealth.c */
diff --git a/util/ihpm.c b/util/ihpm.c
new file mode 100644
index 0000000..740ab74
--- /dev/null
+++ b/util/ihpm.c
@@ -0,0 +1,4003 @@
+/*
+ * ihpm.c
+ * Hardware Platform Management, IPM Controller Firmware Upgrade Procedure
+ *
+ * Change history:
+ * 08/25/2010 ARCress - ported from ipmitool/lib/ipmi_hpmfwupg.c
+ * 08/24/2011 ARcress - updated to Kontron 1.08 (K17) version,
+ * added hpm_decode_cc(), etc.
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2006 Kontron Canada, Inc. All Rights Reserved.
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#include <winsock.h>
+#include <stdlib.h>
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+typedef uint32_t socklen_t;
+#include "getopt.h"
+#else
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <ctype.h> /*for toupper*/
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <time.h>
+
+#include "ipmicmd.h"
+#include "ihpm.h"
+
+/****************************************************************************
+*
+* Copyright (c) 2006 Kontron Canada, Inc. All Rights Reserved.
+*
+* HPM.1
+* Hardware Platform Management
+* IPM Controller Firmware Upgrade Procedure
+*
+* This module implements an Upgrade Agent for the IPM Controller
+* Firmware Upgrade Procedure (HPM.1) specification version 1.0.
+*
+* author:
+* Frederic.Lelievre@ca.kontron.com
+* Francois.Isabelle@ca.kontron.com
+* Jean-Michel.Audet@ca.kontron.com
+* MarieJosee.Blais@ca.kontron.com
+*
+*****************************************************************************
+*
+* HISTORY
+* ===========================================================================
+* 2007-01-11
+*
+* - Incremented to version 0.2
+* - Added lan packet size reduction mechanism to workaround fact
+* that lan iface will not return C7 on excessive length
+* - Fixed some typos
+* - now uses lprintf()
+*
+* - Incremented to version 0.3
+* - added patch for openipmi si driver V39 (send message in driver does not
+* retry on 82/83 completion code and return 82/83 as response from target
+* [conditionnaly built with ENABLE_OPENIPMI_V39_PATCH]
+*
+* see: ipmi-fix-send-msg-retry.pacth in openipmi-developer mailing list
+*
+* 2007-01-16
+*
+* - Incremented to version 0.4
+* - Fixed lan iface inaccesiblity timeout handling. Waiting for firmware
+* activation completion (fixed sleep) before re-opening a session and
+* get the final firmware upgrade status.
+* - Fixed some user interface stuff.
+*
+* 2007-05-09
+*
+* - Incremented to version 1.0
+* - Modifications for compliancy with HPM.1 specification version 1.0
+*
+* 2007-06-05
+*
+* - Modified the display of upgrade of Firmware version.
+* - Added new options like "check" and "component" and "all" to hpm commands.
+* - By default we skip the upgrade if we have the same firmware version
+* as compared to the Image file (*.hpm).This will ensure that user does
+* not update the target incase its already been updated
+*
+* 2008-01-25
+* - Reduce buffer length more aggressively when no response from iol.
+* - Incremented version to 1.02
+*
+* 2009-02-11
+* - With multi-component HPM file, if one component need to be skipped because
+* the component is already up-to-date, ipmitool sends "Initiate upgrade
+* action / Upload for upgrade" anyway.
+*
+* If the component needs to be skipped, ipmitool will not send "Initiate
+* upgrade action / Upload for upgrade"
+*
+* - Incremented version to 1.03
+*
+* 2009-02-11
+* - Fixed side effect introduced by last version, "forced" update didn't
+* work anymore
+* - Incremented version to 1.04
+*
+* 2009-03-25
+* - Fix the case where ipmitool loses the iol connection during the upload
+* block process. Once IPMITool was successfully sent the first byte,
+* IPMITool will not resize the block size.
+*
+* 2009-03-26
+* - Fix the problem when we try to upgrade specific component and the component
+* is already updated, IPMITool sends a "prepare action" but IPMITool skips
+* the upload firmware block process.
+* So, if we specify a specific component, we want to force to upload this
+* specific component.
+* - Incremented version to 1.05
+*
+* 2009-04-20
+* - Reworked previous update, when 'component' is specified, the other
+* components are now skipped.
+* - Incremented version to 1.06
+*
+* ===========================================================================
+* TODO
+* ===========================================================================
+* 2007-01-11
+* - Add interpretation of GetSelftestResults
+* - Add interpretation of component ID string
+*
+*****************************************************************************/
+
+extern int verbose;
+
+/*
+ * Agent version
+ */
+#define HPMFWUPG_VERSION_MAJOR 1
+#define HPMFWUPG_VERSION_MINOR 0
+#define HPMFWUPG_VERSION_SUBMINOR 9
+static char * progname = "ihpm";
+static char * progver = "1.09"; /* HPMFWUPG_VERSION */
+extern char fdebug; /*from ipmicmd.c*/
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static int g_channel_buf_size = 0;
+
+/*
+ * HPM.1 FIRMWARE UPGRADE COMMANDS (part of PICMG)
+ */
+
+#define HPMFWUPG_GET_TARGET_UPG_CAPABILITIES 0x2E
+#define HPMFWUPG_GET_COMPONENT_PROPERTIES 0x2F
+#define HPMFWUPG_ABORT_UPGRADE 0x30
+#define HPMFWUPG_INITIATE_UPGRADE_ACTION 0x31
+#define HPMFWUPG_UPLOAD_FIRMWARE_BLOCK 0x32
+#define HPMFWUPG_FINISH_FIRMWARE_UPLOAD 0x33
+#define HPMFWUPG_GET_UPGRADE_STATUS 0x34
+#define HPMFWUPG_ACTIVATE_FIRMWARE 0x35
+#define HPMFWUPG_QUERY_SELFTEST_RESULT 0x36
+#define HPMFWUPG_QUERY_ROLLBACK_STATUS 0x37
+#define HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK 0x38
+
+/*
+ * HPM.1 SPECIFIC COMPLETION CODES
+ */
+#define HPMFWUPG_ROLLBACK_COMPLETED 0x00
+#define HPMFWUPG_COMMAND_IN_PROGRESS 0x80
+#define HPMFWUPG_NOT_SUPPORTED 0x81
+#define HPMFWUPG_SIZE_MISMATCH 0x81
+#define HPMFWUPG_ROLLBACK_FAILURE 0x81
+#define HPMFWUPG_INV_COMP_MASK 0x81
+#define HPMFWUPG__ABORT_FAILURE 0x81
+#define HPMFWUPG_INV_COMP_ID 0x82
+#define HPMFWUPG_INT_CHECKSUM_ERROR 0x82
+#define HPMFWUPG_INV_UPLOAD_MODE 0x82
+#define HPMFWUPG_ROLLBACK_OVERRIDE 0x82
+#define HPMFWUPG_INV_COMP_PROP 0x83
+#define HPMFWUPG_FW_MISMATCH 0x83
+#define HPMFWUPG_ROLLBACK_DENIED 0x83
+#define HPMFWUPG_NOT_SUPPORTED_NOW 0xd5
+
+/*
+ * This error code is used as a temporary PATCH to
+ * the latest Open ipmi driver. This PATCH
+ * will be removed once a new Open IPMI driver is released.
+ * (Buggy version = 39)
+ */
+#define ENABLE_OPENIPMI_V39_PATCH
+
+#ifdef ENABLE_OPENIPMI_V39_PATCH
+
+#define RETRY_COUNT_MAX 3
+
+static int errorCount;
+
+#define HPMFWUPG_IS_RETRYABLE(error) \
+((((error==0x83)||(error==0x82)||(error==0x80)) && (errorCount++<RETRY_COUNT_MAX))?TRUE:FALSE)
+#else
+#define HPMFWUPG_IS_RETRYABLE(error) FALSE
+#endif
+
+/*
+ * HPM FIRMWARE UPGRADE GENERAL DEFINITIONS
+ */
+
+#define HPMFWUPG_PICMG_IDENTIFIER 0
+#define HPMFWUPG_VERSION_SIZE 6
+#define HPMFWUPG_DESC_STRING_LENGTH 12
+#define HPMFWUPG_DEFAULT_INACCESS_TIMEOUT 60 /* sec */
+#define HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT 60 /* sec */
+#define HPMFWUPG_MD5_SIGNATURE_LENGTH 16
+
+/* Component IDs */
+typedef enum eHpmfwupgComponentId
+{
+ HPMFWUPG_COMPONENT_ID_0 = 0,
+ HPMFWUPG_COMPONENT_ID_1,
+ HPMFWUPG_COMPONENT_ID_2,
+ HPMFWUPG_COMPONENT_ID_3,
+ HPMFWUPG_COMPONENT_ID_4,
+ HPMFWUPG_COMPONENT_ID_5,
+ HPMFWUPG_COMPONENT_ID_6,
+ HPMFWUPG_COMPONENT_ID_7,
+ HPMFWUPG_COMPONENT_ID_MAX
+} tHpmfwupgComponentId;
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgComponentBitMask
+{
+ union
+ {
+ unsigned char byte;
+ struct
+ {
+ #ifdef WORDS_BIGENDIAN
+ unsigned char component7 : 1;
+ unsigned char component6 : 1;
+ unsigned char component5 : 1;
+ unsigned char component4 : 1;
+ unsigned char component3 : 1;
+ unsigned char component2 : 1;
+ unsigned char component1 : 1;
+ unsigned char component0 : 1;
+ #else
+ unsigned char component0 : 1;
+ unsigned char component1 : 1;
+ unsigned char component2 : 1;
+ unsigned char component3 : 1;
+ unsigned char component4 : 1;
+ unsigned char component5 : 1;
+ unsigned char component6 : 1;
+ unsigned char component7 : 1;
+ #endif
+ }ATTRIBUTE_PACKING bitField;
+ }ATTRIBUTE_PACKING ComponentBits;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+static const int HPMFWUPG_SUCCESS = 0;
+static const int HPMFWUPG_ERROR = -1;
+/* Upload firmware specific error codes */
+static const int HPMFWUPG_UPLOAD_BLOCK_LENGTH = 1;
+static const int HPMFWUPG_UPLOAD_RETRY = 2;
+
+
+/*
+ * TARGET UPGRADE CAPABILITIES DEFINITIONS
+ */
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesResp
+{
+ unsigned char picmgId;
+ unsigned char hpmVersion;
+ union
+ {
+ unsigned char byte;
+ struct
+ {
+ #if WORDS_BIGENDIAN
+ unsigned char fwUpgUndesirable : 1;
+ unsigned char autRollbackOverride : 1;
+ unsigned char ipmcDegradedDurinUpg: 1;
+ unsigned char deferActivation : 1;
+ unsigned char servAffectDuringUpg : 1;
+ unsigned char manualRollback : 1;
+ unsigned char autRollback : 1;
+ unsigned char ipmcSelftestCap : 1;
+ #else
+ unsigned char ipmcSelftestCap : 1;
+ unsigned char autRollback : 1;
+ unsigned char manualRollback : 1;
+ unsigned char servAffectDuringUpg : 1;
+ unsigned char deferActivation : 1;
+ unsigned char ipmcDegradedDurinUpg: 1;
+ unsigned char autRollbackOverride : 1;
+ unsigned char fwUpgUndesirable : 1;
+ #endif
+ }ATTRIBUTE_PACKING bitField;
+ }ATTRIBUTE_PACKING GlobalCapabilities;
+ unsigned char upgradeTimeout;
+ unsigned char selftestTimeout;
+ unsigned char rollbackTimeout;
+ unsigned char inaccessTimeout;
+ struct HpmfwupgComponentBitMask componentsPresent;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesCtx
+{
+ struct HpmfwupgGetTargetUpgCapabilitiesReq req;
+ struct HpmfwupgGetTargetUpgCapabilitiesResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * COMPONENT PROPERTIES DEFINITIONS
+ */
+
+typedef enum eHpmfwupgCompPropertiesSelect
+{
+ HPMFWUPG_COMP_GEN_PROPERTIES = 0,
+ HPMFWUPG_COMP_CURRENT_VERSION,
+ HPMFWUPG_COMP_DESCRIPTION_STRING,
+ HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION,
+ HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION,
+ HPMFWUPG_COMP_RESERVED,
+ HPMFWUPG_COMP_OEM_PROPERTIES = 192
+} tHpmfwupgCompPropertiesSelect;
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesReq
+{
+ unsigned char picmgId;
+ unsigned char componentId;
+ unsigned char selector;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetGeneralPropResp
+{
+ unsigned char picmgId;
+ union
+ {
+ unsigned char byte;
+ struct
+ {
+ #if WORDS_BIGENDIAN
+ unsigned char reserved : 2;
+ unsigned char payloadColdReset : 1;
+ unsigned char deferredActivation : 1;
+ unsigned char comparisonSupport : 1;
+ unsigned char preparationSupport : 1;
+ unsigned char rollbackBackup : 2;
+ #else
+ unsigned char rollbackBackup : 2;
+ unsigned char preparationSupport : 1;
+ unsigned char comparisonSupport : 1;
+ unsigned char deferredActivation : 1;
+ unsigned char payloadColdReset : 1;
+ unsigned char reserved : 2;
+ #endif
+ }ATTRIBUTE_PACKING bitfield;
+ }ATTRIBUTE_PACKING GeneralCompProperties;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetCurrentVersionResp
+{
+ unsigned char picmgId;
+ unsigned char currentVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetDescStringResp
+{
+ unsigned char picmgId;
+ char descString[HPMFWUPG_DESC_STRING_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetRollbackFwVersionResp
+{
+ unsigned char picmgId;
+ unsigned char rollbackFwVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetDeferredFwVersionResp
+{
+ unsigned char picmgId;
+ unsigned char deferredFwVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * GetComponentProperties - OEM properties (192)
+ */
+#define HPMFWUPG_OEM_LENGTH 4
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetOemProperties
+{
+ unsigned char picmgId;
+ unsigned char oemRspData[HPMFWUPG_OEM_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesResp
+{
+ union
+ {
+ struct HpmfwupgGetGeneralPropResp generalPropResp;
+ struct HpmfwupgGetCurrentVersionResp currentVersionResp;
+ struct HpmfwupgGetDescStringResp descStringResp;
+ struct HpmfwupgGetRollbackFwVersionResp rollbackFwVersionResp;
+ struct HpmfwupgGetDeferredFwVersionResp deferredFwVersionResp;
+ struct HpmfwupgGetOemProperties oemProperties;
+ }ATTRIBUTE_PACKING Response;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesCtx
+{
+ struct HpmfwupgGetComponentPropertiesReq req;
+ struct HpmfwupgGetComponentPropertiesResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+/*
+ * ABORT UPGRADE DEFINITIONS
+ */
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeCtx
+{
+ struct HpmfwupgAbortUpgradeReq req;
+ struct HpmfwupgAbortUpgradeResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * UPGRADE ACTIONS DEFINITIONS
+ */
+typedef enum eHpmfwupgUpgradeAction
+{
+ HPMFWUPG_UPGRADE_ACTION_BACKUP = 0,
+ HPMFWUPG_UPGRADE_ACTION_PREPARE,
+ HPMFWUPG_UPGRADE_ACTION_UPGRADE,
+ HPMFWUPG_UPGRADE_ACTION_COMPARE,
+ HPMFWUPG_UPGRADE_ACTION_INVALID = 0xff
+} tHpmfwupgUpgradeAction;
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionReq
+{
+ unsigned char picmgId;
+ struct HpmfwupgComponentBitMask componentsMask;
+ unsigned char upgradeAction;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionCtx
+{
+ struct HpmfwupgInitiateUpgradeActionReq req;
+ struct HpmfwupgInitiateUpgradeActionResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * UPLOAD FIRMWARE BLOCK DEFINITIONS
+ */
+
+#define HPMFWUPG_SEND_DATA_COUNT_MAX 256
+#define HPMFWUPG_SEND_DATA_COUNT_KCS 30
+#define HPMFWUPG_SEND_DATA_COUNT_LAN 25
+#define HPMFWUPG_SEND_DATA_COUNT_IPMB 26
+#define HPMFWUPG_SEND_DATA_COUNT_IPMBL 26
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockReq
+{
+ unsigned char picmgId;
+ unsigned char blockNumber;
+ unsigned char data[HPMFWUPG_SEND_DATA_COUNT_MAX];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockCtx
+{
+ struct HpmfwupgUploadFirmwareBlockReq req;
+ struct HpmfwupgUploadFirmwareBlockResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+/*
+ * FINISH FIRMWARE UPLOAD DEFINITIONS
+ */
+
+#define HPMFWUPG_IMAGE_SIZE_BYTE_COUNT 4
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadReq
+{
+ unsigned char picmgId;
+ unsigned char componentId;
+ unsigned char imageLength[HPMFWUPG_IMAGE_SIZE_BYTE_COUNT];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadCtx
+{
+ struct HpmfwupgFinishFirmwareUploadReq req;
+ struct HpmfwupgFinishFirmwareUploadResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * ACTIVATE FW DEFINITIONS
+ */
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareReq
+{
+ unsigned char picmgId;
+ unsigned char rollback_override;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareCtx
+{
+ struct HpmfwupgActivateFirmwareReq req;
+ struct HpmfwupgActivateFirmwareResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+/*
+ * GET UPGRADE STATUS DEFINITIONS
+ */
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusResp
+{
+ unsigned char picmgId;
+ unsigned char cmdInProcess;
+ unsigned char lastCmdCompCode;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusCtx
+{
+ struct HpmfwupgGetUpgradeStatusReq req;
+ struct HpmfwupgGetUpgradeStatusResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * MANUAL FW ROLLBACK DEFINITIONS
+ */
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgManualFirmwareRollbackReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgManualFirmwareRollbackResp
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+struct HpmfwupgManualFirmwareRollbackCtx
+{
+ struct HpmfwupgManualFirmwareRollbackReq req;
+ struct HpmfwupgManualFirmwareRollbackResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * QUERY ROLLBACK STATUS DEFINITIONS
+ */
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusResp
+{
+ unsigned char picmgId;
+ struct HpmfwupgComponentBitMask rollbackComp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusCtx
+{
+ struct HpmfwupgQueryRollbackStatusReq req;
+ struct HpmfwupgQueryRollbackStatusResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+/*
+ * QUERY SELF TEST RESULT DEFINITIONS
+ */
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQuerySelftestResultReq
+{
+ unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQuerySelftestResultResp
+{
+ unsigned char picmgId;
+ unsigned char result1;
+ unsigned char result2;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgQuerySelftestResultCtx
+{
+ struct HpmfwupgQuerySelftestResultReq req;
+ struct HpmfwupgQuerySelftestResultResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+/*
+ * HPM.1 IMAGE DEFINITIONS
+ */
+
+#define HPMFWUPG_HEADER_SIGNATURE_LENGTH 8
+#define HPMFWUPG_MANUFATURER_ID_LENGTH 3
+#define HPMFWUPG_PRODUCT_ID_LENGTH 2
+#define HPMFWUPG_TIME_LENGTH 4
+#define HPMFWUPG_TIMEOUT_LENGTH 1
+#define HPMFWUPG_COMP_REVISION_LENGTH 2
+#define HPMFWUPG_FIRM_REVISION_LENGTH 6
+#define HPMFWUPG_IMAGE_HEADER_VERSION 0
+#define HPMFWUPG_IMAGE_SIGNATURE "PICMGFWU"
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgImageHeader
+{
+ char signature[HPMFWUPG_HEADER_SIGNATURE_LENGTH];
+ unsigned char formatVersion;
+ unsigned char deviceId;
+ unsigned char manId[HPMFWUPG_MANUFATURER_ID_LENGTH];
+ unsigned char prodId[HPMFWUPG_PRODUCT_ID_LENGTH];
+ unsigned char time[HPMFWUPG_TIME_LENGTH];
+ union
+ {
+ struct
+ {
+ #if WORDS_BIGENDIAN
+ unsigned char imageSelfTest : 1;
+ unsigned char autRollback : 1;
+ unsigned char manRollback : 1;
+ unsigned char servAffected : 1;
+ unsigned char reserved : 4;
+ #else
+ unsigned char reserved : 4;
+ unsigned char servAffected : 1;
+ unsigned char manRollback : 1;
+ unsigned char autRollback : 1;
+ unsigned char imageSelfTest : 1;
+ #endif
+ } ATTRIBUTE_PACKING bitField;
+ unsigned char byte;
+ }ATTRIBUTE_PACKING imageCapabilities;
+ struct HpmfwupgComponentBitMask components;
+ unsigned char selfTestTimeout;
+ unsigned char rollbackTimeout;
+ unsigned char inaccessTimeout;
+ unsigned char compRevision[HPMFWUPG_COMP_REVISION_LENGTH];
+ unsigned char firmRevision[HPMFWUPG_FIRM_REVISION_LENGTH];
+ unsigned short oemDataLength;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+#define HPMFWUPG_DESCRIPTION_LENGTH 21
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgActionRecord
+{
+ unsigned char actionType;
+ struct HpmfwupgComponentBitMask components;
+ unsigned char checksum;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#define HPMFWUPG_FIRMWARE_SIZE_LENGTH 4
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgFirmwareImage
+{
+ unsigned char version[HPMFWUPG_FIRM_REVISION_LENGTH];
+ char desc[HPMFWUPG_DESCRIPTION_LENGTH];
+ unsigned char length[HPMFWUPG_FIRMWARE_SIZE_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgUpgradeCtx
+{
+ struct HpmfwupgComponentBitMask compUpdateMask;
+ unsigned int imageSize;
+ unsigned char* pImageData;
+ unsigned char componentId;
+ struct HpmfwupgGetTargetUpgCapabilitiesResp targetCap;
+ struct HpmfwupgGetGeneralPropResp genCompProp[HPMFWUPG_COMPONENT_ID_MAX];
+ struct ipm_devid_rsp devId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+typedef enum eHpmfwupgActionType
+{
+ HPMFWUPG_ACTION_BACKUP_COMPONENTS = 0,
+ HPMFWUPG_ACTION_PREPARE_COMPONENTS,
+ HPMFWUPG_ACTION_UPLOAD_FIRMWARE,
+ HPMFWUPG_ACTION_RESERVED = 0xFF
+} tHpmfwupgActionType;
+
+/*
+ * FUNCTIONS PROTOTYPES
+ */
+#define HPMFWUPG_MAJORMINOR_VERSION_SIZE 2
+
+
+#define DEFAULT_COMPONENT_UPLOAD 0x0F
+
+/*
+ * Options added for user to check the version and to view both the FILE and TARGET Version
+ */
+#define VERSIONCHECK_MODE 0x01
+#define VIEW_MODE 0x02
+#define DEBUG_MODE 0x04
+#define FORCE_MODE_ALL 0x08
+#define FORCE_MODE_COMPONENT 0x10
+#define FORCE_MODE (FORCE_MODE_ALL|FORCE_MODE_COMPONENT)
+
+typedef struct _VERSIONINFO
+{
+ unsigned char componentId;
+ unsigned char targetMajor;
+ unsigned char targetMinor;
+ unsigned char targetAux[4];
+ unsigned char rollbackMajor;
+ unsigned char rollbackMinor;
+ unsigned char rollbackAux[4];
+ unsigned char imageMajor;
+ unsigned char imageMinor;
+ unsigned char imageAux[4];
+ unsigned char coldResetRequired;
+ unsigned char rollbackSupported;
+ unsigned char skipUpgrade;
+ char descString[15];
+}VERSIONINFO, *PVERSIONINFO;
+
+VERSIONINFO gVersionInfo[HPMFWUPG_COMPONENT_ID_MAX];
+
+#define TARGET_VER (0x01)
+#define ROLLBACK_VER (0x02)
+#define IMAGE_VER (0x04)
+
+
+
+
+static int HpmfwupgPreUpgradeCheck(void *intf,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx,int componentToUpload,int option);
+static int HpmfwupgUpgrade(void *intf, char* imageFilename, int activate, int,int);
+static int HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgPreparationStage( void *intf,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx, int option);
+static int HpmfwupgUpgradeStage ( void *intf,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx, int compToUpload ,int option);
+static int HpmfwupgActivationStage(void *intf,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgGetTargetUpgCapabilities(void *intf,
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx* pCtx);
+static int HpmfwupgGetComponentProperties(void *intf,
+ struct HpmfwupgGetComponentPropertiesCtx* pCtx);
+static int HpmfwupgQuerySelftestResult(void *intf,
+ struct HpmfwupgQuerySelftestResultCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgQueryRollbackStatus(void *intf,
+ struct HpmfwupgQueryRollbackStatusCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgAbortUpgrade(void *intf,
+ struct HpmfwupgAbortUpgradeCtx* pCtx);
+static int HpmfwupgInitiateUpgradeAction(void *intf,
+ struct HpmfwupgInitiateUpgradeActionCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgUploadFirmwareBlock(void *intf,
+ struct HpmfwupgUploadFirmwareBlockCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx, int count ,
+ unsigned int *pOffset, unsigned int *blockLen);
+static int HpmfwupgFinishFirmwareUpload(void *intf,
+ struct HpmfwupgFinishFirmwareUploadCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgActivateFirmware(void *intf,
+ struct HpmfwupgActivateFirmwareCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgGetUpgradeStatus(void *intf,
+ struct HpmfwupgGetUpgradeStatusCtx* pCtxstruct,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgManualFirmwareRollback(void *intf,
+ struct HpmfwupgManualFirmwareRollbackCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static void HpmfwupgPrintUsage(void);
+static unsigned char HpmfwupgCalculateChecksum(unsigned char* pData, unsigned int length);
+static int HpmfwupgGetDeviceId(void *intf, struct ipm_devid_rsp* pGetDevId);
+static int HpmfwupgGetBufferFromFile(char* imageFilename, struct HpmfwupgUpgradeCtx* pFwupgCtx);
+static int HpmfwupgWaitLongDurationCmd(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx);
+
+static struct ipmi_rs * HpmfwupgSendCmd(void *intf, struct ipmi_rq req,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx);
+
+
+static int HpmFwupgActionUploadFirmware
+(
+ struct HpmfwupgComponentBitMask components,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx,
+ unsigned char** pImagePtr,
+ int componentToUpload,
+ void *intf,
+ int option,
+ int* pFlagColdReset
+);
+
+static char * hpm_decode_cc( uchar cmd, uchar cc )
+{
+ char *pstr;
+ switch(cc) {
+ case 0x80: pstr = "Command in progress"; break;
+ case 0x81: pstr = "HPM not supported"; break;
+ case 0x82: pstr = "Checksum error"; break;
+ case 0x83: pstr = "Firmware mismatch"; break;
+ default: pstr = decode_cc(cmd,cc);
+ }
+ return(pstr);
+}
+
+/****************************************************************************
+*
+* Function Name: HpmGetuserInput
+*
+* Description: This function gets input from user and returns TRUE if its Yes
+* or FALSE if its No
+*
+*****************************************************************************/
+int HpmGetUserInput(char *str)
+{
+ char userInput[2];
+ printf("%s",str);
+ scanf("%s",userInput);
+ if (toupper(userInput[0]) == 'Y')
+ {
+ return 1;
+ }
+ return 0;
+}
+/****************************************************************************
+*
+* Function Name: HpmDisplayLine
+*
+* Description: This is to display the line with the given character.
+*
+*****************************************************************************/
+void HpmDisplayLine(char *s, int n)
+{
+ while (n--) printf ("%c",*s);
+ printf("\n");
+}
+
+/****************************************************************************
+*
+* Function Name: HpmDisplayUpgradeHeader
+*
+* Description: This function the displays the Upgrade header information
+*
+*****************************************************************************/
+void HpmDisplayUpgradeHeader(int option)
+{
+ printf("\n");
+ HpmDisplayLine("-",78 );
+ printf("|ID | Name | Versions | %% |\n");
+ printf("| | | Active | Backup | File | |\n");
+ printf("|---|-----------|-----------------|-----------------|-----------------|------|\n");
+}
+
+/****************************************************************************
+*
+* Function Name: HpmDisplayUpgrade
+*
+* Description: This function displays the progress of the upgrade it prints the "."
+* every 5% of its completion.
+*
+*****************************************************************************/
+void HpmDisplayUpgrade( int skip, unsigned int totalSent,
+ unsigned int displayFWLength,time_t timeElapsed)
+{
+ int percent;
+ static int old_percent=1;
+ if (skip)
+ {
+ printf(" Skip |\n");
+ return;
+ }
+ fflush(stdout);
+
+ percent = (int)((totalSent * 100)/displayFWLength);
+ if (percent != old_percent)
+ {
+ if ( percent == 0 ) printf(" 0 %% |");
+ else if (percent == 100) printf("\b\b\b\b\b\b\b100 %% |\n");
+ else printf("\b\b\b\b\b\b\b%3d %% |", percent);
+ old_percent = percent;
+ }
+
+ if (totalSent== displayFWLength)
+ {
+ /* Display the time taken to complete the upgrade */
+ printf("| | Upload Time: %02d.%02d | Image Size: %05x |\n",
+ timeElapsed/60,timeElapsed%60,totalSent);
+ }
+}
+
+/****************************************************************************
+*
+* Function Name: HpmDisplayVersionHeader
+*
+* Description: This function displays the information about version header
+*
+*****************************************************************************/
+int HpmDisplayVersionHeader(int mode)
+{
+ if ( mode & IMAGE_VER)
+ {
+ HpmDisplayLine("-",71 );
+ printf("|ID | Name | Versions |\n");
+ printf("| | | Active | Backup | File |\n");
+ HpmDisplayLine("-",71 );
+ }
+ else
+ {
+ HpmDisplayLine("-",53 );
+ printf("|ID | Name | Versions |\n");
+ printf("| | | Active | Backup |\n");
+ HpmDisplayLine("-",53 );
+ }
+ return 0;
+}
+
+/****************************************************************************
+*
+* Function Name: HpmDisplayVersion
+*
+* Description: This function displays the version of the image and target
+*
+*****************************************************************************/
+int HpmDisplayVersion(int mode,VERSIONINFO *pVersion)
+{
+ char descString[12];
+ memset(&descString,0x00,12);
+ /*
+ * Added this to ensure that even if the description string
+ * is more than required it does not give problem in displaying it
+ */
+ strncpy(descString,pVersion->descString,11);
+ /*
+ * If the cold reset is required then we can display * on it
+ * so that user is aware that he needs to do payload power
+ * cycle after upgrade
+ */
+ printf("|%c%-2d|%-11s|",pVersion->coldResetRequired?'*':' ',pVersion->componentId,descString);
+
+ if (mode & TARGET_VER)
+ {
+ if (pVersion->targetMajor == 0xFF && pVersion->targetMinor == 0xFF)
+ printf(" ---.-- -------- |");
+ else
+ printf(" %3d.%02x %02X%02X%02X%02X |",
+ pVersion->targetMajor,
+ pVersion->targetMinor,
+ pVersion->targetAux[0],
+ pVersion->targetAux[1],
+ pVersion->targetAux[2],
+ pVersion->targetAux[3]
+ );
+
+ if (mode & ROLLBACK_VER)
+ {
+ if (pVersion->rollbackMajor == 0xFF && pVersion->rollbackMinor == 0xFF)
+ printf(" ---.-- -------- |");
+ else
+ printf(" %3d.%02x %02X%02X%02X%02X |",
+ pVersion->rollbackMajor,
+ pVersion->rollbackMinor,
+ pVersion->rollbackAux[0],
+ pVersion->rollbackAux[1],
+ pVersion->rollbackAux[2],
+ pVersion->rollbackAux[3]);
+ }
+ else
+ {
+ printf(" ---.-- -------- |");
+ }
+ }
+
+ if (mode & IMAGE_VER)
+ {
+ if (pVersion->imageMajor == 0xFF && pVersion->imageMinor == 0xFF)
+ printf(" ---.-- |");
+ else
+ printf(" %3d.%02x %02X%02X%02X%02X |",
+ pVersion->imageMajor,
+ pVersion->imageMinor,
+ pVersion->imageAux[0],
+ pVersion->imageAux[1],
+ pVersion->imageAux[2],
+ pVersion->imageAux[3]);
+ }
+ return 0;
+}
+
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgTargerCheck
+*
+* Description: This function gets the target information and displays it on the
+* screen
+*
+*****************************************************************************/
+int HpmfwupgTargetCheck(void * intf, int option)
+{
+ // struct HpmfwupgUpgradeCtx fwupgCtx;
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+ int rc = HPMFWUPG_SUCCESS;
+ int componentId = 0;
+ int flagColdReset = FALSE;
+ struct ipm_devid_rsp devIdrsp;
+ struct HpmfwupgGetComponentPropertiesCtx getCompProp;
+ int mode = 0;
+
+
+ rc = HpmfwupgGetDeviceId(intf, &devIdrsp);
+
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ lprintf(LOG_NOTICE,"Verify whether the Target board is present \n");
+ return rc;
+ }
+
+ rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ /*
+ * That indicates the target is not responding to the command
+ * May be that there is no HPM support
+ */
+ lprintf(LOG_NOTICE,"Board might not be supporting the HPM.1 Standards\n");
+ return rc;
+ }
+ if (option & VIEW_MODE)
+ {
+ lprintf(LOG_NOTICE,"-------Target Information-------");
+ lprintf(LOG_NOTICE,"Device Id : 0x%x", devIdrsp.device_id);
+ lprintf(LOG_NOTICE,"Device Revision : 0x%x", devIdrsp.device_revision);
+ lprintf(LOG_NOTICE,"Product Id : 0x%04x", buf2short(devIdrsp.product_id));
+ lprintf(LOG_NOTICE,"Manufacturer Id : 0x%04x (%s)\n\n",
+ buf2short(devIdrsp.manufacturer_id),
+ get_mfg_str(devIdrsp.manufacturer_id,NULL));
+ HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER);
+ }
+
+ for ( componentId = HPMFWUPG_COMPONENT_ID_0; componentId < HPMFWUPG_COMPONENT_ID_MAX;
+ componentId++ )
+ {
+ /* If the component is supported */
+ if ( ((1 << componentId) & targetCapCmd.resp.componentsPresent.ComponentBits.byte) )
+ {
+ memset((PVERSIONINFO)&gVersionInfo[componentId],0x00,sizeof(VERSIONINFO));
+
+ getCompProp.req.componentId = componentId;
+ getCompProp.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
+ rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ lprintf(LOG_NOTICE,"Get CompGenProp Failed for component Id %d\n",componentId);
+ return rc;
+ }
+
+ gVersionInfo[componentId].rollbackSupported = getCompProp.resp.Response.
+ generalPropResp.GeneralCompProperties.bitfield.rollbackBackup;
+ gVersionInfo[componentId].coldResetRequired = getCompProp.resp.Response.
+ generalPropResp.GeneralCompProperties.bitfield.payloadColdReset;
+
+ getCompProp.req.selector = HPMFWUPG_COMP_DESCRIPTION_STRING;
+ rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ lprintf(LOG_NOTICE,"Get CompDescString Failed for component Id %d\n",componentId);
+ return rc;
+ }
+ strcpy((char *)&gVersionInfo[componentId].descString,
+ getCompProp.resp.Response.descStringResp.descString);
+
+ getCompProp.req.selector = HPMFWUPG_COMP_CURRENT_VERSION;
+ rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ lprintf(LOG_NOTICE,"Get CompCurrentVersion Failed for component Id %d\n",componentId);
+ return rc;
+ }
+
+ gVersionInfo[componentId].componentId = componentId;
+ gVersionInfo[componentId].targetMajor = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[0];
+ gVersionInfo[componentId].targetMinor = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[1];
+ gVersionInfo[componentId].targetAux[0] = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[2];
+ gVersionInfo[componentId].targetAux[1] = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[3];
+ gVersionInfo[componentId].targetAux[2] = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[4];
+ gVersionInfo[componentId].targetAux[3] = getCompProp.resp.Response.
+ currentVersionResp.currentVersion[5];
+ mode = TARGET_VER;
+
+ if (gVersionInfo[componentId].rollbackSupported)
+ {
+ getCompProp.req.selector = HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION;
+ rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ lprintf(LOG_NOTICE,"Get CompRollbackVersion Failed for component Id %d\n",componentId);
+ } else {
+ gVersionInfo[componentId].rollbackMajor = getCompProp.resp
+ .Response.rollbackFwVersionResp.rollbackFwVersion[0];
+ gVersionInfo[componentId].rollbackMinor = getCompProp.resp
+ .Response.rollbackFwVersionResp.rollbackFwVersion[1];
+ gVersionInfo[componentId].rollbackAux[0] = getCompProp.resp.Response.
+ rollbackFwVersionResp.rollbackFwVersion[2];
+ gVersionInfo[componentId].rollbackAux[1] = getCompProp.resp.Response.
+ rollbackFwVersionResp.rollbackFwVersion[3];
+ gVersionInfo[componentId].rollbackAux[2] = getCompProp.resp.Response.
+ rollbackFwVersionResp.rollbackFwVersion[4];
+ gVersionInfo[componentId].rollbackAux[3] = getCompProp.resp.Response.
+ rollbackFwVersionResp.rollbackFwVersion[5];
+ }
+ mode |= ROLLBACK_VER;
+ }
+
+ if (gVersionInfo[componentId].coldResetRequired)
+ {
+ /*
+ * If any of the component indicates that the Payload Cold reset is required
+ * then set the flag
+ */
+ flagColdReset = TRUE;
+ }
+ if (option & VIEW_MODE)
+ {
+ HpmDisplayVersion(mode,&gVersionInfo[componentId]);
+ printf("\n");
+ }
+ }
+ }
+
+ if (option & VIEW_MODE)
+ {
+ HpmDisplayLine("-",53 );
+ if (flagColdReset)
+ {
+ fflush(stdout);
+ lprintf(LOG_NOTICE,"(*) Component requires Payload Cold Reset");
+ }
+ printf("\n\n");
+ }
+ return HPMFWUPG_SUCCESS;
+}
+
+/*****************************************************************************
+* Function Name: HpmfwupgUpgrade
+*
+* Description: This function performs the HPM.1 firmware upgrade procedure as
+* defined the IPM Controller Firmware Upgrade Specification
+* version 1.0
+*
+*****************************************************************************/
+int HpmfwupgUpgrade(void *intf, char* imageFilename,
+ int activate,int componentToUpload, int option)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ // struct HpmfwupgImageHeader imageHeader;
+ struct HpmfwupgUpgradeCtx fwupgCtx;
+
+ /*
+ * GET IMAGE BUFFER FROM FILE
+ */
+
+ rc = HpmfwupgGetBufferFromFile(imageFilename, &fwupgCtx);
+
+ /*
+ * VALIDATE IMAGE INTEGRITY
+ */
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ printf("Validating firmware image integrity...");
+ fflush(stdout);
+ rc = HpmfwupgValidateImageIntegrity(&fwupgCtx);
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ printf("OK\n");
+ fflush(stdout);
+ }
+ else
+ {
+ free(fwupgCtx.pImageData);
+ }
+ }
+
+ /*
+ * PREPARATION STAGE
+ */
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ printf("Performing preparation stage...");
+ fflush(stdout);
+ rc = HpmfwupgPreparationStage(intf, &fwupgCtx, option);
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ printf("OK\n");
+ fflush(stdout);
+ }
+ else
+ {
+ free(fwupgCtx.pImageData);
+ }
+ }
+
+ /*
+ * UPGRADE STAGE
+ */
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ if (option & VIEW_MODE)
+ {
+ lprintf(LOG_NOTICE,"\nComparing Target & Image File version");
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\nPerforming upgrade stage:");
+ }
+ if (option & VIEW_MODE)
+ {
+ rc = HpmfwupgPreUpgradeCheck(intf, &fwupgCtx,componentToUpload,VIEW_MODE);
+ }
+ else
+ {
+ rc = HpmfwupgPreUpgradeCheck(intf, &fwupgCtx,componentToUpload,option);
+ if (rc == HPMFWUPG_SUCCESS )
+ {
+ if( verbose ) {
+ printf("Component update mask : 0x%02x\n", fwupgCtx.compUpdateMask.ComponentBits.byte);
+ }
+ rc = HpmfwupgUpgradeStage(intf, &fwupgCtx,componentToUpload,option);
+ }
+ }
+
+ if ( rc != HPMFWUPG_SUCCESS )
+ {
+ if (verbose) printf("HPM Upgrade error %d\n",rc);
+ free(fwupgCtx.pImageData);
+ }
+ }
+
+ /*
+ * ACTIVATION STAGE
+ */
+ if ( rc == HPMFWUPG_SUCCESS && activate )
+ {
+ lprintf(LOG_NOTICE,"Performing activation stage: ");
+ rc = HpmfwupgActivationStage(intf, &fwupgCtx);
+ if ( rc != HPMFWUPG_SUCCESS )
+ {
+ if (verbose) printf("HPM Activation error %d\n",rc);
+ free(fwupgCtx.pImageData);
+ }
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ if (option & VIEW_MODE)
+ {
+ // Dont display anything here in case we are just viewing it
+ lprintf(LOG_NOTICE," ");
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\nFirmware upgrade procedure successful\n");
+ }
+ free(fwupgCtx.pImageData);
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Firmware upgrade procedure failed\n");
+ }
+
+ return rc;
+}
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgValidateImageIntegrity
+*
+* Description: This function validates a HPM.1 firmware image file as defined
+* in section 4 of the IPM Controller Firmware Upgrade
+* Specification version 1.0
+*
+*****************************************************************************/
+int HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+ md5_state_t ctx;
+ static unsigned char md[HPMFWUPG_MD5_SIGNATURE_LENGTH];
+ unsigned char* pMd5Sig = pFwupgCtx->pImageData +
+ (pFwupgCtx->imageSize -
+ HPMFWUPG_MD5_SIGNATURE_LENGTH);
+
+ /* Validate MD5 checksum */
+ memset(md, 0, HPMFWUPG_MD5_SIGNATURE_LENGTH);
+ memset(&ctx, 0, sizeof(md5_state_t));
+ md5_init(&ctx);
+ md5_append(&ctx, pFwupgCtx->pImageData, pFwupgCtx->imageSize -
+ HPMFWUPG_MD5_SIGNATURE_LENGTH);
+ md5_finish(&ctx, md);
+ if ( memcmp(md, pMd5Sig,HPMFWUPG_MD5_SIGNATURE_LENGTH) != 0 )
+ {
+ lprintf(LOG_NOTICE,"\n Invalid MD5 signature");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Validate Header signature */
+ if( strncmp(pImageHeader->signature, HPMFWUPG_IMAGE_SIGNATURE, HPMFWUPG_HEADER_SIGNATURE_LENGTH) == 0 )
+ {
+ /* Validate Header image format version */
+ if ( pImageHeader->formatVersion == HPMFWUPG_IMAGE_HEADER_VERSION )
+ {
+ /* Validate header checksum */
+ if ( HpmfwupgCalculateChecksum((unsigned char*)pImageHeader,
+ sizeof(struct HpmfwupgImageHeader) +
+ pImageHeader->oemDataLength +
+ sizeof(unsigned char)/*checksum*/) != 0 )
+ {
+ lprintf(LOG_NOTICE,"\n Invalid header checksum");
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\n Unrecognized image version");
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\n Invalid image signature");
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ return rc;
+}
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgPreparationStage
+*
+* Description: This function the preperation stage of a firmware upgrade
+* procedure as defined in section 3.2 of the IPM Controller
+* Firmware Upgrade Specification version 1.0
+*
+*****************************************************************************/
+int HpmfwupgPreparationStage(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx, int option)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+
+ /* Get device ID */
+ rc = HpmfwupgGetDeviceId(intf, &pFwupgCtx->devId);
+
+ /* Match current IPMC IDs with upgrade image */
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Validate device ID */
+ if ( pImageHeader->deviceId == pFwupgCtx->devId.device_id )
+ {
+ /* Validate product ID */
+ if ( memcmp(pImageHeader->prodId, pFwupgCtx->devId.product_id, HPMFWUPG_PRODUCT_ID_LENGTH ) == 0 )
+ {
+ /* Validate man ID */
+ if ( memcmp(pImageHeader->manId, pFwupgCtx->devId.manufacturer_id,
+ HPMFWUPG_MANUFATURER_ID_LENGTH ) != 0 )
+ {
+ lprintf(LOG_NOTICE,"\n Invalid image file for manufacturer %u",
+ buf2short(pFwupgCtx->devId.manufacturer_id));
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\n Invalid image file for product %u",
+ buf2short(pFwupgCtx->devId.product_id));
+ rc = HPMFWUPG_ERROR;
+ }
+
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"\n Invalid device ID %x", pFwupgCtx->devId.device_id);
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ /*
+ * Giving one more chance to user to check whether its OK to continue even if the
+ * product ID does not match. This is helpful as sometimes we just want to update
+ * and dont care whether we have a different product Id. If the user says NO then
+ * we need to just bail out from here
+ */
+ if ( (option & FORCE_MODE) || (option & VIEW_MODE) )
+ {
+ printf("\n Image Information");
+ printf("\n Device Id : 0x%x",pImageHeader->deviceId);
+ printf("\n Prod Id : 0x%02x%02x",pImageHeader->prodId[1], pImageHeader->prodId[0]);
+ printf("\n Manuf Id : 0x%02x%02x%02x",pImageHeader->manId[2],
+ pImageHeader->manId[1],pImageHeader->manId[0]);
+ printf("\n Board Information");
+ printf("\n Device Id : 0x%x", pFwupgCtx->devId.device_id);
+ printf("\n Prod Id : 0x%02x%02x",pFwupgCtx->devId.product_id[1], pFwupgCtx->devId.product_id[0]);
+ printf("\n Manuf Id : 0x%02x%02x%02x",pFwupgCtx->devId.manufacturer_id[2],
+ pFwupgCtx->devId.manufacturer_id[1],pFwupgCtx->devId.manufacturer_id[0]);
+ if (HpmGetUserInput("\n Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N) :"))
+ rc = HPMFWUPG_SUCCESS;
+ }
+ else
+ {
+ /*
+ * If you use all option its kind of FORCE command where we need to upgrade all the components
+ */
+ printf("\n\n Use \"all\" option for uploading all the components\n");
+ }
+ }
+ }
+
+ /* Validate earliest compatible revision */
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Validate major & minor revision */
+ if ( pImageHeader->compRevision[0] < pFwupgCtx->devId.fw_rev1 )
+ {
+ /* Do nothing, upgrade accepted */
+ }
+ else if ( pImageHeader->compRevision[0] == pFwupgCtx->devId.fw_rev1 )
+ {
+ /* Must validate minor revision */
+ if ( pImageHeader->compRevision[1] > pFwupgCtx->devId.fw_rev2 )
+ {
+ /* Version not compatible for upgrade */
+ lprintf(LOG_NOTICE,"\n Version: Major: %d", pImageHeader->compRevision[0]);
+ lprintf(LOG_NOTICE," Minor: %x", pImageHeader->compRevision[1]);
+ lprintf(LOG_NOTICE," Not compatible with ");
+ lprintf(LOG_NOTICE," Version: Major: %d", pFwupgCtx->devId.fw_rev1);
+ lprintf(LOG_NOTICE," Minor: %x", pFwupgCtx->devId.fw_rev2);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ /* Version not compatible for upgrade */
+ lprintf(LOG_NOTICE,"\n Version: Major: %d", pImageHeader->compRevision[0]);
+ lprintf(LOG_NOTICE," Minor: %x", pImageHeader->compRevision[1]);
+ lprintf(LOG_NOTICE," Not compatible with ");
+ lprintf(LOG_NOTICE," Version: Major: %d", pFwupgCtx->devId.fw_rev1);
+ lprintf(LOG_NOTICE," Minor: %x", pFwupgCtx->devId.fw_rev2);
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ /* Confirming it once again */
+ if ( (option & FORCE_MODE) || (option & VIEW_MODE) )
+ {
+ if( HpmGetUserInput("\n Continue IGNORING Earliest compatibility (Y/N) :"))
+ rc = HPMFWUPG_SUCCESS;
+ }
+ }
+ }
+
+ /* Get target upgrade capabilities */
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+
+ rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Copy response to context */
+ memcpy(&pFwupgCtx->targetCap,
+ &targetCapCmd.resp,
+ sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
+
+ if (option & VIEW_MODE)
+ {
+ return rc;
+ }
+ else
+ {
+ /* Make sure all component IDs defined in the upgrade
+ image are supported by the IPMC */
+ if ( (pImageHeader->components.ComponentBits.byte &
+ pFwupgCtx->targetCap.componentsPresent.ComponentBits.byte ) !=
+ pImageHeader->components.ComponentBits.byte )
+ {
+ lprintf(LOG_NOTICE,"\n Some components present in the image file are not supported by the IPMC");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ /* Make sure the upgrade is desirable rigth now */
+ if ( pFwupgCtx->targetCap.GlobalCapabilities.bitField.fwUpgUndesirable == 1 )
+ {
+ lprintf(LOG_NOTICE,"\n Upgrade undesirable at this moment");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ /* Get confimation from the user if he wants to continue when service
+ affected during upgrade */
+ if ( pFwupgCtx->targetCap.GlobalCapabilities.bitField.servAffectDuringUpg == 1 ||
+ pImageHeader->imageCapabilities.bitField.servAffected == 1 )
+ {
+ if (HpmGetUserInput("\nServices may be affected during upgrade. Do you wish to continue? y/n "))
+ {
+ rc = HPMFWUPG_SUCCESS;
+ }
+ else
+ {
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ }
+ }
+ }
+
+ /* Get the general properties of each component present in image */
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ int componentId;
+
+ for ( componentId = HPMFWUPG_COMPONENT_ID_0;
+ componentId < HPMFWUPG_COMPONENT_ID_MAX;
+ componentId++ )
+ {
+ /* Reset component properties */
+ memset(&pFwupgCtx->genCompProp[componentId], 0, sizeof (struct HpmfwupgGetGeneralPropResp));
+
+ if ( (1 << componentId & pImageHeader->components.ComponentBits.byte) )
+ {
+ struct HpmfwupgGetComponentPropertiesCtx getCompPropCmd;
+
+ /* Get general component properties */
+ getCompPropCmd.req.componentId = componentId;
+ getCompPropCmd.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
+
+ rc = HpmfwupgGetComponentProperties(intf, &getCompPropCmd);
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Copy response to context */
+ memcpy(&pFwupgCtx->genCompProp[componentId],
+ &getCompPropCmd.resp,
+ sizeof(struct HpmfwupgGetGeneralPropResp));
+ }
+ }
+ }
+ }
+
+ return rc;
+}
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgPreUpgradeCheck
+*
+* Description: This function the pre Upgrade check, this mainly helps in checking
+* which all version upgrade is skippable because the image version
+* is same as target version.
+*
+*****************************************************************************/
+int HpmfwupgPreUpgradeCheck(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx,
+ int componentToUpload,int option)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ unsigned char* pImagePtr;
+ struct HpmfwupgActionRecord* pActionRecord;
+ unsigned int actionsSize;
+ int flagColdReset = FALSE;
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+
+ /* Put pointer after image header */
+ pImagePtr = (unsigned char*)
+ (pFwupgCtx->pImageData + sizeof(struct HpmfwupgImageHeader) +
+ pImageHeader->oemDataLength + sizeof(unsigned char)/*checksum*/);
+
+ /* Deternime actions size */
+ actionsSize = pFwupgCtx->imageSize - sizeof(struct HpmfwupgImageHeader);
+
+ if (option & VIEW_MODE)
+ {
+ HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER|IMAGE_VER);
+ }
+
+ /* Perform actions defined in the image */
+ while( ( pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize -
+ HPMFWUPG_MD5_SIGNATURE_LENGTH)) &&
+ ( rc == HPMFWUPG_SUCCESS) )
+ {
+ /* Get action record */
+ pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
+
+ /* Validate action record checksum */
+ if ( HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
+ sizeof(struct HpmfwupgActionRecord)) != 0 )
+ {
+ lprintf(LOG_NOTICE," Invalid Action record.");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ switch( pActionRecord->actionType )
+ {
+ case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
+ {
+ pImagePtr += sizeof(struct HpmfwupgActionRecord);
+ }
+ break;
+
+ case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
+ {
+ if (componentToUpload != DEFAULT_COMPONENT_UPLOAD)
+ {
+ if (!(1<<componentToUpload & pActionRecord->components.ComponentBits.byte))
+ {
+ lprintf(LOG_NOTICE,"\nComponent Id given is not supported\n");
+ return HPMFWUPG_ERROR;
+ }
+ }
+ pImagePtr += sizeof(struct HpmfwupgActionRecord);
+ }
+ break;
+
+ case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
+ /* Upload all firmware blocks */
+ {
+ struct HpmfwupgFirmwareImage* pFwImage;
+ unsigned char* pData;
+ unsigned int firmwareLength = 0;
+ unsigned char mode = 0;
+ unsigned char componentId = 0x00;
+ unsigned char componentIdByte = 0x00;
+ VERSIONINFO *pVersionInfo;
+ // struct HpmfwupgGetComponentPropertiesCtx getCompProp;
+
+ /* Save component ID on which the upload is done */
+ componentIdByte = pActionRecord->components.ComponentBits.byte;
+
+ while ((componentIdByte>>=1)!=0)
+ {
+ componentId++;
+ }
+ pFwupgCtx->componentId = componentId;
+
+ pFwImage = (struct HpmfwupgFirmwareImage*)(pImagePtr +
+ sizeof(struct HpmfwupgActionRecord));
+
+ pData = ((unsigned char*)pFwImage + sizeof(struct HpmfwupgFirmwareImage));
+
+ /* Get firmware length */
+ firmwareLength = pFwImage->length[0];
+ firmwareLength |= (pFwImage->length[1] << 8) & 0xff00;
+ firmwareLength |= (pFwImage->length[2] << 16) & 0xff0000;
+ firmwareLength |= (pFwImage->length[3] << 24) & 0xff000000;
+
+ pVersionInfo = &gVersionInfo[componentId];
+
+ pVersionInfo->imageMajor = pFwImage->version[0];
+ pVersionInfo->imageMinor = pFwImage->version[1];
+ pVersionInfo->imageAux[0] = pFwImage->version[2];
+ pVersionInfo->imageAux[1] = pFwImage->version[3];
+ pVersionInfo->imageAux[2] = pFwImage->version[4];
+ pVersionInfo->imageAux[3] = pFwImage->version[5];
+
+ mode = TARGET_VER | IMAGE_VER;
+
+ if (pVersionInfo->coldResetRequired)
+ {
+ flagColdReset = TRUE;
+ }
+ pVersionInfo->skipUpgrade = FALSE;
+
+ if (option & FORCE_MODE_ALL)
+ {
+ /* user has given all to upload all the components on the command line */
+ if(verbose) {
+ lprintf(LOG_NOTICE,"Forcing ALL components");
+ }
+ }
+ else if( option & FORCE_MODE_COMPONENT )
+ {
+ if( componentToUpload != componentId )
+ {
+ if(verbose) {
+ lprintf(LOG_NOTICE,"Forcing component %d skip", componentId);
+ }
+ /* user has given the component Id to upload on the command line */
+ pVersionInfo->skipUpgrade = TRUE;
+ }
+ else if(verbose)
+ {
+ lprintf(LOG_NOTICE,"Forcing component %d update", componentId);
+ /* user has given the component Id to upload on the command line */
+ }
+ }
+ else
+ {
+ if
+ (
+ (pVersionInfo->imageMajor == pVersionInfo->targetMajor)
+ &&
+ (pVersionInfo->imageMinor == pVersionInfo->targetMinor))
+ {
+ if (pVersionInfo->rollbackSupported)
+ {
+ /*If the Image Versions are same as Target Versions then check for the
+ * rollback version*/
+ if
+ (
+ (pVersionInfo->imageMajor == pVersionInfo->rollbackMajor)
+ &&
+ (pVersionInfo->imageMinor == pVersionInfo->rollbackMinor)
+ )
+ {
+ /* This indicates that the Rollback version is also same as
+ * Image version -- So now we must skip it */
+ pVersionInfo->skipUpgrade = TRUE;
+ }
+ mode |= ROLLBACK_VER;
+ }
+ else
+ {
+ pVersionInfo->skipUpgrade = TRUE;
+ }
+ }
+ if ( verbose ) {
+ lprintf(LOG_NOTICE,"Component %d: %s", componentId , (pVersionInfo->skipUpgrade?"skipped":"to update"));
+ }
+ }
+ if( pVersionInfo->skipUpgrade == FALSE )
+ {
+ pFwupgCtx->compUpdateMask.ComponentBits.byte |= 1<<componentId;
+ }
+ if (option & VIEW_MODE)
+ {
+ HpmDisplayVersion(mode,pVersionInfo);
+ printf("\n");
+ }
+ pImagePtr = pData + firmwareLength;
+ }
+ break;
+ default:
+ lprintf(LOG_NOTICE," Invalid Action type. Cannot continue");
+ rc = HPMFWUPG_ERROR;
+ break;
+ }
+ }
+ }
+ if (option & VIEW_MODE)
+ {
+ HpmDisplayLine("-",71);
+ if (flagColdReset)
+ {
+ fflush(stdout);
+ lprintf(LOG_NOTICE,"(*) Component requires Payload Cold Reset");
+ }
+ }
+ return rc;
+}
+
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgUpgradeStage
+*
+* Description: This function the upgrade stage of a firmware upgrade
+* procedure as defined in section 3.3 of the IPM Controller
+* Firmware Upgrade Specification version 1.0
+*
+*****************************************************************************/
+int HpmfwupgUpgradeStage(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx,
+ int componentToUpload, int option)
+{
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+ struct HpmfwupgActionRecord* pActionRecord;
+
+ int rc = HPMFWUPG_SUCCESS;
+ unsigned char* pImagePtr;
+ unsigned int actionsSize;
+ int flagColdReset = FALSE;
+ // time_t start,end;
+
+ /* Put pointer after image header */
+ pImagePtr = (unsigned char*)
+ (pFwupgCtx->pImageData + sizeof(struct HpmfwupgImageHeader) +
+ pImageHeader->oemDataLength + sizeof(unsigned char)/*checksum*/);
+
+ /* Deternime actions size */
+ actionsSize = pFwupgCtx->imageSize - sizeof(struct HpmfwupgImageHeader);
+
+ if (option & VERSIONCHECK_MODE || option & FORCE_MODE)
+ {
+ HpmDisplayUpgradeHeader(0);
+ }
+
+ /* Perform actions defined in the image */
+ while( ( pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize -
+ HPMFWUPG_MD5_SIGNATURE_LENGTH)) &&
+ ( rc == HPMFWUPG_SUCCESS) )
+ {
+ /* Get action record */
+ pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
+
+ /* Validate action record checksum */
+ if ( HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
+ sizeof(struct HpmfwupgActionRecord)) != 0 )
+ {
+ lprintf(LOG_NOTICE," Invalid Action record.");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ switch( pActionRecord->actionType )
+ {
+ case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
+ {
+ /* Send prepare components command */
+ struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+
+ initUpgActionCmd.req.componentsMask = pFwupgCtx->compUpdateMask;
+ /* Action is prepare components */
+ initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_BACKUP;
+ rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+ pImagePtr += sizeof(struct HpmfwupgActionRecord);
+
+ }
+ break;
+ case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
+ {
+ int componentId;
+ /* Make sure every components specified by this action
+ supports the prepare components */
+
+ /* Component 'filtering' is done in PreUpdateCheck() and pFwupgCtx is set accordiongly */
+
+ for ( componentId = HPMFWUPG_COMPONENT_ID_0;
+ componentId < HPMFWUPG_COMPONENT_ID_MAX;
+ componentId++ )
+ {
+ if ( (1 << componentId & pFwupgCtx->compUpdateMask.ComponentBits.byte) )
+ {
+ if ( pFwupgCtx->genCompProp[componentId].GeneralCompProperties.bitfield.preparationSupport == 0 )
+ {
+ lprintf(LOG_NOTICE," Prepare component not supported by component ID %d", componentId);
+ rc = HPMFWUPG_ERROR;
+ break;
+ }
+ }
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ if ( pFwupgCtx->compUpdateMask.ComponentBits.byte != 0x00 )
+ {
+ /* Send prepare components command */
+ struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+ initUpgActionCmd.req.componentsMask = pFwupgCtx->compUpdateMask;
+ /* Action is prepare components */
+ initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_PREPARE;
+ rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+
+ }
+ pImagePtr += sizeof(struct HpmfwupgActionRecord);
+ }
+ }
+ break;
+
+ case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
+ /* Upload all firmware blocks */
+ rc = HpmFwupgActionUploadFirmware
+ (
+ pActionRecord->components,
+ pFwupgCtx,
+ &pImagePtr,
+ componentToUpload,
+ intf,
+ option,
+ &flagColdReset
+ );
+
+ break;
+ default:
+ lprintf(LOG_NOTICE," Invalid Action type. Cannot continue");
+ rc = HPMFWUPG_ERROR;
+ break;
+ }
+ }
+ }
+
+ HpmDisplayLine("-",78);
+
+ if (flagColdReset)
+ {
+ fflush(stdout);
+ lprintf(LOG_NOTICE,"(*) Component requires Payload Cold Reset");
+ }
+ return rc;
+}
+
+static int HpmFwupgActionUploadFirmware
+(
+ struct HpmfwupgComponentBitMask components,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx,
+ unsigned char** pImagePtr,
+ int componentToUpload,
+ void *intf,
+ int option,
+ int *pFlagColdReset
+)
+{
+ struct HpmfwupgFirmwareImage* pFwImage;
+ struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+ struct HpmfwupgUploadFirmwareBlockCtx uploadCmd;
+ struct HpmfwupgFinishFirmwareUploadCtx finishCmd;
+ // struct HpmfwupgGetComponentPropertiesCtx getCompProp;
+ VERSIONINFO *pVersionInfo;
+ time_t start,end;
+
+ int rc = HPMFWUPG_SUCCESS;
+ int skip = TRUE;
+ unsigned char* pData, *pDataInitial;
+ unsigned char count;
+ unsigned int totalSent = 0;
+ unsigned char bufLength = 0;
+ unsigned int firmwareLength = 0;
+
+ unsigned int displayFWLength = 0;
+ unsigned char *pDataTemp;
+ unsigned int imageOffset = 0x00;
+ unsigned int blockLength = 0x00;
+ unsigned int lengthOfBlock = 0x00;
+ unsigned int numTxPkts = 0;
+ unsigned int numRxPkts = 0;
+ unsigned char mode = 0;
+ unsigned char componentId = 0x00;
+ unsigned char componentIdByte = 0x00;
+
+ /* Save component ID on which the upload is done */
+ componentIdByte = components.ComponentBits.byte;
+ while ((componentIdByte>>=1)!=0)
+ {
+ componentId++;
+ }
+ pFwupgCtx->componentId = componentId;
+
+ pVersionInfo = (VERSIONINFO*) &gVersionInfo[componentId];
+
+ pFwImage = (struct HpmfwupgFirmwareImage*)((*pImagePtr) +
+ sizeof(struct HpmfwupgActionRecord));
+
+ pDataInitial = ((unsigned char*)pFwImage + sizeof(struct HpmfwupgFirmwareImage));
+ pData = pDataInitial;
+
+ /* Get firmware length */
+ firmwareLength = pFwImage->length[0];
+ firmwareLength |= (pFwImage->length[1] << 8) & 0xff00;
+ firmwareLength |= (pFwImage->length[2] << 16) & 0xff0000;
+ firmwareLength |= (pFwImage->length[3] << 24) & 0xff000000;
+
+ mode = TARGET_VER | IMAGE_VER;
+
+ if (pVersionInfo->rollbackSupported)
+ {
+ mode |= ROLLBACK_VER;
+ }
+
+ if ((option & DEBUG_MODE))
+ {
+ printf("\n\n Comp ID : %d [%-20s]\n",pVersionInfo->componentId,pFwImage->desc);
+ }
+ else
+ {
+ HpmDisplayVersion(mode,pVersionInfo);
+ }
+
+ if( (1 << componentId) & pFwupgCtx->compUpdateMask.ComponentBits.byte)
+ {
+ if( verbose ) {
+ lprintf(LOG_NOTICE,"Do not skip %d" , componentId);
+ }
+ skip = FALSE;
+ }
+
+ if(!skip)
+ {
+ /* Initialize parameters */
+ uploadCmd.req.blockNumber = 0;
+
+ /* Check if we receive size in parameters */
+ if(g_channel_buf_size != 0)
+ {
+ if (g_sa == BMC_SA)
+ {
+ bufLength = g_channel_buf_size - 9; /* Plan for overhead */
+ }
+ else
+ {
+ bufLength = g_channel_buf_size - 11; /* Plan for overhead */
+ }
+ }
+ else
+ {
+ /* Find max buffer length according the connection parameters */
+ if ( is_remote() ) /*IPMI LAN*/
+ {
+ bufLength = HPMFWUPG_SEND_DATA_COUNT_LAN - 2;
+ if (g_sa != BMC_SA)
+ bufLength -= 8;
+ }
+ else
+ {
+ int i;
+ i = get_driver_type();
+ if ((i == DRV_MV || i == DRV_KCS) && /*open driver*/
+ (g_sa == BMC_SA) )
+ {
+ bufLength = HPMFWUPG_SEND_DATA_COUNT_KCS - 2;
+ }
+ else
+ {
+ if ( g_bus == 7 )
+ {
+ bufLength = HPMFWUPG_SEND_DATA_COUNT_IPMBL;
+ }
+ else
+ {
+ bufLength = HPMFWUPG_SEND_DATA_COUNT_IPMB;
+ }
+ }
+ }
+ }
+ if (verbose)
+ printf("Upgrade buffer size = %d (%d)\n",bufLength,g_channel_buf_size);
+
+ /* Send Initiate Upgrade Action */
+ initUpgActionCmd.req.componentsMask = components;
+ /* Action is upgrade */
+ initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_UPGRADE;
+ rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+
+ if (rc != HPMFWUPG_SUCCESS)
+ {
+ skip = TRUE;
+ }
+
+ if ( (pVersionInfo->coldResetRequired) && (!skip))
+ {
+ *pFlagColdReset = TRUE;
+ }
+ /* pDataInitial is the starting pointer of the image data */
+ /* pDataTemp is one which we will move across */
+ pData = pDataInitial;
+ pDataTemp = pDataInitial;
+ lengthOfBlock = firmwareLength;
+ totalSent = 0x00;
+ displayFWLength= firmwareLength;
+ time(&start);
+
+
+ while ( (pData < (pDataTemp+lengthOfBlock)) && (rc == HPMFWUPG_SUCCESS) )
+ {
+ if ( (pData+bufLength) <= (pDataTemp+lengthOfBlock) )
+ {
+ count = bufLength;
+ }
+ else
+ {
+ count = (unsigned char)((pDataTemp+lengthOfBlock) - pData);
+ }
+ memcpy(&uploadCmd.req.data, pData, bufLength);
+
+ imageOffset = 0x00;
+ blockLength = 0x00;
+ numTxPkts++;
+ rc = HpmfwupgUploadFirmwareBlock(intf, &uploadCmd, pFwupgCtx, count,
+ &imageOffset,&blockLength);
+ numRxPkts++;
+
+ if ( rc != HPMFWUPG_SUCCESS)
+ {
+ if ( rc == HPMFWUPG_UPLOAD_BLOCK_LENGTH )
+ {
+ /* Retry with a smaller buffer length */
+ if ( is_remote() ) // strstr(intf->name,"lan") != NULL
+ {
+ bufLength -= (unsigned char)8;
+ lprintf(LOG_INFO,"Trying reduced buffer length: %d", bufLength);
+ }
+ else
+ {
+ bufLength -= (unsigned char)1;
+ lprintf(LOG_INFO,"Trying reduced buffer length: %d", bufLength);
+ }
+ rc = HPMFWUPG_SUCCESS;
+ }
+ else if ( rc == HPMFWUPG_UPLOAD_RETRY )
+ {
+ rc = HPMFWUPG_SUCCESS;
+ }
+ else
+ {
+ fflush(stdout);
+ lprintf(LOG_NOTICE,"\n Error in Upload FIRMWARE command [rc=%d]\n",rc);
+ lprintf(LOG_NOTICE,"\n TotalSent:0x%x ",totalSent);
+ /* Exiting from the function */
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ if (blockLength > firmwareLength)
+ {
+ /*
+ * blockLength is the remaining length of the firmware to upload so
+ * if its greater than the firmware length then its kind of error
+ */
+ lprintf(LOG_NOTICE,"\n Error in Upload FIRMWARE command [rc=%d]\n",rc);
+ lprintf(LOG_NOTICE,"\n TotalSent:0x%x Img offset:0x%x Blk length:0x%x Fwlen:0x%x\n",
+ totalSent,imageOffset,blockLength,firmwareLength);
+ rc = HPMFWUPG_ERROR;
+ }
+ totalSent += count;
+ if (imageOffset != 0x00)
+ {
+ /* block Length is valid */
+ lengthOfBlock = blockLength;
+ pDataTemp = pDataInitial + imageOffset;
+ pData = pDataTemp;
+ if ( displayFWLength == firmwareLength)
+ {
+ /* This is basically used only to make sure that we display uptil 100% */
+ displayFWLength = blockLength + totalSent;
+ }
+ }
+ else
+ {
+ pData += count;
+ }
+ time(&end);
+ /*
+ * Just added debug mode in case we need to see exactly how many bytes have
+ * gone through - Its a hidden option used mainly should be used for debugging
+ */
+ if ( option & DEBUG_MODE)
+ {
+ fflush(stdout);
+ printf(" Blk Num : %02x Bytes : %05x \r\n",
+ uploadCmd.req.blockNumber,totalSent);
+ if (imageOffset || blockLength)
+ {
+ printf("\r--> ImgOff : %x BlkLen : %x\n",imageOffset,blockLength);
+ }
+ if (displayFWLength == totalSent)
+ {
+ printf(" Time Taken %02d:%02d\n",(end-start)/60, (end-start)%60);
+ printf("\n");
+ }
+ }
+ else
+ {
+ HpmDisplayUpgrade(0,totalSent,displayFWLength,(end-start));
+ }
+ uploadCmd.req.blockNumber++;
+ }
+ }
+ }
+
+ if (skip)
+ {
+
+ HpmDisplayUpgrade(1,0,0,0);
+ *pImagePtr = pDataInitial + firmwareLength;
+ }
+
+ if
+ (
+ (rc == HPMFWUPG_SUCCESS)
+ &&
+ (!skip)
+ )
+ {
+ /* Send finish component */
+ /* Set image length */
+ finishCmd.req.componentId = componentId;
+ /* We need to send the actual data that is sent
+ * not the comlete firmware image length
+ */
+ finishCmd.req.imageLength[0] = totalSent & 0xFF;
+ finishCmd.req.imageLength[1] = (totalSent >> 8) & 0xFF;
+ finishCmd.req.imageLength[2] = (totalSent >> 16) & 0xFF;
+ finishCmd.req.imageLength[3] = (totalSent >> 24) & 0xFF;
+ rc = HpmfwupgFinishFirmwareUpload(intf, &finishCmd, pFwupgCtx);
+ if ( option & DEBUG_MODE)
+ printf("HpmfwupgFinishFirmwareUpload rc = %d sent = %d\n",rc,totalSent);
+ *pImagePtr = pDataInitial + firmwareLength;
+ }
+
+ return rc;
+}
+
+/****************************************************************************
+*
+* Function Name: HpmfwupgActivationStage
+*
+* Description: This function the validation stage of a firmware upgrade
+* procedure as defined in section 3.4 of the IPM Controller
+* Firmware Upgrade Specification version 1.0
+*
+*****************************************************************************/
+static int HpmfwupgActivationStage(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct HpmfwupgActivateFirmwareCtx activateCmd;
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+
+ /* Print out stuf...*/
+ printf(" ");
+ fflush(stdout);
+ /* Activate new firmware */
+ rc = HpmfwupgActivateFirmware(intf, &activateCmd, pFwupgCtx);
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Query self test result if supported by target and new image */
+ if ( (pFwupgCtx->targetCap.GlobalCapabilities.bitField.ipmcSelftestCap == 1) ||
+ (pImageHeader->imageCapabilities.bitField.imageSelfTest == 1) )
+ {
+ struct HpmfwupgQuerySelftestResultCtx selfTestCmd;
+ rc = HpmfwupgQuerySelftestResult(intf, &selfTestCmd, pFwupgCtx);
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Get the self test result */
+ if ( selfTestCmd.resp.result1 != 0x55 )
+ {
+ /* Perform manual rollback if necessary */
+ /* BACKUP/ MANUAL ROLLBACK not supported by this UA */
+ lprintf(LOG_NOTICE," Self test failed:");
+ lprintf(LOG_NOTICE," Result1 = %x", selfTestCmd.resp.result1);
+ lprintf(LOG_NOTICE," Result2 = %x", selfTestCmd.resp.result2);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ /* Perform manual rollback if necessary */
+ /* BACKUP / MANUAL ROLLBACK not supported by this UA */
+ lprintf(LOG_NOTICE," Self test failed.");
+ }
+ }
+ }
+
+ /* If activation / self test failed, query rollback status if automatic rollback supported */
+ if ( rc == HPMFWUPG_ERROR )
+ {
+ if ( (pFwupgCtx->targetCap.GlobalCapabilities.bitField.autRollback == 1) &&
+ (pFwupgCtx->genCompProp[pFwupgCtx->componentId].GeneralCompProperties.bitfield.rollbackBackup != 0x00) )
+ {
+ struct HpmfwupgQueryRollbackStatusCtx rollCmd;
+ lprintf(LOG_NOTICE," Getting rollback status...");
+ fflush(stdout);
+ rc = HpmfwupgQueryRollbackStatus(intf, &rollCmd, pFwupgCtx);
+ }
+ }
+
+ return rc;
+}
+
+int HpmfwupgGetBufferFromFile(char* imageFilename, struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ FILE* pImageFile = fopen(imageFilename, "rb");
+
+ if ( pImageFile == NULL )
+ {
+ lprintf(LOG_NOTICE,"Cannot open image file %s", imageFilename);
+ rc = HPMFWUPG_ERROR;
+ }
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ /* Get the raw data in file */
+ fseek(pImageFile, 0, SEEK_END);
+ pFwupgCtx->imageSize = ftell(pImageFile);
+ pFwupgCtx->pImageData = malloc(sizeof(unsigned char)*pFwupgCtx->imageSize);
+ pFwupgCtx->compUpdateMask.ComponentBits.byte = 0;
+ rewind(pImageFile);
+ if ( pFwupgCtx->pImageData != NULL )
+ {
+ fread(pFwupgCtx->pImageData, sizeof(unsigned char), pFwupgCtx->imageSize, pImageFile);
+ }
+ else
+ {
+ rc = HPMFWUPG_ERROR;
+ }
+
+ fclose(pImageFile);
+ }
+
+ return rc;
+}
+
+int HpmfwupgGetDeviceId(void *intf, struct ipm_devid_rsp* pGetDevId)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_DEVICE_ID;
+ req.msg.data_len = 0;
+
+ rsp = HpmfwupgSendCmd(intf, req, NULL);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ memcpy(pGetDevId, rsp->data, sizeof(struct ipm_devid_rsp));
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting device ID, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting device ID\n");
+ rc = HPMFWUPG_ERROR;
+ }
+ return rc;
+}
+
+int HpmfwupgGetTargetUpgCapabilities(void *intf,
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx* pCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_GET_TARGET_UPG_CAPABILITIES;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgGetTargetUpgCapabilitiesReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, NULL);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"TARGET UPGRADE CAPABILITIES");
+ lprintf(LOG_NOTICE,"-------------------------------");
+ lprintf(LOG_NOTICE,"HPM.1 version............%d ", pCtx->resp.hpmVersion);
+ lprintf(LOG_NOTICE,"Component 0 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component0 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 1 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component1 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 2 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component2 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 3 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component3 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 4 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component4 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 5 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component5 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 6 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component6 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Component 7 presence....[%c] ", pCtx->resp.componentsPresent.ComponentBits.
+ bitField.component7 ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Upgrade undesirable.....[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.fwUpgUndesirable ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Aut rollback override...[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.autRollbackOverride ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"IPMC degraded...........[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.ipmcDegradedDurinUpg ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Defered activation......[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.deferActivation ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Service affected........[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.servAffectDuringUpg ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Manual rollback.........[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.manualRollback ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Automatic rollback......[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.autRollback ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Self test...............[%c] ", pCtx->resp.GlobalCapabilities.
+ bitField.ipmcSelftestCap ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Upgrade timeout.........[%d sec] ", pCtx->resp.upgradeTimeout*5);
+ lprintf(LOG_NOTICE,"Self test timeout.......[%d sec] ", pCtx->resp.selftestTimeout*5);
+ lprintf(LOG_NOTICE,"Rollback timeout........[%d sec] ", pCtx->resp.rollbackTimeout*5);
+ lprintf(LOG_NOTICE,"Inaccessibility timeout.[%d sec] \n", pCtx->resp.inaccessTimeout*5);
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting target upgrade capabilities\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting target upgrade capabilities\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+
+
+ return rc;
+}
+
+
+int HpmfwupgGetComponentProperties(void *intf, struct HpmfwupgGetComponentPropertiesCtx* pCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_GET_COMPONENT_PROPERTIES;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgGetComponentPropertiesReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, NULL);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ switch ( pCtx->req.selector )
+ {
+ case HPMFWUPG_COMP_GEN_PROPERTIES:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetGeneralPropResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"GENERAL PROPERTIES");
+ lprintf(LOG_NOTICE,"-------------------------------");
+ lprintf(LOG_NOTICE,"Payload cold reset req....[%c] ", pCtx->resp.Response.generalPropResp.
+ GeneralCompProperties.bitfield.payloadColdReset ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Def. activation supported.[%c] ", pCtx->resp.Response.generalPropResp.
+ GeneralCompProperties.bitfield.deferredActivation ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Comparison supported......[%c] ", pCtx->resp.Response.generalPropResp.
+ GeneralCompProperties.bitfield.comparisonSupport ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Preparation supported.....[%c] ", pCtx->resp.Response.generalPropResp.
+ GeneralCompProperties.bitfield.preparationSupport ? 'y' : 'n');
+ lprintf(LOG_NOTICE,"Rollback supported........[%c] \n", pCtx->resp.Response.generalPropResp.
+ GeneralCompProperties.bitfield.rollbackBackup ? 'y' : 'n');
+ }
+ break;
+ case HPMFWUPG_COMP_CURRENT_VERSION:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetCurrentVersionResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Current Version: ");
+ lprintf(LOG_NOTICE," Major: %d", pCtx->resp.Response.currentVersionResp.currentVersion[0]);
+ lprintf(LOG_NOTICE," Minor: %x", pCtx->resp.Response.currentVersionResp.currentVersion[1]);
+ lprintf(LOG_NOTICE," Aux : %03d %03d %03d %03d\n", pCtx->resp.Response.currentVersionResp.currentVersion[2],
+ pCtx->resp.Response.currentVersionResp.currentVersion[3],
+ pCtx->resp.Response.currentVersionResp.currentVersion[4],
+ pCtx->resp.Response.currentVersionResp.currentVersion[5]);
+ }
+ break;
+ case HPMFWUPG_COMP_DESCRIPTION_STRING:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetDescStringResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Description string: %s\n", pCtx->resp.Response.descStringResp.descString);
+ }
+ break;
+ case HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetRollbackFwVersionResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Rollback FW Version: ");
+ lprintf(LOG_NOTICE," Major: %d", pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[0]);
+ lprintf(LOG_NOTICE," Minor: %x", pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[1]);
+ lprintf(LOG_NOTICE," Aux : %03d %03d %03d %03d\n", pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[2],
+ pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[3],
+ pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[4],
+ pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[5]);
+ }
+ break;
+ case HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetDeferredFwVersionResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Deferred FW Version: ");
+ lprintf(LOG_NOTICE," Major: %d", pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[0]);
+ lprintf(LOG_NOTICE," Minor: %x", pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[1]);
+ lprintf(LOG_NOTICE," Aux : %03d %03d %03d %03d\n", pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[2],
+ pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[3],
+ pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[4],
+ pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[5]);
+ }
+ break;
+ // OEM Properties command
+ case HPMFWUPG_COMP_OEM_PROPERTIES:
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetOemProperties));
+ if ( verbose )
+ {
+ unsigned char i = 0;
+ lprintf(LOG_NOTICE,"OEM Properties: ");
+ for (i=0; i < HPMFWUPG_OEM_LENGTH; i++)
+ {
+ lprintf(LOG_NOTICE," 0x%x ", pCtx->resp.Response.oemProperties.oemRspData[i]);
+ }
+ }
+ break;
+ default:
+ lprintf(LOG_NOTICE,"Unsupported component selector");
+ rc = HPMFWUPG_ERROR;
+ break;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting component properties, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting component properties\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+
+ return rc;
+}
+
+int HpmfwupgAbortUpgrade(void *intf, struct HpmfwupgAbortUpgradeCtx* pCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_ABORT_UPGRADE;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgAbortUpgradeReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, NULL);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode != 0x00 )
+ {
+ lprintf(LOG_NOTICE,"Error aborting upgrade, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error aborting upgrade\n");
+ rc = HPMFWUPG_ERROR;
+ }
+ return rc;
+}
+
+int HpmfwupgInitiateUpgradeAction(void *intf, struct HpmfwupgInitiateUpgradeActionCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_INITIATE_UPGRADE_ACTION;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgInitiateUpgradeActionReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ /* Long duration command handling */
+ if ( rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS )
+ {
+ rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+ }
+ else if ( rsp->ccode != 0x00 )
+ {
+ lprintf(LOG_NOTICE,"Error initiating upgrade action, compcode = %x %s\n",
+ rsp->ccode, hpm_decode_cc(req.msg.cmd,rsp->ccode));
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error initiating upgrade action\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+int HpmfwupgUploadFirmwareBlock(void *intf, struct HpmfwupgUploadFirmwareBlockCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx, int count
+ ,unsigned int *imageOffset, unsigned int *blockLength )
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_UPLOAD_FIRMWARE_BLOCK;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ /* 2 is the size of the upload struct - data */
+ req.msg.data_len = 2 + count;
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS ||
+ rsp->ccode == 0x00 )
+ {
+ /*
+ * We need to check if the response also contains the next upload firmware offset
+ * and the firmware length in its response - These are optional but very vital
+ */
+ if ( rsp->data_len > 1 )
+ {
+ /*
+ * If the response data length is greater than 1 it should contain both the
+ * the Section offset and section length. Because we cannot just have
+ * Section offset without section length so the length should be 9
+ */
+ if ( rsp->data_len == 9 )
+ {
+ /* rsp->data[1] - LSB rsp->data[2] - rsp->data[3] = MSB */
+ *imageOffset = (rsp->data[4] << 24) + (rsp->data[3] << 16) + (rsp->data[2] << 8) + rsp->data[1];
+ *blockLength = (rsp->data[8] << 24) + (rsp->data[7] << 16) + (rsp->data[6] << 8) + rsp->data[5];
+ }
+ else
+ {
+ /*
+ * The Spec does not say much for this kind of errors where the
+ * firmware returned only offset and length so currently returning it
+ * as 0x82 - Internal CheckSum Error
+ */
+ lprintf(LOG_NOTICE,"Error wrong rsp->datalen %d for Upload Firmware block command\n",rsp->data_len);
+ rsp->ccode = HPMFWUPG_INT_CHECKSUM_ERROR;
+ }
+ }
+ }
+ /* Long duration command handling */
+ if ( rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS )
+ {
+ rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+ }
+ else if (rsp->ccode != 0x00)
+ {
+ /*
+ * PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+ * This will be fixed in the next release of open ipmi and this
+ * check will have to be removed. (Buggy version = 39)
+ */
+ if ( HPMFWUPG_IS_RETRYABLE(rsp->ccode) )
+ {
+ lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
+ rc = HPMFWUPG_UPLOAD_RETRY;
+ }
+ /*
+ * If completion code = 0xc7, we will retry with a reduced buffer length.
+ * Do not print error.
+ */
+ else if ( rsp->ccode == IPMI_CC_REQ_DATA_INV_LENGTH )
+ {
+ rc = HPMFWUPG_UPLOAD_BLOCK_LENGTH;
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error uploading firmware block, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error uploading firmware block\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+int HpmfwupgFinishFirmwareUpload(void *intf, struct HpmfwupgFinishFirmwareUploadCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_FINISH_FIRMWARE_UPLOAD;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgFinishFirmwareUploadReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ /* Long duration command handling */
+ if ( rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
+ {
+ rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+ }
+ else if ( rsp->ccode != IPMI_CC_OK )
+ {
+ lprintf(LOG_NOTICE,"Error finishing firmware upload, compcode = %x %s\n",
+ rsp->ccode, hpm_decode_cc(req.msg.cmd,rsp->ccode));
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error finishing firmware upload\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+int HpmfwupgActivateFirmware(void *intf, struct HpmfwupgActivateFirmwareCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_ACTIVATE_FIRMWARE;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgActivateFirmwareReq) -
+ (!pCtx->req.rollback_override ? 1 : 0);
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ /* Long duration command handling */
+ if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
+ {
+ printf("Waiting firmware activation...");
+ fflush(stdout);
+
+ rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ lprintf(LOG_NOTICE,"OK");
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Failed");
+ }
+ }
+ else if (rsp->ccode == HPMFWUPG_NOT_SUPPORTED_NOW) /*0xd5*/
+ {
+ printf("Activation already completed.\n");
+ rc = HPMFWUPG_SUCCESS;
+ }
+ else if ( rsp->ccode != IPMI_CC_OK )
+ {
+ lprintf(LOG_NOTICE,"Error activating firmware, compcode = %x\n",
+ rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error activating firmware\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+int HpmfwupgGetUpgradeStatus(void *intf, struct HpmfwupgGetUpgradeStatusCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_GET_UPGRADE_STATUS;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgGetUpgradeStatusReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetUpgradeStatusResp));
+ if ( verbose > 1 )
+ {
+ lprintf(LOG_NOTICE,"Upgrade status:");
+ lprintf(LOG_NOTICE," Command in progress: %x", pCtx->resp.cmdInProcess);
+ lprintf(LOG_NOTICE," Last command completion code: %x", pCtx->resp.lastCmdCompCode);
+ }
+ }
+ /*
+ * PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+ * This will be fixed in the next release of open ipmi and this
+ * check will have to be removed. (Buggy version = 39)
+ */
+ else if ( HPMFWUPG_IS_RETRYABLE(rsp->ccode) )
+ {
+ lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
+
+ pCtx->resp.lastCmdCompCode = HPMFWUPG_COMMAND_IN_PROGRESS;
+ }
+ else
+ {
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Error getting upgrade status, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ }
+ else
+ {
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Error getting upgrade status");
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+
+ return rc;
+}
+
+int HpmfwupgManualFirmwareRollback(void *intf, struct HpmfwupgManualFirmwareRollbackCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgManualFirmwareRollbackReq);
+
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+
+ if ( rsp )
+ {
+ /* Long duration command handling */
+ if ( rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS )
+ {
+ struct HpmfwupgQueryRollbackStatusCtx resCmd;
+ printf("Waiting firmware rollback...");
+ fflush(stdout);
+ rc = HpmfwupgQueryRollbackStatus(intf, &resCmd, pFwupgCtx);
+ }
+ else if ( rsp->ccode != 0x00 )
+ {
+ lprintf(LOG_NOTICE,"Error sending manual rollback, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error sending manual rollback\n");
+ rc = HPMFWUPG_ERROR;
+ }
+ return rc;
+}
+
+int HpmfwupgQueryRollbackStatus(void *intf, struct HpmfwupgQueryRollbackStatusCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ unsigned int rollbackTimeout = 0;
+ unsigned int timeoutSec1, timeoutSec2;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_QUERY_ROLLBACK_STATUS;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgQueryRollbackStatusReq);
+
+ /*
+ * If we are not in upgrade context, we use default timeout values
+ */
+ if ( pFwupgCtx != NULL )
+ {
+ rollbackTimeout = pFwupgCtx->targetCap.rollbackTimeout*5;
+ }
+ else
+ {
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+ verbose--;
+ rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+ verbose++;
+ if ( rc == HPMFWUPG_SUCCESS )
+ {
+ rollbackTimeout = targetCapCmd.resp.rollbackTimeout *5;
+ }
+ else
+ {
+ rollbackTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+ }
+ }
+
+ /* Poll rollback status until completion or timeout */
+ timeoutSec1 = (uint32_t)time(NULL);
+ timeoutSec2 = (uint32_t)time(NULL);
+ do
+ {
+ /* Must wait at least 100 ms between status requests */
+ os_usleep(0,100000);
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+ /*
+ * PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+ * This will be fixed in the next release of open ipmi and this
+ * check will have to be removed. (Buggy version = 39)
+ */
+ if ( rsp )
+ {
+ if ( HPMFWUPG_IS_RETRYABLE(rsp->ccode) )
+ {
+ lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
+ rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+ }
+ }
+ timeoutSec2 = (uint32_t)time(NULL);
+
+ }while( rsp &&
+ (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) &&
+ (timeoutSec2 - timeoutSec1 < rollbackTimeout ) );
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgQueryRollbackStatusResp));
+ if ( pCtx->resp.rollbackComp.ComponentBits.byte != 0 )
+ {
+ /* Rollback occured */
+ lprintf(LOG_NOTICE,"Rollback occured on component mask: 0x%02x",
+ pCtx->resp.rollbackComp.ComponentBits.byte);
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"No Firmware rollback occured");
+ }
+ }
+ else if ( rsp->ccode == 0x81 )
+ {
+ lprintf(LOG_NOTICE,"Rollback failed on component mask: 0x%02x",
+ pCtx->resp.rollbackComp.ComponentBits.byte);
+ rc = HPMFWUPG_ERROR;
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting rollback status, compcode = %x", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting upgrade status\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+int HpmfwupgQuerySelftestResult(void *intf, struct HpmfwupgQuerySelftestResultCtx* pCtx,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ unsigned char selfTestTimeout = 0;
+ unsigned int timeoutSec1, timeoutSec2;
+
+ pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+
+ /*
+ * If we are not in upgrade context, we use default timeout values
+ */
+ if ( pFwupgCtx != NULL )
+ {
+ /* Getting selftest timeout from new image */
+ struct HpmfwupgImageHeader* pImageHeader = (struct HpmfwupgImageHeader*)
+ pFwupgCtx->pImageData;
+ selfTestTimeout = pImageHeader->selfTestTimeout;
+ }
+ else
+ {
+ selfTestTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = HPMFWUPG_QUERY_SELFTEST_RESULT;
+ req.msg.data = (unsigned char*)&pCtx->req;
+ req.msg.data_len = sizeof(struct HpmfwupgQuerySelftestResultReq);
+
+
+ /* Poll rollback status until completion or timeout */
+ timeoutSec1 = (uint32_t)time(NULL);
+ timeoutSec2 = (uint32_t)time(NULL);
+ do
+ {
+ /* Must wait at least 100 ms between status requests */
+ os_usleep(0,100000);
+ rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+ /*
+ * PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+ * This will be fixed in the next release of open ipmi and this
+ * check will have to be removed. (Buggy version = 39)
+ */
+ if ( rsp )
+ {
+ if ( HPMFWUPG_IS_RETRYABLE(rsp->ccode) )
+ {
+ lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
+ rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+ }
+ }
+ timeoutSec2 = (uint32_t)time(NULL);
+
+ }while( rsp &&
+ (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) &&
+ (timeoutSec2 - timeoutSec1 < selfTestTimeout ) );
+
+ if ( rsp )
+ {
+ if ( rsp->ccode == 0x00 )
+ {
+ memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgQuerySelftestResultResp));
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Self test results:");
+ lprintf(LOG_NOTICE,"Result1 = %x", pCtx->resp.result1);
+ lprintf(LOG_NOTICE,"Result2 = %x", pCtx->resp.result2);
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting self test results, compcode = %x\n", rsp->ccode);
+ rc = HPMFWUPG_ERROR;
+ }
+ }
+ else
+ {
+ lprintf(LOG_NOTICE,"Error getting upgrade status\n");
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+struct ipmi_rs * HpmfwupgSendCmd(void *intf, struct ipmi_rq req,
+ struct HpmfwupgUpgradeCtx* pFwupgCtx )
+{
+ struct ipmi_rs * rsp;
+ unsigned int inaccessTimeout = 0, inaccessTimeoutCounter = 0;
+ unsigned int upgradeTimeout = 0, upgradeTimeoutCounter = 0;
+ unsigned int timeoutSec1, timeoutSec2;
+ unsigned char retry = 0;
+ static struct ipmi_rs fakeRsp;
+ int rv, rsp_len;
+
+ /*
+ * If we are not in upgrade context, we use default timeout values
+ */
+ if ( pFwupgCtx != NULL )
+ {
+ inaccessTimeout = pFwupgCtx->targetCap.inaccessTimeout*5;
+ upgradeTimeout = pFwupgCtx->targetCap.upgradeTimeout*5;
+ }
+ else
+ {
+ /* keeping the inaccessTimeout to 60 seconds results in almost 2900 retries
+ * So if the target is not available it will be retrying the command for 2900
+ * times which is not effecient -So reducing the Timout to 5 seconds which is
+ * almost 200 retries if it continuously recieves 0xC3 as completion code.
+ */
+ inaccessTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+ upgradeTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+ }
+
+ timeoutSec1 = (uint32_t)time(NULL);
+
+ do
+ {
+ static unsigned char isValidSize = FALSE;
+ rv = ipmi_sendrecv(&req, fakeRsp.data, &rsp_len);
+ if( rv < 0)
+ {
+ #define HPM_LAN_PACKET_RESIZE_LIMIT 6
+
+ if(is_remote()) /* also covers lanplus */
+ {
+ static int errorCount=0;
+
+ lprintf(LOG_DEBUG,"HPM: no response available");
+ lprintf(LOG_DEBUG,"HPM: the command may be rejected for " \
+ "security reasons");
+
+ if
+ (
+ req.msg.netfn == IPMI_NETFN_PICMG
+ &&
+ req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
+ &&
+ errorCount < HPM_LAN_PACKET_RESIZE_LIMIT
+ &&
+ (!isValidSize)
+ )
+ {
+ lprintf(LOG_DEBUG,"HPM: upload firmware block API called");
+ lprintf(LOG_DEBUG,"HPM: returning length error to force resize");
+
+ fakeRsp.ccode = IPMI_CC_REQ_DATA_INV_LENGTH;
+ rv = fakeRsp.ccode;
+ rsp = &fakeRsp;
+ errorCount++;
+ }
+ else if
+ (
+ req.msg.netfn == IPMI_NETFN_PICMG
+ &&
+ ( req.msg.cmd == HPMFWUPG_ACTIVATE_FIRMWARE ||
+ req.msg.cmd == HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK )
+ )
+ {
+ /*
+ * rsp == NULL and command activate firmware or manual firmware
+ * rollback most likely occurs when we have sent a firmware activation
+ * request. Fake a command in progress response.
+ */
+ lprintf(LOG_DEBUG,"HPM: activate/rollback firmware API called");
+ lprintf(LOG_DEBUG,"HPM: returning in progress to handle IOL session lost");
+
+ fakeRsp.ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+ rv = fakeRsp.ccode;
+ rsp = &fakeRsp;
+ }
+ else if
+ (
+ req.msg.netfn == IPMI_NETFN_PICMG
+ &&
+ ( req.msg.cmd == HPMFWUPG_QUERY_ROLLBACK_STATUS ||
+ req.msg.cmd == HPMFWUPG_GET_UPGRADE_STATUS )
+ )
+ {
+ /*
+ * rsp == NULL and command get upgrade status or query rollback
+ * status most likely occurs when we are waiting for firmware
+ * activation. Try to re-open the IOL session (re-open will work
+ * once the IPMC recovers from firmware activation.
+ */
+
+ lprintf(LOG_DEBUG,"HPM: upg/rollback status firmware API called");
+ lprintf(LOG_DEBUG,"HPM: try to re-open IOL session");
+
+ {
+ /* force session re-open */
+ ipmi_close_();
+ os_usleep(inaccessTimeout,0);
+
+ /* Fake timeout to retry command */
+ fakeRsp.ccode = 0xc3;
+ rv = fakeRsp.ccode;
+ rsp = &fakeRsp;
+ }
+ }
+ }
+ }
+
+ /* Handle inaccessibility timeout (rsp = NULL if IOL) */
+ if ( rv < 0 || rv == 0xff || rv == 0xc3 || rv == 0xd3 )
+ {
+ if ( inaccessTimeoutCounter < inaccessTimeout )
+ {
+ timeoutSec2 = (uint32_t)time(NULL);
+ if ( timeoutSec2 > timeoutSec1 )
+ {
+ inaccessTimeoutCounter += timeoutSec2 - timeoutSec1;
+ timeoutSec1 = (uint32_t)time(NULL);
+ }
+ os_usleep(0,100000);
+ retry = 1;
+ }
+ else
+ {
+ retry = 0;
+ }
+ }
+ /* Handle node busy timeout */
+ else if ( rv == 0xc0 )
+ {
+ if ( upgradeTimeoutCounter < upgradeTimeout )
+ {
+ timeoutSec2 = (uint32_t)time(NULL);
+ if ( timeoutSec2 > timeoutSec1 )
+ {
+ timeoutSec1 = (uint32_t)time(NULL);
+ // upgradeTimeoutCounter += timeoutSec2 - timeoutSec1;
+ upgradeTimeoutCounter += 1;
+ }
+ os_usleep(0,100000);
+ retry = 1;
+ }
+ else
+ {
+ retry = 0;
+ }
+ }
+ else
+ {
+ #ifdef ENABLE_OPENIPMI_V39_PATCH
+ if( rv == IPMI_CC_OK )
+ {
+ errorCount = 0 ;
+ }
+ #endif
+ retry = 0;
+
+ if
+ (
+ req.msg.netfn == IPMI_NETFN_PICMG
+ &&
+ req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
+ &&
+ (!isValidSize)
+ )
+ {
+ lprintf(LOG_INFO,"Buffer length is now considered valid" );
+
+ isValidSize = TRUE;
+ }
+ }
+ }while( retry );
+
+ if (rv < 0) rsp = NULL;
+ else {
+ rsp = &fakeRsp; /*has data already*/
+ rsp->ccode = (uchar)rv;
+ rsp->session.payloadtype = 0; /*IPMI_PAYLOAD_TYPE_IPMI*/
+ rsp->data_len = rsp_len;
+ }
+ return rsp;
+}
+
+int HpmfwupgWaitLongDurationCmd(void *intf, struct HpmfwupgUpgradeCtx* pFwupgCtx)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ unsigned int upgradeTimeout = 0;
+ unsigned int timeoutSec1, timeoutSec2;
+ struct HpmfwupgGetUpgradeStatusCtx upgStatusCmd;
+
+ /*
+ * If we are not in upgrade context, we use default timeout values
+ */
+ if ( pFwupgCtx != NULL )
+ {
+ upgradeTimeout = pFwupgCtx->targetCap.upgradeTimeout*5;
+ if ( verbose )
+ printf("Use File Upgrade Capabilities: %i seconds\n", upgradeTimeout);
+ }
+ else
+ {
+ /* Try to retreive from Caps */
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+
+ if(HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd) != HPMFWUPG_SUCCESS)
+ {
+ upgradeTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+
+ if ( verbose )
+ printf("Use default timeout: %i seconds\n", upgradeTimeout);
+ }
+ else
+ {
+ upgradeTimeout = (targetCapCmd.resp.upgradeTimeout * 5);
+ if ( verbose )
+ printf("Use Command Upgrade Capabilities Timeout: %i seconds\n", upgradeTimeout);
+ }
+ }
+
+ if(rc == HPMFWUPG_SUCCESS)
+ {
+ /* Poll upgrade status until completion or timeout*/
+ timeoutSec1 = (uint32_t)time(NULL);
+ timeoutSec2 = (uint32_t)time(NULL);
+ rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd, pFwupgCtx);
+ }
+
+ while(
+ (upgStatusCmd.resp.lastCmdCompCode == HPMFWUPG_COMMAND_IN_PROGRESS ) &&
+ (timeoutSec2 - timeoutSec1 < upgradeTimeout ) &&
+ (rc == HPMFWUPG_SUCCESS)
+ )
+ {
+ /* Must wait at least 1000 ms between status requests */
+ os_usleep(0,1000000);
+ rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd, pFwupgCtx);
+ //printf("Get Status: %x - %x = %x _ %x [%x]\n", timeoutSec2, timeoutSec1,(timeoutSec2 - timeoutSec1),upgradeTimeout, rc);
+ }
+
+ if ( upgStatusCmd.resp.lastCmdCompCode != 0x00 )
+ {
+ if ( verbose )
+ {
+ lprintf(LOG_NOTICE,"Error waiting for command %x, compcode = %x",
+ upgStatusCmd.resp.cmdInProcess,
+ upgStatusCmd.resp.lastCmdCompCode,
+ hpm_decode_cc(upgStatusCmd.resp.cmdInProcess,
+ upgStatusCmd.resp.lastCmdCompCode));
+ }
+ rc = HPMFWUPG_ERROR;
+ }
+
+ return rc;
+}
+
+unsigned char HpmfwupgCalculateChecksum(unsigned char* pData, unsigned int length)
+{
+ unsigned char checksum = 0;
+ int dataIdx = 0;
+
+ for ( dataIdx = 0; dataIdx < (int)length; dataIdx++ )
+ {
+ checksum += pData[dataIdx];
+ }
+ return checksum;
+}
+
+static void HpmfwupgPrintUsage(void)
+{
+ lprintf(LOG_NOTICE,"help - This help menu");
+ lprintf(LOG_NOTICE,"check - Check the target information");
+ lprintf(LOG_NOTICE,"check <file> - If the user is unsure of what update is going to be ");
+ lprintf(LOG_NOTICE," This will display the existing target version and image ");
+ lprintf(LOG_NOTICE," version on the screen");
+ lprintf(LOG_NOTICE,"upgrade <file> - Upgrade the firmware using a valid HPM.1 image <file>");
+ lprintf(LOG_NOTICE," This checks the version from the file and image and ");
+ lprintf(LOG_NOTICE," if it differs then only updates else skips");
+ lprintf(LOG_NOTICE,"upgrade <file> all - Updates all the components present in the file on the target board");
+ lprintf(LOG_NOTICE," without skipping (use this only after using \"check\" command");
+ lprintf(LOG_NOTICE,"upgrade <file> component x - Upgrade only component <x> from the given <file>");
+ lprintf(LOG_NOTICE," component 0 - BOOT");
+ lprintf(LOG_NOTICE," component 1 - RTK");
+ lprintf(LOG_NOTICE,"upgrade <file> activate - Upgrade the firmware using a valid HPM.1 image <file>");
+ lprintf(LOG_NOTICE," If activate is specified, activate new firmware rigth");
+ lprintf(LOG_NOTICE," away");
+ lprintf(LOG_NOTICE,"activate [norollback] - Activate the newly uploaded firmware");
+ lprintf(LOG_NOTICE,"targetcap - Get the target upgrade capabilities");
+ lprintf(LOG_NOTICE,"compprop <id> <select> - Get the specified component properties");
+ lprintf(LOG_NOTICE," Valid component <ID> 0-7 ");
+ lprintf(LOG_NOTICE," Properties <select> can be one of the following: ");
+ lprintf(LOG_NOTICE," 0- General properties");
+ lprintf(LOG_NOTICE," 1- Current firmware version");
+ lprintf(LOG_NOTICE," 2- Description string");
+ lprintf(LOG_NOTICE," 3- Rollback firmware version");
+ lprintf(LOG_NOTICE," 4- Deferred firmware version");
+ lprintf(LOG_NOTICE,"abort - Abort the on-going firmware upgrade");
+ lprintf(LOG_NOTICE,"upgstatus - Returns the status of the last long duration command");
+ lprintf(LOG_NOTICE,"rollback - Performs a manual rollback on the IPM Controller");
+ lprintf(LOG_NOTICE," firmware");
+ lprintf(LOG_NOTICE,"rollbackstatus - Query the rollback status");
+ lprintf(LOG_NOTICE,"selftestresult - Query the self test results\n");
+}
+
+int ipmi_hpmfwupg_main(void * intf, int argc, char ** argv)
+{
+ int rc = HPMFWUPG_SUCCESS;
+ int activateFlag = 0x00;
+ int componentId = DEFAULT_COMPONENT_UPLOAD;
+ int option = VERSIONCHECK_MODE;
+
+ lprintf(LOG_DEBUG,"ipmi_hpmfwupg_main()");
+
+
+ lprintf(LOG_NOTICE,"\nPICMG HPM.1 Upgrade Agent %d.%d.%d: \n",
+ HPMFWUPG_VERSION_MAJOR, HPMFWUPG_VERSION_MINOR, HPMFWUPG_VERSION_SUBMINOR);
+
+ if ( (argc == 0) || (strcmp(argv[0], "help") == 0) )
+ {
+ HpmfwupgPrintUsage();
+ return ERR_USAGE;
+ }
+ if ( (strcmp(argv[0], "check") == 0) )
+ {
+ /* hpm check */
+ if (argv[1] == NULL)
+ {
+ rc = HpmfwupgTargetCheck(intf,VIEW_MODE);
+ }
+ else
+ {
+ /* hpm check <filename> */
+ rc = HpmfwupgTargetCheck(intf,0);
+ if (rc == HPMFWUPG_SUCCESS)
+ {
+ rc = HpmfwupgUpgrade(intf, argv[1],0,DEFAULT_COMPONENT_UPLOAD,VIEW_MODE);
+ }
+ }
+ }
+
+ else if ( strcmp(argv[0], "upgrade") == 0)
+ {
+ int i =0;
+ if (fdebug) option |= DEBUG_MODE;
+ if (g_channel_buf_size > 0)
+ printf("Large buffer size %d specified\n", g_channel_buf_size );
+ for (i=1; i< argc ; i++)
+ {
+ if (strcmp(argv[i],"activate") == 0)
+ {
+ activateFlag = 1;
+ }
+ /* hpm upgrade <filename> all */
+ if (strcmp(argv[i],"all") == 0)
+ {
+ option &= ~(VERSIONCHECK_MODE);
+ option &= ~(VIEW_MODE);
+ option |= FORCE_MODE_ALL;
+ }
+ /* hpm upgrade <filename> component <comp Id> */
+ if (strcmp(argv[i],"component") == 0)
+ {
+ if (i+1 < argc)
+ {
+ componentId = atoi(argv[i+1]);
+ option &= ~(VERSIONCHECK_MODE);
+ option &= ~(VIEW_MODE);
+ option |= FORCE_MODE_COMPONENT;
+
+ if( verbose ) {
+ lprintf(LOG_NOTICE,"Component Id %d provided",componentId );
+ }
+
+ /* Error Checking */
+ if (componentId >= HPMFWUPG_COMPONENT_ID_MAX)
+ {
+ lprintf(LOG_NOTICE,"Given component ID %d exceeds Max Comp ID %d\n",
+ componentId, HPMFWUPG_COMPONENT_ID_MAX-1);
+ return HPMFWUPG_ERROR;
+ }
+ }
+ if (componentId == DEFAULT_COMPONENT_UPLOAD)
+ {
+ /* That indicates the user has given component on console but not
+ * given any ID */
+ lprintf(LOG_NOTICE,"No component Id provided\n");
+ return HPMFWUPG_ERROR;
+ }
+ }
+ if (strcmp(argv[i],"debug") == 0)
+ {
+ option |= DEBUG_MODE;
+ }
+ }
+ rc = HpmfwupgTargetCheck(intf,0);
+ if (rc == HPMFWUPG_SUCCESS)
+ {
+ /* Call the Upgrade function to start the upgrade */
+ rc = HpmfwupgUpgrade(intf, argv[1],activateFlag,componentId,option);
+ }
+ }
+
+ else if ( (argc >= 1) && (strcmp(argv[0], "activate") == 0) )
+ {
+ struct HpmfwupgActivateFirmwareCtx cmdCtx;
+ if ( (argc == 2) && (strcmp(argv[1], "norollback") == 0) )
+ cmdCtx.req.rollback_override = 1;
+ else
+ cmdCtx.req.rollback_override = 0;
+ rc = HpmfwupgActivateFirmware(intf, &cmdCtx, NULL);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "targetcap") == 0) )
+ {
+ struct HpmfwupgGetTargetUpgCapabilitiesCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgGetTargetUpgCapabilities(intf, &cmdCtx);
+ }
+ else if ( (argc == 3) && (strcmp(argv[0], "compprop") == 0) )
+ {
+ struct HpmfwupgGetComponentPropertiesCtx cmdCtx;
+ cmdCtx.req.componentId = atob(argv[1]);
+ cmdCtx.req.selector = atob(argv[2]);
+ verbose++;
+ rc = HpmfwupgGetComponentProperties(intf, &cmdCtx);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "abort") == 0) )
+ {
+ struct HpmfwupgAbortUpgradeCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgAbortUpgrade(intf, &cmdCtx);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "upgstatus") == 0) )
+ {
+ struct HpmfwupgGetUpgradeStatusCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgGetUpgradeStatus(intf, &cmdCtx, NULL);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "rollback") == 0) )
+ {
+ struct HpmfwupgManualFirmwareRollbackCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgManualFirmwareRollback(intf, &cmdCtx, NULL);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "rollbackstatus") == 0) )
+ {
+ struct HpmfwupgQueryRollbackStatusCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgQueryRollbackStatus(intf, &cmdCtx, NULL);
+ }
+ else if ( (argc == 1) && (strcmp(argv[0], "selftestresult") == 0) )
+ {
+ struct HpmfwupgQuerySelftestResultCtx cmdCtx;
+ verbose++;
+ rc = HpmfwupgQuerySelftestResult(intf, &cmdCtx, NULL);
+ }
+ else
+ {
+ HpmfwupgPrintUsage();
+ }
+
+ return rc;
+}
+
+#ifdef METACOMMAND
+int i_hpm(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+ set_loglevel(LOG_NOTICE);
+
+ while ( (c = getopt( argc, argv,"m:z:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'z':
+ g_channel_buf_size = atoi(optarg);
+ if (g_channel_buf_size < HPMFWUPG_SEND_DATA_COUNT_LAN)
+ rc = ERR_BAD_LENGTH;
+ else if (g_channel_buf_size > IPMI_REQBUF_SIZE)
+ rc = LAN_ERR_BADLENGTH;
+ if (rc != 0) {
+ printf("Invalid buffer size %d\n",g_channel_buf_size);
+ return rc;
+ }
+ break;
+ case 'x': fdebug = 1; verbose = 1;
+ set_loglevel(LOG_DEBUG);
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ HpmfwupgPrintUsage();
+ return ERR_USAGE;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rc = ipmi_hpmfwupg_main(intf, argc, argv);
+
+ ipmi_close_();
+ // show_outcome(progname,rc);
+ return rc;
+}
+/* end ihpm.c */
+
diff --git a/util/ihpm.h b/util/ihpm.h
new file mode 100644
index 0000000..00d6dc9
--- /dev/null
+++ b/util/ihpm.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_HPMFWUPG_H
+#define IPMI_HPMFWUPG_H
+
+#define IPMI_BUF_SIZE 1024
+#ifdef HAVE_LANPLUS
+#include "../lib/lanplus/lanplus_defs.h"
+#else
+#define _IPMI_RS_
+struct ipmi_rs {
+ uint8_t ccode;
+ uint8_t data[IPMI_BUF_SIZE];
+
+ /*
+ * Looks like this is the length of the entire packet, including the RMC
+P
+ * stuff, then modified to be the length of the extra IPMI message data
+ */
+ int data_len;
+
+ struct {
+ uint8_t netfn;
+ uint8_t cmd;
+ uint8_t seq;
+ uint8_t lun;
+ } msg;
+ struct {
+ uint8_t authtype;
+ uint32_t seq;
+ uint32_t id;
+ uint8_t bEncrypted; /* IPMI v2 only */
+ uint8_t bAuthenticated; /* IPMI v2 only */
+ uint8_t payloadtype; /* IPMI v2 only */
+ uint16_t msglen;
+ } session;
+};
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+#define IPMI_NETFN_APP 0x06
+#define IPMI_NETFN_PICMG 0x2C
+
+#define IPMI_BMC_SLAVE_ADDR 0x20
+
+#define BMC_GET_DEVICE_ID 0x1
+
+#define IPMI_CC_OK 0x00
+#define IPMI_CC_REQ_DATA_INV_LENGTH 0xc7
+
+#define ATTRIBUTE_PACKING /* */
+#define PRAGMA_PACK 1
+
+#pragma pack(1)
+struct ipm_devid_rsp {
+ uint8_t device_id;
+ uint8_t device_revision;
+ uint8_t fw_rev1;
+ uint8_t fw_rev2;
+ uint8_t ipmi_version;
+ uint8_t adtl_device_support;
+ uint8_t manufacturer_id[3];
+ uint8_t product_id[2];
+ uint8_t aux_fw_rev[4];
+};
+#pragma pack()
+
+typedef struct md5_state_s {
+ uint count[2]; /* message length in bits, lsw first */
+ uint abcd[4]; /* digest buffer */
+ uchar buf[64]; /* accumulate block */
+} md5_state_t;
+
+void md5_init(md5_state_t *pms); /*md5.c*/
+void md5_append(md5_state_t *pms, const uchar *data, int nbytes); /*md5.c*/
+void md5_finish(md5_state_t *pms, uchar digest[16]); /*md5.c*/
+
+void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+void set_loglevel(int level);
+char * get_mfg_str(uchar *rgmfg, int *pmfg);
+ushort buf2short(uchar * buf);
+
+int ipmi_hpmfwupg_main(void *, int, char **);
+
+#endif /* IPMI_KFWUM_H */
diff --git a/util/ilan.c b/util/ilan.c
new file mode 100644
index 0000000..a1ed76a
--- /dev/null
+++ b/util/ilan.c
@@ -0,0 +1,5149 @@
+/*---------------------------------------------------------------------------
+ * Filename: ilan.c (was pefconfig.c)
+ *
+ * Author: arcress at users.sourceforge.net
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * Abstract:
+ * This tool sets up the custom Platform Event Filter for the panicSEL
+ * record (0x20, OS Critical Stop) to send a PEF SNMP alert for Linux
+ * panics. It also configures the BMC LAN parameters, which are needed
+ * to support PEF alerts.
+ *
+ * ----------- Change History -----------------------------------------------
+ * 10/16/01 Andy Cress - created
+ * 10/24/01 Andy Cress - mods for SetPefEntry(0c)
+ * 11/02/01 Andy Cress - added option to disable a given PefEntry
+ * 11/15/01 Andy Cress - added function to GetLanEntry
+ * 11/19/01 Andy Cress - added function to SetLanEntry
+ * 01/18/02 Andy Cress - added GetCfgData function
+ * 01/31/02 Andy Cress - converted to use ipmi_cmd_ia
+ * 02/06/02 Andy Cress - removed GetCfgData
+ * 02/06/02 Andy Cress - added ipmi_cmd_va
+ * 02/08/02 Andy Cress - added GetChanAcc
+ * 02/14/02 Andy Cress - added Get_IPMac_Addr()
+ * 02/21/02 Andy Cress - added Alert IP/MAC logic to Get_IPMac_Addr()
+ * 03/21/02 Andy Cress - do SetChanAcc(0x80) with every SetChanAcc(0x40)
+ * 04/15/02 Andy Cress v1.2 - fix bug with user-specified Alert IP:
+ * (ccode=c7 on SetLanEntry(16 & 18), also
+ * added Get_Mac() for user-specified Alert IP.
+ * 04/16/02 Andy Cress v1.3 added SetUser() to set password if specified,
+ * also changed unset mac[0] to be 0xFF, not 0.
+ * 05/09/02 Andy Cress v1.4 fixed bug 504 gwymac[0]=00 (mymac overwrote it),
+ * also fixed alert scan to pick last trapsink
+ * 05/31/02 Andy Cress v1.5 for gwy mac, changed arping -c 1 to -c 2,
+ * also get com2sec community from snmpd.conf,
+ * set dest type for no ack, no retry,
+ * special handling to set preset PEF entries
+ * 07/02/02 Andy Cress v1.6 added more Usage text
+ * 07/08/02 Andy Cress v1.7 SetUserAccess length change
+ * 08/02/02 Andy Cress v1.8 moved common ipmi_cmd() code to ipmicmd.c
+ * 08/27/02 Andy Cress v1.9 fixed 0xc7 on SETUSER_ACCESS with pefconfig -P "",
+ * show message if alert dest not found
+ * 09/10/02 Andy Cress v1.10 make channel nums into defines (16)
+ * 09/17/02 Andy Cress v1.11 decode Dest Addr IP (19) in decimal,
+ * fix enable user padding in SetUser,
+ * display new community string when setting
+ * 12/09/02 Andy Cress v1.12 fix error w -C & snmpd.conf conflict
+ * 01/29/03 Andy Cress v1.13 added MV OpenIPMI support
+ * 02/05/03 Andy Cress v1.14 show pef entry descriptions,
+ * added EnablePef routine
+ * show correct Alert dest mac if -A only
+ * 04/04/03 Andy Cress v1.15 add eth interface option (-i)
+ * 05/13/03 Andy Cress v1.16 fix EnablePef if startup delay not supported
+ * 06/19/03 Andy Cress v1.17 added errno.h (email from Travers Carter)
+ * 07/25/03 Andy Cress v1.18 add SerialOverLan configuration
+ * mod to SetUser, added GetBmcEthDevice,
+ * use 'arping -I' if eth1.
+ * 08/18/03 Andy Cress v1.19 Don't abort if IPMI 1.0, just skip PEF,
+ * SetLanEntry(10 & 11) for bmc grat arp,
+ * SetLanEntry(2) to 0x17 for auth priv
+ * 09/10/03 Andy Cress v1.20 Don't enable a PEF entry if it is empty,
+ * added -L lan_ch parameter,
+ * scan for lan_ch in GetBmcEthDevice
+ * 09/22/03 Andy Cress v1.21 Add DHCP option (-D), from Jerry Yu.
+ * 12/05/03 Andy Cress v1.22 Fix auth type enables for ServerConfig
+ * 12/16/03 Andy Cress v1.23 Allow flexible auth types via authmask
+ * 03/19/04 Andy Cress v1.24 Change default pefnum for mBMC to 10
+ * 04/15/04 Andy Cress v1.25 Init each response for channel info, avoids
+ * 0xcc error with /dev/ipmi0 due to wrong lan_ch
+ * 05/05/04 Andy Cress v1.26 call ipmi_close before exit. Note that
+ * Get_IPMac_Addr and GetBmcEthDevice
+ * routines need more work for WIN32.
+ * 05/24/04 Andy Cress v1.27 added CHAN_ACC params for ia64
+ * 06/28/04 Andy Cress v1.28 added parsing to get community from trapsink
+ * 07/23/04 Andy Cress v1.29 use lan_ch variable to set Alert Policy Table
+ * 08/23/04 Andy Cress v1.30 fixed decoding of PE Table entries,
+ * added -e option (same as no params)
+ * 08/25/04 Andy Cress v1.31 added some WIN32 logic to Get_Mac, Get_IPMac_Addr
+ * 11/01/04 Andy Cress v1.32 add -N / -R for remote nodes
+ * added -U for remote username
+ * 11/18/04 Andy Cress v1.33 added -u to configure a lan username (user 2)
+ * 11/23/04 Andy Cress v1.34 added pef_defaults if first 11 empty
+ * 01/11/05 Andy Cress v1.35 allow scan for BMC LAN if fIPMI10
+ * 01/20/05 Andy Cress v1.36 fix to allow IPMI 2.0
+ * 02/16/05 Andy Cress v1.37 added IPMI 2.0 VLAN parameters,
+ * if DHCP, can set DHCP Server via -I param
+ * 03/02/05 Andy Cress v1.38 show Serial-Over-Lan params,
+ * fix -L with lan_ch_parm. mods to GetBmcEthDevice
+ * 03/18/05 Andy Cress v1.39 fix GetBmcEthDevice for invalid MAC compares
+ * 06/03/05 Andy Cress v1.40 For my MAC in BMC, check user-specified, then
+ check existing BMC MAC, then check OS MAC.
+ * 06/10/05 Andy Cress v1.41 Display multiple Alert Destinations,
+ * handle fSOL20 commands
+ * 07/07/05 Andy Cress v1.42 Fix GetBmcEthDevice for TIGI2U to skip GCM ch 3
+ * 07/08/05 Andy Cress v1.43 Mods to handle Intel NSI2U miniBMC,
+ * 08/01/05 Andy Cress v1.44 added -t option to test if BMC LAN configured
+ * 08/10/05 Andy Cress v1.45 truncate extra string chars,
+ * decode more PEF params
+ * 09/07/05 Andy Cress v1.46 enable mBMC PEF entries 26 thru 30
+ * 04/06/06 Andy Cress v1.47 show "gcm" as ifname if -L 3.
+ * 06/20/06 Andy Cress v1.48 fix strcmp(gcm), show all 4 alert policies,
+ * add PefDesc() for misc vendor pefdesc, add -a.
+ * 08/08/06 Andy Cress v1.49 add Alcolu to fsharedMAC
+ * 09/29/06 Andy Cress v1.52 use bmcmymac if valid, use bmcmyip if ok,
+ * added -q for user number,
+ * enhanced Get_IPMac_Addr for Windows
+ * 10/12/06 Andy Cress v1.53 FindEthNum updates, always use gwy iface for mac
+ * 11/02/06 Andy Cress v1.55 add user names, EnablePef mods for non-Intel.
+ * 05/02/07 Brian Johnson v1.65 add fpefenable flag to not do SetPefEntry
+ * if no Alert Destination. Previously did
+ * SetPefEntry but not EnablePef in this case.
+ * 05/04/07 Andy Cress v1.65 Use 0x02 for DHCP source instead of 0x03,
+ * fix 1714748 missing "X:" in getopt line
+ * 05/23/07 Jakub Gorgolewski
+ * v1.66 Use iphlpapi for Windows detection
+ * 10/31/07 Andy Cress v2.3 Fixed PEF entry for Power Redundancy Lost
+ * 11/15/07 Andy Cress v2.4 Move custom PEF to #14, add to usage,
+ * Allow broadcast MAC for -X
+ * 12/17/07 Andy Cress v2.5 Add fSetPEFOks & secondary Gateway
+ */
+/*M*
+ *---------------------------------------------------------------------------
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *---------------------------------------------------------------------------
+ *M*/
+#ifdef WIN32
+#include <winsock2.h>
+#include <iphlpapi.h>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+/* Linux or similar */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <errno.h>
+#endif
+#ifdef LINUX
+#include <unistd.h>
+#endif
+#ifdef SOLARIS
+#include <sys/sockio.h>
+#define SIOCGIFHWADDR SIOCGENADDR
+#define ifr_netmask ifr_ifru.ifru_addr
+// #define ifr_hwaddr.sa_data ifr_ifru.ifru_enaddr
+#elif defined(BSD)
+#include <sys/sockio.h>
+#define SIOCGIFHWADDR SIOCGIFMAC
+#define ifr_netmask ifr_ifru.ifru_addr
+// #define ifr_hwaddr.sa_data ifr_ifru.ifru_addr
+#elif defined(MACOS)
+#include <sys/sockio.h>
+#define ifr_netmask ifr_ifru.ifru_addr
+#endif
+#include "ipmicmd.h"
+#include "oem_intel.h"
+#include "oem_supermicro.h"
+
+#define SELprintf printf
+#define RTF_UP 0x0001 /* route usable */
+
+#define SOL_ENABLE_FLAG 0x01
+#define SOL_DISABLE_FLAG 0x00
+#define SOL_PRIVILEGE_LEVEL_USER 0x02
+#define SOL_PRIVILEGE_LEVEL_OPERATOR 0x03
+#define SOL_PRIVILEGE_LEVEL_ADMIN 0x04
+#define SOL_PREFERRED_BAUD_RATE 0x0a /*115.2k*/
+/* For IPMI 1.5, use Intel SOL commands & subfunctions */
+#define SOL_ENABLE_PARAM 0x01
+#define SOL_AUTHENTICATION_PARAM 0x02
+#define SOL_ACC_INTERVAL_PARAM 0x03
+#define SOL_RETRY_PARAM 0x04
+#define SOL_BAUD_RATE_PARAM 0x05 /*non-volatile*/
+#define SOL_VOL_BAUD_RATE_PARAM 0x06 /*volatile*/
+/* For IPMI 2.0, use IPMI SOL commands & subfunctions */
+#define SOL_ENABLE_PARAM2 0x08
+#define SOL_AUTHENTICATION_PARAM2 0x09
+#define SOL_BAUD_RATE_PARAM2 0x11
+
+/* IPMI 2.0 SOL PAYLOAD commands */
+#define SET_PAYLOAD_ACCESS 0x4C
+#define GET_PAYLOAD_ACCESS 0x4D
+#define GET_PAYLOAD_SUPPORT 0x4E
+
+/* Channel Access values */
+#define CHAN_ACC_DISABLE 0x20 /* PEF off, disabled*/
+#define CHAN_ACC_PEFON 0x02 /* PEF on, always avail */
+#define CHAN_ACC_PEFOFF 0x22 /* PEF off, always avail*/
+/* special channel access values for ia64 */
+#define CHAN_ACC_PEFON64 0x0A /* PEF on, always avail, UserLevelAuth=off */
+#define CHAN_ACC_PEFOFF64 0x2A /* PEF off, always avail, UserLevelAuth=off */
+#define OS_LINUX 1
+#define OS_WINDOWS 2
+#define OS_SOLARIS 3
+#define OS_BSD 4
+#define OS_HPUX 5
+
+ /* TSRLT2 Channels: 0=IPMB, 1=Serial/EMP, 6=LAN2, 7=LAN1 */
+ /* S5000 Channels: 0=IPMB, 1=LAN1, 2=LAN2, 3=RMM2, 4=Serial, 6=pci, 7=sys */
+ /* For TIGPT1U/mBMC: 1=LAN channel, no serial */
+#define LAN_CH 1
+#define SER_CH 4
+#define MAXCHAN 12 /*was 16, reduced for gnu ipmi_lan*/
+#define NUM_DEVICES_TO_CHECK 32 /*for GetBmcEthDevice()*/
+#define MAC_LEN 6 /*length of MAC Address*/
+#define PSW_LEN 16 /* see also PSW_MAX =20 in ipmicmd.h*/
+/* Note: The optional IPMI 2.0 20-byte passwords are not supported here,
+ * due to back-compatibility issues. */
+
+ /* IP address source values */
+#define SRC_STATIC 0x01
+#define SRC_DHCP 0x02 /* BMC running DHCP */
+#define SRC_BIOS 0x03 /* BIOS, sometimes DHCP */
+#define SRC_OTHER 0x04
+
+/* PEF event severities */
+#define PEF_SEV_UNSPEC 0x00
+#define PEF_SEV_MON 0x01
+#define PEF_SEV_INFO 0x02
+#define PEF_SEV_OK 0x04
+#define PEF_SEV_WARN 0x08
+#define PEF_SEV_CRIT 0x10
+#define PEF_SEV_NORECOV 0x20
+#define FLAG_INIT 99 /*initial value of char flag, beyond scope*/
+#define PARM_INIT 0xff
+
+typedef struct
+{ /* See IPMI Table 15-2 */
+ uchar rec_id;
+ uchar fconfig;
+ uchar action;
+ uchar policy;
+ uchar severity;
+ uchar genid1;
+ uchar genid2;
+ uchar sensor_type;
+ uchar sensor_no;
+ uchar event_trigger;
+ uchar data1;
+ uchar mask1;
+ uchar res[9];
+} PEF_RECORD;
+
+typedef struct
+{ /* See IPMI Table 19-3 */
+ uchar data[36];
+} LAN_RECORD; /*LanRecord*/
+
+#ifdef METACOMMAND
+extern int get_lan_stats(uchar chan); /*see bmchealth.c */
+extern char *get_sensor_type_desc(uchar stype); /*from ievents.c*/
+#endif
+
+#define MYIP 0x01
+#define GWYIP 0x02
+#define DESTIP 0x04
+#define MAXPEF 41 /* max pefnum offset = 40 (41 entries) */
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "ilan";
+static char fdebug = 0;
+static char fipmilan = 0;
+static char fIPMI10 = 0; /* =1 if IPMI v1.0 or less */
+static char fIPMI20 = 0; /* =1 if IPMI v2.0 or greater */
+static char fSOL20 = 1; /* =1 if use Serial-Over-Lan 2.0 w IPMI 2.0 */
+static char fsharedMAC = 0; /* =1 if special shared-MAC BMC LAN port */
+static char fAdjustPefNum = 0; /* =1 adjust pefnum to first empty index */
+static char fUserPefNum = 0; /* =1 if user specified a valid pefnum value*/
+static char freadonly = 1; /* =1 to only read LAN & PEF parameters */
+static char fcanonical = 0; /* =1 to show only canonical output */
+static char bdelim = BCOLON; /* delimiter ':' or '|' if canonical output*/
+static char ftestonly = 0;
+static char fprivset = 0;
+static char flanstats = 0; /* =1 to show the IPMI LAN statistics */
+static char foptmsg = 0; /* =1 to show the option warning msg */
+static char fshowchan = 0; /* =1 to show the IPMI channels */
+static char nopts = 0; /* number of pefconfig options specified*/
+static int nerrs = 0; /* number of errors during processing */
+static int ngood = 0; /* number of good results */
+static int lasterr = 0; /* value of the last error */
+static char fCustomPEF = 0; /* =1 if -j to input a custom PEF record */
+static char fSetPEFOks = 0; /* =1 if -k to set PEF OK rules */
+static char fdisable = 0;
+static char fenable = 0; /* =1 to config BMC LAN and PEF */
+static char fpefenable = 0; /* =1 enable PEF if Alert Dest is specified*/
+static char fdisableSOL = 0;
+static char fgetser = 0;
+static char fsetifn = 0; /* =1 if user specified ifname[] with -i */
+static char fethfound = 0; /* =1 if FindEthNum successful */
+static char fset_ip = 0; /* !=0 if options used to specify an IP addr*/
+static char fpassword = 0; /* =1 user-specified a password, so set it. */
+static uchar fmBMC = 0; /* =1 mini-BMC, =0 Sahalee BMC */
+static uchar fiBMC = 0; /* =1 Intel iBMC */
+static uchar fRomley = 0; /* =1 Intel Romley BMC */
+static uchar fipv6 = 0; /* =1 if BMC supports IPv6 */
+static uchar bmcpefctl = 0; /* existing BMC PEF Control, !0 = enabled */
+static char alertnum = 1; /* alert dest num (usu 1 thru 4) */
+static char alertmax = 9; /* alert dest num max (usu 4, error if >9) */
+static char pefnum = 12; /* 11 pre-defined entries, adding 12th */
+static char pefadd = 0; /* num PEF rules added (usu 2, could be 5 */
+static char pefmax = MAXPEF; /* 20 for Sahalee, 30 for miniBMC */
+static char *myuser = NULL; /* username to set, specified by -u */
+static uchar usernum = 0; /* set non-zero to specify user number */
+static uchar rgmyip[4] = {0,0,0,0};
+static uchar rggwyip[4] = {0,0,0,0};
+static uchar rggwy2ip[4] = {0,0,0,0};
+static uchar rgdestip[4] = {0,0,0,0};
+static uchar rgsubnet[4] = {0,0,0,0};
+static uchar bmcsubnet[4] = {255,255,255,0}; /* default subnet */
+static uchar ossubnet[4] = {0,0,0,0};
+static uchar osmyip[4] = {0,0,0,0};
+static uchar bmcmyip[4] = {0,0,0,0};
+static uchar bmcdestip[4] = {0,0,0,0};
+static uchar bmcdestmac[6]= {0xff,0,0,0,0,0};
+static uchar bmcmymac[6] = {0xff,0,0,0,0,0};
+static uchar rgmymac[6] = {0xff,0,0,0,0,0};
+static uchar osmymac[6] = {0xff,0,0,0,0,0};
+static uchar rggwymac[6] = {0xff,0,0,0,0,0};
+static uchar rggwy2mac[6] = {0xff,0,0,0,0,0};
+static uchar rgdestmac[6] = {0xff,0,0,0,0,0};
+static uchar rgdhcpmac[6] = {0xff,0,0,0,0,0};
+static char rghostname[32] = {'\0'};
+static uchar custPEF[20]; /* max used = 18 bytes */
+static char rgcommunity[19] = "public"; /* default community */
+static char fsetcommunity = 0; /* =1 if user-specified community */
+static char passwordData[PSW_MAX+1] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static uchar authmask = 0; /* usu 0x17, mBMC = 0x15 */
+static uchar bAuth = 0x16; /*exclude auth=None for security*/
+static uchar lan_access = 0x04; /* usu 4=Admin, 3=Operator, 2=User */
+static uchar lan_user = 0x02; /* if -u specified, use user 2 for lan */
+static uchar arp_interval = 0x04; /* in 500 ms increments, 0-based */
+static uchar arp_ctl = 0x01; /* 01=grat arp, 02=arp resp, 03=both*/
+static uchar fsetarp = 0; /* 1=user-specified arp_ctl */
+#ifdef WIN32
+static uchar ostype = OS_WINDOWS; /*windows*/
+static char ifname[64] = "Local Area Connection "; /* interface name */
+static char ifpattn[25] = "Local Area Connection ";
+#elif SOLARIS
+/* for i86pc use "e1000g0", but for sun4u(sparc) this might be "eri0" */
+static uchar ostype = OS_SOLARIS;
+#ifdef __SPARC__
+static char ifname[16] = "eri0"; /* SPARC interface name */
+static char ifname0[16] = "eri0";
+static char ifpattn[14] = "eri";
+#else
+static char ifname[16] = "e1000g0"; /* Solaris x86 interface name */
+static char ifname0[16] = "e1000g0";
+static char ifpattn[14] = "e1000g";
+#endif
+#elif defined(BSD)
+static uchar ostype = OS_BSD;
+static char ifname[16] = "em0"; /* interface name */
+static char ifname0[16] = "em0";
+static char ifpattn[14] = "em";
+#elif defined(HPUX)
+static uchar ostype = OS_HPUX;
+static char ifname[16] = "lan0"; /* interface name */
+static char ifname0[16] = "lan0";
+static char ifpattn[14] = "lan";
+#else
+static uchar ostype = OS_LINUX;
+static char ifname[16] = "eth0"; /* interface name */
+static char ifname0[16] = "eth0";
+static char ifpattn[14] = "eth";
+#endif
+static char *pspace1 = "\t"; /*used for fcanonical output*/
+static char *pspace2 = "\t\t";
+static char *pspace3 = "\t\t\t";
+static char *pspace4 = "\t\t\t\t";
+static int vend_id;
+static int prod_id;
+static int lan_dhcp = 0; /*=1 if using DHCP for bmc lan channel*/
+static uchar ser_ch = SER_CH;
+static uchar lan_ch = LAN_CH;
+static uchar lan_ch_parm = PARM_INIT;
+static uchar gcm_ch = PARM_INIT;
+static uchar vlan_enable = PARM_INIT;
+static uchar failover_enable = PARM_INIT;
+static uchar vlan_prio = 0; /*default = 0*/
+static ushort vlan_id = 0; /*max 12 bits used*/
+static uchar max_users = 5; /* set in GetUser(1); */
+static uchar enabled_users = 0; /* set in GetUser(1); */
+static uchar show_users = 5; /* default, adjusted based on DeviceID */
+static uchar fnewbaud = 0; /* =1 if user specified baud */
+static uchar sol_baud = SOL_PREFERRED_BAUD_RATE; /*115.2k default*/
+static uchar sol_accum[2] = { 0x04, 0x32 };
+static uchar sol_retry[2] = { 0x06, 0x14 };
+static uchar sol_bvalid = 0; /* =1 if SOL baud is valid */
+static uchar chan_pefon = CHAN_ACC_PEFON;
+static uchar chan_pefoff = CHAN_ACC_PEFOFF;
+static uchar SessInfo[18]; /* Session Info data */
+// static uchar bparm7[3] = {0x00, 0x00, 0x00}; /*ipv4 header before*/
+static uchar iparm7[3] = {0x1E, 0x00, 0x00}; /*intel ipv4 TTL,Flags,Service*/
+static uchar oparm7[3] = {0x40, 0x40, 0x10}; /*other ipv4 TTL,Flags,Service*/
+static uchar *parm7 = &oparm7[0];
+#define MAX_PEFPARAMS 14 /* max pef params = 14 */
+uchar peflen[MAX_PEFPARAMS] = {0,1,1,1,1,1,21,2,1,4,17,1,3,18}; /*for ShowPef*/
+uchar pef_array[MAXPEF][21]; /* array of all PEF entries read, */
+ /* sizeof(PEF_RECORD) = 21 */
+uchar pef_defaults[11][21] = { /* array of first 11 default PEF entries */
+{0x01,0x80,1,1,PEF_SEV_CRIT,0xff,0xff,0x01,0xff,0x01,0x95,0x0a,0,0,0,0,0,0,0,0,0}, /*Temp*/
+{0x02,0x80,1,1,PEF_SEV_CRIT,0xff,0xff,0x02,0xff,0x01,0x95,0x0a,0,0,0,0,0,0,0,0,0}, /*Volt*/
+{0x03,0x80,1,1,PEF_SEV_CRIT,0xff,0xff,0x04,0xff,0x01,0x95,0x0a,0,0,0,0,0,0,0,0,0}, /*Fan*/
+{0x04,0x80,1,1,PEF_SEV_WARN,0xff,0xff,0x05,0x05,0x03,0x01,0x00,0,0,0,0,0,0,0,0,0}, /*Chass*/
+{0x05,0x80,1,1,PEF_SEV_WARN,0xff,0xff,0x08,0xff,0x6f,0x06,0x00,0,0,0,0,0,0,0,0,0}, /*PS*/
+{0x06,0x80,1,1,PEF_SEV_WARN,0xff,0xff,0x0c,0x08,0x6f,0x02,0x00,0,0,0,0,0,0,0,0,0}, /*ECC*/
+{0x07,0x80,1,1,PEF_SEV_CRIT,0xff,0xff,0x0f,0x06,0x6f,0x01,0x00,0,0,0,0,0,0,0,0,0}, /*FRB*/
+{0x08,0x80,1,1,PEF_SEV_WARN,0xff,0xff,0x07,0xff,0x6f,0x1c,0x00,0,0,0,0,0,0,0,0,0}, /*POST*/
+{0x09,0x80,1,1,PEF_SEV_CRIT,0xff,0xff,0x13,0xff,0x6f,0x3e,0x03,0,0,0,0,0,0,0,0,0}, /*NMI*/
+{0x0a,0x80,1,1,PEF_SEV_INFO,0xff,0xff,0x23,0x03,0x6f,0x0e,0x00,0,0,0,0,0,0,0,0,0}, /*WDT*/
+{0x0b,0x80,1,1,PEF_SEV_MON,0xff,0xff,0x12,0xff,0x6f,0x02,0x00,0,0,0,0,0,0,0,0,0} };/*Restart*/
+
+char **pefdesc;
+char *pefdesc1[MAXPEF] = { /* for Sahalee BMC */
+/* 0 0x00 */ "",
+/* 1 0x01 */ "Temperature Sensor",
+/* 2 0x02 */ "Voltage Sensor",
+/* 3 0x04 */ "Fan Failure",
+/* 4 0x05 */ "Chassis Intrusion",
+/* 5 0x08 */ "Power Supply Fault",
+/* 6 0x0c */ "Memory ECC Error",
+/* 7 0x0f */ "BIOS POST Error",
+/* 8 0x07 */ "FRB Failure",
+/* 9 0x13 */ "Fatal NMI",
+/*10 0x23 */ "Watchdog Timer Reset",
+/*11 0x12 */ "System Restart",
+/*12 0x20 */ "OS Critical Stop",
+/*13 0x09 */ "Power Redundancy Lost",
+/*14 0x00 */ "reserved",
+/*15 0x00 */ "reserved",
+/*16 0x00 */ "reserved",
+/*17 */ "reserved",
+/*18 */ "reserved",
+/*19 */ "reserved",
+/*20 */ "reserved",
+/*21 */ "reserved",
+/*22 */ "reserved",
+/*23 */ "reserved",
+/*24 */ "reserved",
+/*25 */ "reserved",
+/*26 */ "reserved",
+/*27 */ "reserved",
+/*28 */ "reserved",
+/*29 */ "unused",
+/*30 */ "unused" };
+
+char *pefdesc2[MAXPEF] = { /* for NSC miniBMC */
+/* 0 */ "",
+/* 1 0x02*/ "Voltage Sensor Assert",
+/* 2 0x23*/ "Watchdog FRB Timeout", /* was "Proc FRB Thermal", */
+/* 3 0x02*/ "Voltage Sensor Deassert",
+/* 4 0x07*/ "Proc1 IERR",
+/* 5 0xff*/ "Digital Sensor OK",
+/* 6 0x14*/ "Chassis Identify",
+/* 7 0x13*/ "NMI Button",
+/* 8 0x14*/ "Clear CMOS via Panel",
+/* 9 0x0f*/ "OS Load POST Code",
+/*10 0x20*/ "OS Critical Stop",
+/*11 0x09 */ "Power Redundancy Lost",
+/*12 0x00*/ "reserved",
+/*13 */ "reserved",
+/*14 */ "reserved",
+/*15 */ "reserved",
+/*16 */ "reserved",
+/*17 */ "reserved",
+/*18 */ "reserved",
+/*19 */ "reserved",
+/*20 */ "reserved",
+/*21 */ "reserved",
+/*22 */ "reserved",
+/*23 */ "reserved",
+/*24 */ "reserved",
+/*25 */ "reserved",
+/*26 0x05*/ "Chassis Intrusion",
+/*27 0x0f*/ "POST Code Error",
+/*28 0x02*/ "Voltage Failure",
+/*29 0x04*/ "Fan Failure",
+/*30 0x01*/ "Temperature Failure"};
+
+#define NLAN 39
+char canon_param[NLAN] = { 0,0,0,1,1,1,1,0,0,0,0,0,1,1,0,0,1,0,0,1,
+ 0,0,0,0,0,0,1,1,1,1};
+struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} lanparams[NLAN] = { /* see IPMI Table 19-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 4, "IP address"},
+ /* 4 */ { 4, 1, "IP addr src"}, /* (DHCP/Static) */
+ /* 5 */ { 5, 6, "MAC addr"},
+ /* 6 */ { 6, 4, "Subnet mask"},
+ /* 7 */ { 7, 3, "IPv4 header"},
+ /* 8 */ { 8, 2, "Prim RMCP port"},
+ /* 9 */ { 9, 2, "Sec RMCP port"},
+ /* 10 */ {10, 1, "BMC grat ARP"},
+ /* 11 */ {11, 1, "grat ARP interval"},
+ /* 12 */ {12, 4, "Def gateway IP"},
+ /* 13 */ {13, 6, "Def gateway MAC"},
+ /* 14 */ {14, 4, "Sec gateway IP"},
+ /* 15 */ {15, 6, "Sec gateway MAC"},
+ /* 16 */ {16,18, "Community string"},
+ /* 17 */ {17, 1, "Num dest"},
+ /* 18 */ {18, 5, "Dest type"},
+ /* 19 */ {19, 13, "Dest address"},
+ /* 20 */ {20, 2, "VLAN ID"},
+ /* 21 */ {21, 1, "VLAN Priority"},
+ /* 22 */ {22, 1, "Cipher Suite Support"},
+ /* 23 */ {23,17, "Cipher Suites "},
+ /* 24 */ {24, 9, "Cipher Suite Priv"},
+ /* 25 */ {25, 4, "VLAN Dest Tag"},
+ /* 26 */ {96, 28, "OEM Alert String"},
+ /* 27 */ {97, 1, "Alert Retry Algorithm"},
+ /* 28 */ {98, 3, "UTC Offset"},
+ /* 29 */ {102, 1, "IPv6 Enable"},
+ /* 30 */ {103, 1, "IPv6 Addr Source"},
+ /* 31 */ {104,16, "IPv6 Address"},
+ /* 32 */ {105, 1, "IPv6 Prefix Len"},
+ /* 33 */ {106,16, "IPv6 Default Gateway"},
+ /* 34 */ {108,17, "IPv6 Dest address"},
+ /* 35 */ {192, 4, "DHCP Server IP"},
+ /* 36 */ {193, 6, "DHCP MAC Address"},
+ /* 37 */ {194, 1, "DHCP Enable"},
+ /* 38 */ {201, 2, "Channel Access Mode(Lan)"}
+};
+
+#define NSER 22 /* max=32 */
+struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} serparams[NSER] = { /* see IPMI Table 20-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 1, "Connection Mode"},
+ /* 4 */ { 4, 1, "Sess Inactiv Timeout"},
+ /* 5 */ { 5, 5, "Channel Callback"},
+ /* 6 */ { 6, 1, "Session Termination"},
+ /* 7 */ { 7, 2, "IPMI Msg Comm"},
+ /* 8 */ { 8, 2, "Mux Switch"},
+ /* 9 */ { 9, 2, "Modem Ring Time"},
+ /* 10 */ {10,17, "Modem Init String"},
+ /* 11 */ {11, 5, "Modem Escape Seq"},
+ /* 12 */ {12, 8, "Modem Hangup Seq"},
+ /* 13 */ {13, 8, "Modem Dial Command"},
+ /* 14 */ {14, 1, "Page Blackout Interval"},
+ /* 15 */ {15,18, "Community String"},
+ /* 16 */ {16, 1, "Num of Alert Dest"},
+ /* 17 */ {17, 5, "Destination Info"},
+ /* 18 */ {18, 1, "Call Retry Interval"},
+ /* 19 */ {19, 3, "Destination Comm Settings"},
+ /* 20 */ {29, 2, "Terminal Mode Config"},
+ /* 21 */ {201, 2,"Channel Access Mode (Ser)"}
+};
+
+static void getauthstr(uchar auth, char *s)
+{
+ if (s == NULL) return;
+ s[0] = 0;
+ if (auth & 0x01) strcat(s,"None ");
+ if (auth & 0x02) strcat(s,"MD2 ");
+ if (auth & 0x04) strcat(s,"MD5 ");
+ if (auth & 0x10) strcat(s,"Pswd ");
+ if (auth & 0x20) strcat(s,"OEM ");
+ return;
+}
+
+static int GetDeviceID(LAN_RECORD *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pLanRecord == NULL) return(-1);
+
+ status = ipmi_cmd(GET_DEVICE_ID, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetDeviceID: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ memcpy(pLanRecord,&responseData[0],responseLength);
+ set_mfgid(&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*end GetDeviceID() */
+
+static int GetChanAcc(uchar chan, uchar parm, LAN_RECORD *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pLanRecord == NULL) return(-1);
+ responseLength = 3;
+ inputData[0] = chan;
+ inputData[1] = parm; /* 0x80 = active, 0x40 = non-volatile */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_CHANNEL_ACC, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetChanAcc: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pLanRecord,&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*GetChanAcc()*/
+
+static int SetChanAcc(uchar chan, uchar parm, uchar val)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (fmBMC) return(0); /* mBMC doesn't support this */
+ /* parm: 0x80 = active, 0x40 = set non-vol*/
+ responseLength = 1;
+ inputData[0] = chan; /* channel */
+ inputData[1] = (parm & 0xc0) | (val & 0x3F);
+ inputData[2] = (parm & 0xc0) | lan_access; /* set priv level to Admin */
+
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_CHANNEL_ACC, inputData, 3, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SetChanAcc: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(status);
+} /*SetChanAcc()*/
+
+int
+SetPasswd(int unum, char *uname, char *upswd)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status, i, psw_len;
+ uchar completionCode;
+ char inputData[24];
+ int ret = 0;
+
+ inputData[0] = (uchar)unum; /*user 1 = null user */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_USER_NAME, inputData, 1, responseData,
+ &responseLength, &completionCode, fdebug);
+ SELprintf("GET_USERNAME: %x %x %x, status = %x, ccode=%x\n",
+ responseData[0],responseData[1],responseData[2],
+ status,completionCode);
+ if (fdebug) {
+ char aname[17];
+ printf("User %d: ",unum);
+ for (i = 0; i < responseLength; i++) {
+ printf("%02x ",responseData[i]);
+ if (responseData[i] < 0x20) aname[i] = '.';
+ else aname[i] = responseData[i];
+ }
+ aname[16] = 0;
+ printf(" %s\n",aname);
+ }
+
+ if (unum != 1)
+ { /* user specified a lan username */
+ if (fiBMC && (unum == 2)) {
+ /* cannot set user 2 name */
+ if (uname != NULL) {
+ if (strcmp(uname,"root") != 0)
+ printf("SETUSERNAME - user2 name %s must be root\n",uname);
+ }
+ } else if (unum == 2 && (vend_id == VENDOR_SUPERMICROX ||
+ vend_id == VENDOR_SUPERMICRO) ) {
+ /* cannot set user 2 name */
+ if (uname != NULL) {
+ if (strcmp(uname,"ADMIN") != 0)
+ printf("SETUSERNAME - user2 name %s must be ADMIN\n",uname);
+ }
+ } else {
+ inputData[0] = (uchar)unum;
+ memset(&inputData[1],0,16);
+ if (uname != NULL)
+ memcpy(&inputData[1],uname,strlen(uname));
+ status = ipmi_cmd(SET_USER_NAME, inputData, 17, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (completionCode == 0xCC)
+ status = 0; /*setting username to previous gives 0xCC, ok*/
+ else {
+ SELprintf("SETUSERNAME - %x %x %x status = %x, ccode=%x\n",
+ inputData[0],inputData[1],inputData[2],
+ status,completionCode);
+ if (status == 0) status = completionCode;
+ if (status != 0) ret = status;
+ }
+ }
+ }
+
+ if ((unum != 1) && (uname == NULL)) {
+ ; /* if no username, do not enable user */
+ } else {
+ inputData[0] = (uchar)unum; /*user 1 = null user */
+ inputData[1] = 0x01; /*enable user*/
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_USER_PASSWORD, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+ printf("SETUSERENAB - inputData %x %x %x, status = %x, ccode=%x\n",
+ inputData[0],inputData[1],inputData[2],
+ status,completionCode);
+ if (status == 0) status = completionCode;
+ if (status != 0) ret = status;
+ }
+
+ inputData[0] = (uchar)unum; /*user 1 = null user */
+ inputData[1] = 0x02; /*set password*/
+ psw_len = PSW_LEN; /*=16 change if 20-byte passwords supported */
+ memset(&inputData[2],0,psw_len);
+ if (upswd != NULL)
+ strcpy(&inputData[2],upswd);
+ if (fdebug) {
+ char apsw[PSW_MAX+1];
+ char c;
+ printf("Pswd %d: ",unum);
+ for (i = 0; i < psw_len; i++) {
+ c = inputData[i+2];
+ printf("%02x ",(unsigned char)c);
+ if (c < 0x20) apsw[i] = '.';
+ else apsw[i] = c;
+ }
+ apsw[psw_len] = 0;
+ printf(" %s\n",apsw);
+ }
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_USER_PASSWORD, inputData, 2+psw_len,
+ responseData,&responseLength, &completionCode,fdebug);
+ SELprintf("SETUSERPSW - inputData %x %x %x, status = %x, ccode=%x\n",
+ inputData[0],inputData[1],inputData[2],
+ status,completionCode);
+ if (status == 0) status = completionCode;
+ if (status != 0) ret = status;
+
+ inputData[0] = (uchar)unum; /*user 1 = null user */
+ inputData[1] = 0x03; /*test password*/
+ memset(&inputData[2],0,psw_len);
+ if (upswd != NULL)
+ strcpy(&inputData[2],upswd);
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_USER_PASSWORD, inputData, 2+psw_len,
+ responseData,&responseLength, &completionCode,fdebug);
+ SELprintf("TESTUSERPSW - inputData %x %x %x, status = %x, ccode=%x\n",
+ inputData[0],inputData[1],inputData[2],
+ status,completionCode);
+
+ if (fiBMC && (unum == 2)) { /*iBMC doesn't support this on user 2*/
+ if (fdebug)
+ printf("skipping SETUSER_ACCESS on iBMC for user %d\n",unum);
+ } else {
+ inputData[0] = 0x90 | lan_ch; /* = 0x97 */
+ inputData[1] = (uchar)unum; /* user num */
+ inputData[2] = lan_access; /* usu admin */
+ inputData[3] = 0x00; /* User Session Limit, 0=not limited*/
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_USER_ACCESS, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+ printf("SETUSER_ACCESS - inputData %x %x %x, status = %x ccode=%x\n",
+ (uchar)inputData[0],inputData[1],inputData[2],
+ status,completionCode);
+ if (status == 0) status = completionCode;
+ if (status != 0) ret = status;
+ }
+
+ return(ret);
+} /*end SetPswd()*/
+
+int SetUser(int unum, char *uname, char *passwd)
+{
+ int ret = 0;
+ /* if the user specified a username or password, set it. */
+ if ((fpassword) || (uname != NULL)) {
+ ret = SetPasswd(unum, uname,passwd); /*set username and password*/
+ }
+ return(ret);
+} /*end SetUser()*/
+
+int
+DisableUser(int unum)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar completionCode;
+ char inputData[24];
+
+ inputData[0] = 0x80 | lan_ch; /* = 0x87, no IPMI */
+ inputData[1] = (uchar)unum; /* user 1 */
+ inputData[2] = 0x0F; /* No access */
+ inputData[3] = 0x00; /* User Session Limit, 0=not limited*/
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(SET_USER_ACCESS, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == 0) status = completionCode;
+ return(status);
+}
+
+static char *parse_priv(uchar c)
+{
+ char *p;
+ c = (c & 0x0f);
+ switch(c) {
+ case 1: p = "Callback"; break;
+ case 2: p = "User "; break;
+ case 3: p = "Operator"; break;
+ case 4: p = "Admin "; break;
+ case 5: p = "OEM "; break;
+ case 0x0f: p = "No access"; break;
+ default: p = "Reserved";
+ }
+ return(p);
+}
+
+static void show_priv(uchar c)
+{
+ char *privstr;
+ privstr = parse_priv(c);
+ printf("%s",privstr);
+}
+
+static int valid_priv(int c)
+{
+ int rv;
+ switch(c) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 0x0f:
+ rv = 1;
+ break;
+ default:
+ rv = 0;
+ break;
+ }
+ return rv;
+}
+
+int GetUser(uchar user_num)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar completionCode;
+ char inputData[24];
+
+ inputData[0] = lan_ch;
+ inputData[1] = user_num; /* usually = 1 for BMC LAN */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_USER_ACCESS, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == 0 && completionCode == 0) {
+ uchar c;
+ if (user_num == 1) { /*get max_users and enabled_users*/
+ max_users = responseData[0] & 0x3f;
+ enabled_users = responseData[1] & 0x3f;
+ if (enabled_users > show_users) show_users = enabled_users;
+ if (show_users > max_users) show_users = max_users;
+ if (!fcanonical)
+ SELprintf("Users: showing %d of max %d users (%d enabled)\n",
+ show_users,max_users,enabled_users);
+ }
+ if (fcanonical)
+ SELprintf("Channel %d User %d Access %s%c ", lan_ch, user_num,
+ pspace2,bdelim);
+ else
+ SELprintf("User Access(chan%d,user%d): %02x %02x %02x %02x : ",
+ lan_ch, user_num, (uchar)responseData[0],
+ responseData[1],responseData[2], responseData[3]);
+ c = responseData[3];
+ inputData[0] = user_num; /* usually = 1 for BMC LAN */
+ responseLength = sizeof(responseData);
+ status = ipmi_cmd(GET_USER_NAME, inputData, 1, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != 0 || completionCode != 0)
+ responseData[0] = 0;
+ if (c & 0x10) printf("IPMI, ");
+ show_priv(c);
+ printf(" (%s)\n",responseData); /*show user name */
+ } else
+ SELprintf("Get User Access(%d,%d), status=%x, ccode=%x\n",
+ lan_ch, user_num, status, completionCode);
+ return(status);
+} /*end GetUser()*/
+
+static int GetSerEntry(uchar subfunc, LAN_RECORD *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+ uchar chan; uchar bset;
+
+ if (pLanRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetSerEntry(%d): error, output buffer is NULL\n",subfunc);
+ return (-1);
+ }
+
+ chan = ser_ch; /* 1=EMP, 0=IPMB, 6=LAN2, 7=LAN1 */
+ bset = 0;
+
+ inputData[0] = chan; // flags, channel 3:0 (1=EMP)
+ inputData[1] = subfunc; // Param selector
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+ if (subfunc == 10) {
+ inputData[2] = 0;
+ inputData[3] = 1;
+ }
+
+ status = ipmi_cmd(GET_SER_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetSerEntry(%d,%d): completion code=%x\n",
+ chan,subfunc,completionCode);
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pLanRecord,&responseData[1],responseLength-1);
+ pLanRecord->data[responseLength-1] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetSerEntry(%d,%d): ipmi_cmd status=%x ccode=%x\n",
+ chan,subfunc,status,completionCode);
+ return -1;
+}
+
+static int GetLanEntry(uchar subfunc, uchar bset, LAN_RECORD *pLanRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status, n;
+ uchar completionCode;
+ uchar chan;
+
+ if (pLanRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetLanEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ chan = lan_ch; /* LAN 1 = 7 */
+
+ inputData[0] = chan; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+
+ status = ipmi_cmd(GET_LAN_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetLanEntry: completion code=%x\n",
+ completionCode);
+ status = completionCode;
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ if (responseLength > 0) {
+ n = responseLength-1;
+ memcpy(pLanRecord,&responseData[1],n);
+ } else n = 0;
+ pLanRecord->data[n] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetLanEntry: ipmi_cmd status=%d completionCode=%x\n",
+ status,completionCode);
+ return status;
+} /* end GetLanEntry() */
+
+static int SetLanEntry(uchar subfunc, LAN_RECORD *pLanRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pLanRecord == NULL)
+ {
+ if (fdebug)
+ printf("SetLanEntry(%d): error, input buffer is NULL\n",subfunc);
+ return (-1);
+ }
+ if (vend_id == VENDOR_SUPERMICROX || vend_id == VENDOR_SUPERMICRO) {
+ /* SUPERMICRO cannot set grat arp or grat arp interval */
+ if (subfunc == 10 || subfunc == 11) return(0);
+ }
+
+ inputData[0] = lan_ch; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ memcpy(&inputData[2],pLanRecord,reqlen);
+
+ status = ipmi_cmd(SET_LAN_CONFIG, inputData, (uchar)(reqlen+2),
+ responseData, &responseLength,&completionCode,fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("SetLanEntry(%d): completion code=%x\n",
+ subfunc,completionCode); // responseData[0]);
+ return(completionCode);
+ } else {
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("SetLanEntry(%d): ipmi_cmd status=%d ccode=%x\n",
+ subfunc,status,completionCode);
+ return status;
+} /* end SetLanEntry() */
+
+int GetPefEntry(uchar subfunc, ushort rec_id, PEF_RECORD *pPefRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24]; /* only use 3 bytes for input */
+ int status, n;
+ uchar completionCode;
+
+ if (pPefRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetPefEntry(%d): error, output buffer is NULL\n",subfunc);
+ return (-1);
+ }
+
+ inputData[0] = subfunc; // Parameter = Evt Filter Table
+ inputData[1] = (uchar)rec_id;
+ inputData[2] = 0;
+
+ status = ipmi_cmd(GET_PEF_CONFIG, inputData, 3, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("GetPefEntry(%d/%d): completion code=%x\n",
+ subfunc,rec_id,completionCode);
+ status = completionCode;
+ } else {
+ /* expect PEF record to be >=21 bytes */
+ if (responseLength > 1) n = responseLength-1;
+ else n = 0;
+ if (n > 21) n = 21; /*only use 21 bytes*/
+ if ((subfunc == 6) && (n < 21)) {
+ if (fdebug)
+ printf("GetPefEntry(%d/%d): length %d too short\n",
+ subfunc,rec_id,responseLength);
+ }
+ // dont copy first byte (Parameter revision, usu 0x11)
+ if (n == 0) memset(pPefRecord,0,21);
+ else memcpy(pPefRecord,&responseData[1],n);
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("GetPefEntry: ipmi_cmd status=%x completionCode=%x\n",
+ status, completionCode);
+ return status;
+} /* end GetPefEntry() */
+
+int SetPefEntry(PEF_RECORD *pPefRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[32]; /* sizeof(PEF_RECORD) = 21 +1=22 */
+ int status;
+ uchar completionCode;
+ uchar subfunc;
+
+ subfunc = 0x06; // Parameter = Evt Filter Table
+
+ if (pPefRecord == NULL) {
+ if (fdebug)
+ printf("SetPefEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
+ // 06 0c 80 01 01 00 ff ff 20 ff 6f ff 00 00 00 00 00 00 00 00 00 00
+ // memset(&inputData[0],0,requestData.dataLength);
+ inputData[0] = subfunc;
+ memcpy(&inputData[1],pPefRecord,sizeof(PEF_RECORD));
+
+ status = ipmi_cmd(SET_PEF_CONFIG, inputData, sizeof(PEF_RECORD)+1,
+ responseData, &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (fdebug)
+ SELprintf("SetPefEntry: completion code=%x\n",
+ completionCode); // responseData[0]);
+ status = completionCode;
+ } else {
+ //successful, done
+ return(0);
+ }
+
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ SELprintf("SetPefEntry: ipmi_cmd status=%d completion code=%x\n",
+ status,completionCode);
+ return(status);
+
+} /* end SetPefEntry() */
+
+int DisablePef(int anum)
+{
+ uchar iData[24]; /* sizeof(PEF_RECORD) = 21 +1=22 */
+ uchar rData[MAX_BUFFER_SIZE];
+ int rLength = MAX_BUFFER_SIZE;
+ uchar cc;
+ int status;
+
+ if (fmBMC) {
+ SELprintf("mini-BMC does not support disabling BMC LAN\n");
+ return(-1);
+ } else {
+ status = SetChanAcc(lan_ch, 0x80, CHAN_ACC_DISABLE);
+ if (fdebug) SELprintf("SetChanAcc(lan/active), ret = %d\n",status);
+ status = SetChanAcc(lan_ch, 0x40, CHAN_ACC_DISABLE);
+ SELprintf("SetChanAcc(lan), ret = %d\n",status);
+ if (status != 0) return(status);
+ }
+
+ iData[0] = 0x01; /* PEF Control Param */
+ iData[1] = 0x00; /* PEF disable */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 2, rData, &rLength,
+ &cc, fdebug);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("DisablePef[%d]: completion code=%x\n",iData[0],cc);
+ return(-1);
+ }
+
+ if (anum != 0) {
+ iData[0] = 0x09; /* PEF Alert Policy Table */
+ iData[1] = (uchar)anum; /* Policy number (default 0x01) */
+ iData[2] = 0x10; /* PEF LAN, policy disable */
+ iData[3] = 0x00; /* LAN_CH=00, default dest=00 */
+ iData[4] = 0x00; /* No alert string */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 5, rData, &rLength,
+ &cc, fdebug);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("DisablePef[%d]: completion code=%x\n",iData[0],cc);
+ return(-1);
+ }
+ }
+ return(status);
+}
+
+int ShowPef(void)
+{
+ uchar iData[24]; /* sizeof(PEF_RECORD) = 21 +1=22 */
+ uchar rData[MAX_BUFFER_SIZE];
+ int rLength = MAX_BUFFER_SIZE;
+ uchar cc;
+ int status, i,j;
+
+ for (j = 1; j < MAX_PEFPARAMS; j++) {
+ if (j == 4 && fmBMC) {
+ /* fmBMC gets cc=0x80 for param 4, so skip it. */
+ continue;
+ }
+ iData[0] = (uchar)j; /* PEF Control Param */
+ if (j == 6 || j == 7 || j == 9) iData[1] = 1;
+ else iData[1] = 0x00; /* PEF Set Selector */
+ if (j == 13) iData[2] = 1;
+ else iData[2] = 0x00; /* PEF Block Selector */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(GET_PEF_CONFIG, iData, 3, rData, &rLength,
+ &cc, fdebug);
+ if (status == 0 && cc == 0) {
+ SELprintf("PefParam[%d]: ",iData[0]);
+ if (rLength > 0)
+ for (i=0;i<peflen[j];i++) SELprintf("%02x ", rData[1+i]);
+ SELprintf("\n");
+ } else
+ SELprintf("PefParam[%d]: GET_PEF status=%d cc=%x\n",
+ iData[0],status,cc);
+ }
+ return(status);
+}
+
+int EnablePef(int anum)
+{
+ uchar iData[24]; /* sizeof(PEF_RECORD) = 21 +1=22 */
+ uchar rData[MAX_BUFFER_SIZE];
+ int rLength = MAX_BUFFER_SIZE;
+ uchar cc;
+ int status;
+ uchar sdelay;
+
+ status = SetChanAcc(lan_ch, 0x80, chan_pefon);
+ if (fdebug) SELprintf("SetChanAcc(lan/active), ret = %d\n",status);
+ status = SetChanAcc(lan_ch, 0x40, chan_pefon);
+ SELprintf("SetChanAcc(lan), ret = %d\n",status);
+ if (status != 0) return(status);
+
+ {
+ iData[0] = 0x01; /* PEF Control Param */
+ iData[1] = 0x00; /* PEF Set Selector */
+ iData[2] = 0x00; /* PEF Block Selector */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(GET_PEF_CONFIG, iData, 3, rData, &rLength,
+ &cc, fdebug);
+ if (status != 0 || cc != 0) sdelay = 0;
+ else sdelay = rData[1];
+ if (fdebug) SELprintf("EnablePef[%d]: get cc=%x, control=%02x\n",
+ iData[0],cc,sdelay);
+ iData[0] = 0x01; /* PEF Control Param (0x01 or 0x05) */
+ iData[1] = 0x01; /* PEF enable, & no startup delay */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 2, rData, &rLength,
+ &cc, fdebug);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("EnablePef[%d]: completion code=%x\n",iData[0],cc);
+ return(-1);
+ }
+
+#ifdef TEST
+ iData[0] = 0x01; /* Serial Channel */
+ iData[1] = 0x13; /* Dest Com settings = 19. */
+ iData[2] = 0x01; /* POL Default Dest */
+ iData[3] = 0x60;
+ iData[4] = 0x07;
+ status = ipmi_cmd(SET_SER_CONFIG, iData, 5, rData, &rLength,
+ &cc, fdebug);
+#endif
+
+ iData[0] = 0x02; /* PEF Action Param */
+ iData[1] = 0x00; /* PEF Set Selector */
+ iData[2] = 0x00; /* PEF Block Selector */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(GET_PEF_CONFIG, iData, 3, rData, &rLength,
+ &cc, fdebug);
+ if (fdebug) SELprintf("EnablePef[%d]: get cc=%x, val=%02x\n",
+ iData[0],cc,rData[1]);
+ iData[0] = 0x02; /* PEF Action Param */
+ if (vend_id == VENDOR_INTEL)
+ iData[1] = 0x2f; /* enable alerts, reset, power cycle/down, diag*/
+ else
+ iData[1] = 0x0f; /* enable alerts, reset, power cycle/down */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 2, rData, &rLength,
+ &cc, fdebug);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("EnablePef[%d]: completion code=%x\n",iData[0],cc);
+ return(-1);
+ }
+
+ if ((sdelay & 0x04) != 0) { /* startup delay is supported */
+ iData[0] = 0x03; /* PEF Startup Delay Param */
+ iData[1] = 0x00; /* 0 seconds, default is 0x3c (60 sec) */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 2, rData, &rLength,
+ &cc, fdebug);
+ if (fdebug) SELprintf("EnablePef[%d]: set val=%02x cc=%x\n",
+ iData[0],iData[1],cc);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("EnablePef[%d]: completion code=%x\n",iData[0],cc);
+ // return(-1);
+ }
+ iData[0] = 0x04; /* PEF Alert Startup Delay Param */
+ iData[1] = 0x00; /* 0 seconds, default is 0x3c (60 sec) */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 2, rData, &rLength,
+ &cc, fdebug);
+ if (fdebug) SELprintf("EnablePef[%d]: set val=%02x cc=%x\n",
+ iData[0],iData[1],cc);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("EnablePef[%d]: completion code=%x\n",iData[0],cc);
+ // return(-1);
+ }
+ } /*endif sdelay*/
+
+ iData[0] = 0x09; /* PEF Alert Policy Table */
+ iData[1] = (uchar)anum; /* Policy number (default 0x01) */
+ iData[2] = 0x18; /* PEF LAN, always alert, policy enable */
+ iData[3] = (lan_ch << 4) + anum; /* LAN_CH=70, default dest=01 */
+ iData[4] = 0x00; /* No alert string */
+ rLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(SET_PEF_CONFIG, iData, 5, rData, &rLength,
+ &cc, fdebug);
+ if (fdebug) SELprintf("EnablePef[%d]: set val=%02x cc=%x\n",
+ iData[0],iData[1],cc);
+ if (status != 0) return(status);
+ if( cc ) {
+ SELprintf("EnablePef[%d]: completion code=%x\n",iData[0],cc);
+ return(-1);
+ }
+ } /*endif IPMI 1.5 */
+
+ return(status);
+} /* end EnablePef */
+
+#define NBAUDS 10
+static struct {
+ unsigned char val;
+ char str[8];
+ } mapbaud[NBAUDS] = {
+ { 6, "9600" },
+ { 6, "9.6K" },
+ { 7, "19.2K" },
+ { 7, "19200" },
+ { 8, "38.4K" },
+ { 8, "38400" },
+ { 9, "57.6K" },
+ { 9, "57600" },
+ { 10, "115.2K" },
+ { 10, "115200" }
+ };
+
+static unsigned char Str2Baud(char * str)
+{
+ unsigned char baud = 0;
+ int i, n, len;
+ len = strlen_(str);
+ for (i = 0; i < len; i++) /*toupper*/
+ if (str[i] >= 'a' && str[i] <= 'z') str[i] &= 0x5F;
+ for (i = 0; i < NBAUDS; i++) {
+ n = strlen_(mapbaud[i].str);
+ if (strncmp(str,mapbaud[i].str,n) == 0) {
+ baud = mapbaud[i].val;
+ break;
+ }
+ }
+ if (i == NBAUDS || baud == 0) {
+ printf("Invalid -B parameter value (%s), using 19.2K.\n",str);
+ i = 1; /* default is 19.2K */
+ baud = mapbaud[i].val; /* =7 */
+ }
+ if (fdebug) printf("new baud = %02x (%s)\n",baud,mapbaud[i].str);
+ return(baud);
+}
+
+static char *Baud2Str(unsigned char bin)
+{
+ char *baudstr;
+ unsigned char b;
+ b = bin & 0x0f;
+ switch(b) {
+ case 6: baudstr = "9600 "; break;
+ case 7: baudstr = "19.2k"; break;
+ case 8: baudstr = "38.4k"; break;
+ case 9: baudstr = "57.6k"; break;
+ case 10: baudstr = "115.2k"; break;
+ default: baudstr = "nobaud";
+ }
+ return(baudstr);
+}
+
+static int BaudValid(unsigned char b)
+{
+ int val = 0;
+ switch(b) {
+ case 6: val = 1; break;
+ case 7: val = 1; break;
+ case 8: val = 1; break;
+ case 9: val = 1; break;
+ case 10: val = 1; break;
+ default: val = 0; break;
+ }
+ return(val);
+}
+
+/*
+ * atomac - converts ASCII string to binary MAC address (array).
+ * Accepts input formatted as 11:22:33:44:55:66 or 11-22-33-44-55-66.
+ */
+void atomac(uchar *array, char *instr)
+{
+ int i,j,n;
+ char *pi;
+ j = 0;
+ pi = instr;
+ n = strlen_(instr);
+ for (i = 0; i <= n; i++) {
+ if (instr[i] == ':') {
+ array[j++] = htoi(pi);
+ pi = &instr[i+1];
+ } else if (instr[i] == '-') {
+ array[j++] = htoi(pi);
+ pi = &instr[i+1];
+ } else if (instr[i] == 0) {
+ array[j++] = htoi(pi);
+ }
+ if (j >= MAC_LEN) break; /*safety valve*/
+ }
+ if (fdebug)
+ printf("atomac: %02x %02x %02x %02x %02x %02x\n",
+ array[0],array[1],array[2],array[3], array[4],array[5]);
+} /*end atomac()*/
+
+/* extern void atoip(uchar *array,char *instr); *from subs.c*/
+void MacSetInvalid(uchar *mac)
+{
+ int i;
+ if (mac == NULL) return;
+ for (i = 0; i < MAC_LEN; i++) {
+ if (i == 0) mac[i] = 0xFF;
+ else mac[i] = 0x00;
+ }
+}
+
+int MacIsValid(uchar *mac)
+{
+ int fvalid = 0;
+ int i;
+ /* check for initial invalid value of FF:00:... */
+ if (mac[0] == 0xff && mac[1] == 0x00) /* marked as invalid */
+ return(fvalid);
+ /* check for all zeros */
+ for (i = 0; i < MAC_LEN; i++)
+ if (mac[i] != 0) { /* not all zeros */
+ fvalid = 1;
+ break;
+ }
+ return(fvalid);
+}
+
+int IpIsValid(uchar *ipadr)
+{
+ int fvalid = 1;
+ if (ipadr[0] == 0) fvalid = 0;
+ return(fvalid);
+}
+
+int SubnetIsValid(uchar *subnet)
+{
+ int fvalid = 0;
+ /* if masking off at least one bit, say valid */
+ if (subnet[0] != 0) fvalid = 1;
+ return(fvalid);
+}
+
+int SubnetIsSame(uchar *ip1, uchar *ip2, uchar *subnet)
+{
+ int i;
+ uchar c1, c2;
+ for (i = 0; i < 4; i ++) {
+ c1 = ip1[i] & subnet[i];
+ c2 = ip2[i] & subnet[i];
+ if (c1 != c2) return 0;
+ }
+ return 1; /*same, return true*/
+}
+
+#ifdef WIN32
+/*
+ * Obtain network adapter information (Windows).
+ */
+PIP_ADAPTER_ADDRESSES GetAdapters() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ ULONG OutBufferLength = 0;
+ ULONG RetVal = 0, i;
+
+ // The size of the buffer can be different
+ // between consecutive API calls.
+ // In most cases, i < 2 is sufficient;
+ // One call to get the size and one call to get the actual parameters.
+ // But if one more interface is added or addresses are added,
+ // the call again fails with BUFFER_OVERFLOW.
+ // So the number is picked slightly greater than 2.
+ // We use i <5 in the example
+ for (i = 0; i < 5; i++) {
+ RetVal = GetAdaptersAddresses(
+ AF_INET, 0, NULL,
+ AdapterAddresses,
+ &OutBufferLength);
+
+ if (RetVal != ERROR_BUFFER_OVERFLOW) {
+ break;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+
+ AdapterAddresses = (PIP_ADAPTER_ADDRESSES) malloc(OutBufferLength);
+ if (AdapterAddresses == NULL) {
+ RetVal = GetLastError();
+ break;
+ }
+ }
+ if (RetVal == NO_ERROR) {
+ // If successful, return pointer to structure
+ return AdapterAddresses;
+ }
+ else {
+ LPVOID MsgBuf;
+
+ printf("Call to GetAdaptersAddresses failed.\n");
+ if (FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ RetVal,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPTSTR) &MsgBuf,
+ 0,
+ NULL )) {
+ printf("\tError: %s", MsgBuf);
+ }
+ LocalFree(MsgBuf);
+ }
+ return NULL;
+}
+
+/*
+ * Set BMC MAC corresponding to current BMC IP address (Windows).
+ */
+int GetLocalMACByIP() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ addr = AdapterList->FirstUnicastAddress;
+ if (addr == NULL) si = NULL;
+ else si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ if (si != NULL) {
+ if(memcmp(&si->sin_addr.s_addr, rgmyip, 4) == 0) {
+ if (!MacIsValid(rgmymac))
+ memcpy(rgmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ memcpy(osmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ wcstombs(ifname,AdapterList->FriendlyName, sizeof(ifname));
+ result = 1;
+ break;
+ }
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+/*
+ * Get First IP Address in Windows OS
+ * ipaddr is 4 bytes, macaddr is 6 bytes, ipname can be 64 bytes.
+ * (called by idiscover.c)
+ */
+int GetFirstIP(uchar *ipaddr, uchar *macadr, char *ipname, char fdbg)
+{
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ struct sockaddr_in *si;
+ uchar *psaddr;
+ int result = -1;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+
+ addr = AdapterList->FirstUnicastAddress;
+ si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ psaddr = (uchar *)&si->sin_addr.s_addr;
+ if ((psaddr[0] != 0) && (psaddr[0] != 169)) {
+ if (fdbg) printf("found IP: s_addr=%d.%d.%d.%d\n",
+ psaddr[0], psaddr[1], psaddr[2], psaddr[3]);
+ if (ipaddr != NULL)
+ memcpy(ipaddr, &si->sin_addr.s_addr, 4);
+ if (macadr != NULL) {
+ memcpy(macadr, AdapterList->PhysicalAddress, MAC_LEN);
+ if (fdbg) printf("found MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
+ macadr[0], macadr[1], macadr[2], macadr[3],
+ macadr[4], macadr[5]);
+ }
+ if (ipname != NULL) {
+ wcstombs(ipname,AdapterList->FriendlyName, sizeof(ifname));
+ if (fdbg) printf("found Adapter: %d\n",ipname);
+ }
+ result = 0;
+ break;
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+/*
+ * Set BMC MAC corresponding to current BMC IP address (Windows).
+ */
+int GetLocalIPByMAC(uchar *macadr) {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ if(memcmp(AdapterList->PhysicalAddress, macadr, MAC_LEN) == 0) {
+ addr = AdapterList->FirstUnicastAddress;
+
+ si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ if (fdebug) {
+ uchar *psaddr;
+ psaddr = (uchar *)&si->sin_addr.s_addr;
+ printf("mac match: rgmyip=%d.%d.%d.%d s_addr=%d.%d.%d.%d\n",
+ rgmyip[0], rgmyip[1], rgmyip[2], rgmyip[3],
+ psaddr[0], psaddr[1], psaddr[2], psaddr[3]);
+ }
+ if (!IpIsValid(rgmyip) && (fsharedMAC==1)) /*not specified, shared*/
+ memcpy(rgmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ wcstombs(ifname,AdapterList->FriendlyName, sizeof(ifname));
+ result = 1;
+ break;
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+/*
+ * Set MAC and IP address from given interface name (Windows).
+ */
+int GetLocalDataByIface() {
+ PIP_ADAPTER_ADDRESSES AdapterAddresses = NULL;
+ PIP_ADAPTER_ADDRESSES AdapterList;
+ int result = 0;
+
+ size_t origsize, newsize, convertedChars;
+ wchar_t* wcstring;
+ struct sockaddr_in *si;
+
+ AdapterAddresses = GetAdapters();
+ AdapterList = AdapterAddresses;
+
+ origsize = strlen(ifname) + 1;
+ newsize = origsize;
+ convertedChars = 0;
+ wcstring = (wchar_t*) malloc(sizeof(wchar_t) * newsize) ;
+ if (wcstring == NULL) AdapterList = NULL; /*skip loop, do free*/
+ else mbstowcs(wcstring, ifname, origsize );
+
+ while (AdapterList) {
+ PIP_ADAPTER_UNICAST_ADDRESS addr;
+ if(wcsstr(AdapterList->FriendlyName, wcstring)) {
+ printf("Using interface: %S\n", AdapterList->FriendlyName);
+ printf("\t%S\n", AdapterList->Description);
+ addr = AdapterList->FirstUnicastAddress;
+
+ si = (struct sockaddr_in*)addr->Address.lpSockaddr;
+ if (fdebug) {
+ uchar *psaddr;
+ psaddr = (uchar *)&si->sin_addr.s_addr;
+ printf("mac match: rgmyip=%d.%d.%d.%d s_addr=%d.%d.%d.%d "
+ "fsharedMAC=%d\n",
+ rgmyip[0], rgmyip[1], rgmyip[2], rgmyip[3],
+ psaddr[0], psaddr[1], psaddr[2], psaddr[3],
+ fsharedMAC);
+ }
+ if (!IpIsValid(rgmyip)) { /*IP not specified*/
+ memcpy(rgmyip, &si->sin_addr.s_addr, 4);
+ memcpy(rgmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ }
+ memcpy(osmyip, &si->sin_addr.s_addr, 4);
+ memcpy(osmymac, AdapterList->PhysicalAddress, MAC_LEN);
+ /* FriendlyName == ifname already */
+ result = 1;
+ break;
+ }
+ AdapterList = AdapterList->Next;
+ }
+
+ if (AdapterAddresses != NULL) {
+ free(AdapterAddresses);
+ }
+ return result;
+}
+
+int FindEthNum(uchar *macadrin)
+{
+ int i;
+ uchar macadr[MAC_LEN];
+ memcpy(macadr,macadrin,MAC_LEN);
+ if (fsharedMAC == 0 && vend_id == VENDOR_INTEL) {
+ /* Intel factory assigns them this way, so use that to compare */
+ macadr[MAC_LEN-1] -= 2; /*OS MAC = BMC MAC - 2*/
+ }
+ i = GetLocalIPByMAC(macadr);
+ if (i == 1) fethfound = 1;
+ if (fdebug) /* show the local OS eth if and MAC */
+ printf("FindEth: OS %s IP=%d.%d.%d.%d MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ ifname, osmyip[0], osmyip[1], osmyip[2], osmyip[3],
+ osmymac[0], osmymac[1], osmymac[2], osmymac[3],
+ osmymac[4], osmymac[5]);
+ /* The actual Windows ethernet interface is determined
+ * in Get_IPMac_Addr using ipconfig, so
+ * init eth interface number as eth0 for Windows. */
+ return(0);
+}
+#elif defined(HPUX)
+#define INSAP 22
+#define OUTSAP 24
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <ctype.h>
+#include <sys/stropts.h>
+#include <sys/poll.h>
+#include <sys/dlpi.h>
+
+#define bcopy(source, destination, length) memcpy(destination, source, length)
+#define AREA_SZ 5000 /*=* buffer length in bytes *=*/
+#define GOT_CTRL 1
+#define GOT_DATA 2
+#define GOT_BOTH 3
+#define GOT_INTR 4
+#define GOT_ERR 128
+static u_long ctl_area[AREA_SZ];
+static u_long dat_area[AREA_SZ];
+static struct strbuf ctl = {AREA_SZ, 0, (char *)ctl_area};
+static struct strbuf dat = {AREA_SZ, 0, (char *)dat_area};
+static char *dlpi_dev[] = {"/dev/dlpi", ""};
+
+/*=* get a message from a stream; return type of message *=*/
+static int get_msg(int fd)
+{
+ int flags = 0;
+ int res, ret;
+ ctl_area[0] = 0;
+ dat_area[0] = 0;
+ ret = 0;
+ res = getmsg(fd, &ctl, &dat, &flags);
+ if(res < 0) {
+ if(errno == EINTR) {
+ return(GOT_INTR);
+ } else {
+ return(GOT_ERR);
+ }
+ }
+ if(ctl.len > 0) {
+ ret |= GOT_CTRL;
+ }
+ if(dat.len > 0) {
+ ret |= GOT_DATA;
+ }
+ return(ret);
+}
+
+/*=* verify that dl_primitive in ctl_area = prim *=*/
+static int check_ctrl(int prim)
+{
+ dl_error_ack_t *err_ack = (dl_error_ack_t *)ctl_area;
+ if(err_ack->dl_primitive != prim) {
+ return GOT_ERR;
+ }
+ return 0;
+}
+
+/*=* put a control message on a stream *=*/
+static int put_ctrl(int fd, int len, int pri)
+{
+ ctl.len = len;
+ if(putmsg(fd, &ctl, 0, pri) < 0) {
+ return GOT_ERR;
+ }
+ return 0;
+}
+
+/*=* put a control + data message on a stream *=*/
+static int put_both(int fd, int clen, int dlen, int pri)
+{
+ ctl.len = clen;
+ dat.len = dlen;
+ if(putmsg(fd, &ctl, &dat, pri) < 0) {
+ return GOT_ERR;
+ }
+ return 0;
+}
+
+/*=* open file descriptor and attach *=*/
+static int dl_open(const char *dev, int ppa, int *fd)
+{
+ dl_attach_req_t *attach_req = (dl_attach_req_t *)ctl_area;
+ if((*fd = open(dev, O_RDWR)) == -1) {
+ return GOT_ERR;
+ }
+ attach_req->dl_primitive = DL_ATTACH_REQ;
+ attach_req->dl_ppa = ppa;
+ put_ctrl(*fd, sizeof(dl_attach_req_t), 0);
+ get_msg(*fd);
+ return check_ctrl(DL_OK_ACK);
+}
+
+/*=* send DL_BIND_REQ *=*/
+static int dl_bind(int fd, int sap, u_char *addr)
+{
+ dl_bind_req_t *bind_req = (dl_bind_req_t *)ctl_area;
+ dl_bind_ack_t *bind_ack = (dl_bind_ack_t *)ctl_area;
+ bind_req->dl_primitive = DL_BIND_REQ;
+ bind_req->dl_sap = sap;
+ bind_req->dl_max_conind = 1;
+ bind_req->dl_service_mode = DL_CLDLS;
+ bind_req->dl_conn_mgmt = 0;
+ bind_req->dl_xidtest_flg = 0;
+ put_ctrl(fd, sizeof(dl_bind_req_t), 0);
+ get_msg(fd);
+ if (GOT_ERR == check_ctrl(DL_BIND_ACK)) {
+ return GOT_ERR;
+ }
+ bcopy((u_char *)bind_ack + bind_ack->dl_addr_offset, addr,
+ bind_ack->dl_addr_length);
+ return 0;
+}
+
+int FindEthNum(uchar *addr)
+{ /* Need to use DLPI for HPUX */
+ /*See http://cplus.kompf.de/artikel/macaddr.html */
+ int fd;
+ int ppa;
+ u_char mac_addr[25];
+ char **dev;
+ int i = 0;
+
+ for (dev = dlpi_dev; **dev != ''; ++dev) {
+ for (ppa=0; ppa<10; ++ppa) {
+ if (GOT_ERR != dl_open(*dev, ppa, &fd)) {
+ if (GOT_ERR != dl_bind(fd, INSAP, mac_addr)) {
+ // bcopy( mac_addr, addr, 6);
+ i = ppa;
+ if (memcmp(mac_addr,addr,MAC_LEN) == 0) {
+ memcpy(osmymac, addr, MAC_LEN);
+ return(ppa);
+ }
+ }
+ }
+ close(fd);
+ }
+ }
+ return(i);
+}
+#else
+
+static char *get_ifreq_mac(struct ifreq *ifrq)
+{
+ char *ptr;
+#ifdef SOLARIS
+ ptr = (char *)&ifrq->ifr_ifru.ifru_enaddr[0];
+#elif BSD
+ ptr = (char *)&ifrq->ifr_ifru.ifru_addr.sa_data[0];
+#elif MACOS
+ static uchar mactmp[MAC_LEN];
+ ptr = &mactmp[0];
+ MacSetInvalid(ptr);
+#else
+ ptr = (char *)&ifrq->ifr_hwaddr.sa_data[0];
+#endif
+ return (ptr);
+}
+
+extern int find_ifname(char *ifname); /*see idiscover.c*/
+
+int FindEthNum(uchar *macadrin)
+{ /*only used for Linux*/
+ struct ifreq ifr;
+ int skfd;
+ int nCurDevice;
+ int devnum = -1;
+ int devos = 0;
+ uchar macadr[MAC_LEN];
+ uchar macsav[MAC_LEN];
+ uchar mactmp[MAC_LEN];
+ uchar ipsav[4];
+ char szDeviceName[ 16 ]; /* MAX_DEVICE_NAME_LENGTH + 1 */
+ uchar fipvalid = 0;
+ int n;
+
+ memcpy(macadr,macadrin,MAC_LEN);
+ if (fsharedMAC == 0 && vend_id == VENDOR_INTEL) {
+ /* Intel factory assigns them this way, so use that to compare */
+ macadr[MAC_LEN-1] -= 2; /*OS MAC = BMC MAC - 2*/
+ }
+#ifdef DBG
+ if (fdebug) {
+ uchar *pb;
+ pb = macadrin;
+ printf("input mac:%02x:%02x:%02x:%02x:%02x:%02x "
+ "tmp mac:%02x:%02x:%02x:%02x:%02x:%02x\n",
+ pb[0],pb[1],pb[2],pb[3],pb[4],pb[5],
+ macadr[0],macadr[1],macadr[2],macadr[3],macadr[4],macadr[5]);
+ }
+#endif
+
+ n = find_ifname(szDeviceName);
+ if (n >= 0) {
+ n = strlen_(szDeviceName);
+ if (n < sizeof(ifpattn)) {
+ strcpy(ifpattn,szDeviceName);
+ ifpattn[n - 1] = 0; /*truncate last digit*/
+ }
+ if (fdebug)
+ printf("found ifname %s, pattern %s\n",szDeviceName,ifpattn);
+ }
+
+ if ( ( skfd = socket(AF_INET, SOCK_DGRAM, 0 ) ) < 0) {
+ if ( fdebug ) {
+ perror("socket");
+ return devnum;
+ }
+ }
+
+ for( nCurDevice = 0 ;
+ (nCurDevice < NUM_DEVICES_TO_CHECK) && (devnum == -1);
+ nCurDevice++ )
+ {
+ sprintf( szDeviceName, "%s%d", ifpattn, nCurDevice ); /*eth%d*/
+ memset((char *)&ifr,0,sizeof(ifr));
+ strcpy(ifr.ifr_name, szDeviceName );
+#ifdef SIOCGIFHWADDR
+ if (ioctl(skfd, SIOCGIFHWADDR, &ifr) > 0) {
+ if ( fdebug )
+ printf("FindEthNum: Could not get MAC address for %s\n",
+ szDeviceName);
+ } else
+#endif
+ {
+ uchar *pb;
+ pb = get_ifreq_mac(&ifr);
+#ifdef DBG
+ if (fdebug) {
+ printf("%s mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
+ szDeviceName, pb[0],pb[1],pb[2],pb[3],pb[4],pb[5]);
+ }
+#endif
+ memcpy(macsav, pb, MAC_LEN);
+ /* check if this device is configured for IP addr */
+ memset((char *)&ifr,0,sizeof(ifr));
+ strcpy(ifr.ifr_name, szDeviceName);
+ ifr.ifr_addr.sa_family = AF_INET;
+ if (ioctl(skfd, SIOCGIFADDR, &ifr) >= 0) {
+ fipvalid = 1;
+ memcpy(ipsav, &ifr.ifr_addr.sa_data[2], 4);
+ } else fipvalid = 0;
+ if (memcmp(macsav, macadr, MAC_LEN) == 0) { /*found match*/
+ devnum = nCurDevice;
+ memcpy(osmymac, macsav, MAC_LEN);
+ if (fipvalid) memcpy(osmyip, ipsav, 4);
+ break;
+ }
+ if (nCurDevice == 0) { /*set a default of eth0*/
+ devos = nCurDevice;
+ memcpy(osmymac,macsav, MAC_LEN);
+ if (fipvalid) memcpy(osmyip, ipsav, 4);
+ } else if (fipvalid) { /*check if NIC1 is eth1,2,3,...*/
+ memcpy(mactmp,osmymac,MAC_LEN);
+ mactmp[MAC_LEN-1] -= 1;
+ if (memcmp(mactmp,macsav,MAC_LEN) == 0) {
+ devos = nCurDevice;
+ memcpy(osmymac, macsav, MAC_LEN);
+ memcpy(osmyip, ipsav, 4);
+ }
+ }
+ } /*end else*/
+ }
+ if (!fsetifn) {
+ if (devnum == -1) { /*not found, use devos default*/
+ devnum = devos;
+ sprintf( ifname, "%s%d", ifpattn, devnum ); /*eth%d*/
+ } else { /* match was found, devnum set */
+ fethfound = 1;
+ strcpy(ifname, szDeviceName );
+ }
+ }
+ close(skfd);
+ if (fdebug) /* show the local OS eth if and MAC */
+ printf("FindEth: OS %s IP=%d.%d.%d.%d MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ ifname, osmyip[0], osmyip[1], osmyip[2], osmyip[3],
+ osmymac[0], osmymac[1], osmymac[2], osmymac[3],
+ osmymac[4], osmymac[5]);
+ return(devnum);
+}
+#endif
+
+int show_channels(void)
+{
+ int ret, rlen;
+ uchar iData[2];
+ uchar rData[10];
+ uchar cc, mtype;
+ int j;
+ int rv = -1;
+
+ for (j = 1; j < MAXCHAN; j++) {
+ rlen = sizeof(rData);
+ iData[0] = (uchar)j; /*channel #*/
+ memset(rData,0,9); /*initialize recv data*/
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug);
+ if (rv != 0) rv = ret;
+ if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */
+ continue;
+ if (ret != 0) {
+ if (fdebug) printf("get_chan_info rc = %x\n",ret);
+ break;
+ }
+ mtype = rData[1]; /* channel medium type */
+ switch(mtype) {
+ case 4: printf("channel[%d] type = lan\n",j); break; /*802.3 LAN type*/
+ case 5: printf("channel[%d] type = serial\n",j); break;
+ case 7: printf("channel[%d] type = pci_smbus\n",j); break;
+ case 12: printf("channel[%d] type = system_interface\n",j); break;
+ default: printf("channel[%d] type = other %d\n",j,mtype); break;
+ }
+ rv = 0;
+ } /*end for j*/
+ return(rv);
+}
+
+/*
+ * GetBmcEthDevice
+ * Attempt to auto-detect the BMC LAN channel and matching OS eth port.
+ * INPUT: lan_parm = lan channel from user -L option, 0xFF if not specified
+ * OUTPUT: lan_ch is set to BMC LAN channel number
+ * if success, returns index of OS eth port (0, 1, ...).
+ * if no lan channels found, returns -2.
+ * if other error, returns -1.
+ */
+int GetBmcEthDevice(uchar lan_parm)
+{
+ LAN_RECORD LanRecord;
+ int devnum = -1;
+ int ret;
+ uchar bmcMacAddress[ MAC_LEN ]; /*MAC_LEN = 6*/
+ int rlen;
+ uchar iData[2];
+ uchar rData[10];
+ uchar cc;
+ int i = 0;
+ int j, jstart, jend, jlan;
+ uchar mtype;
+ uchar *pb;
+ int fchgmac;
+ // int found = 0;
+
+ /* Find the LAN channel(s) via Channel Info */
+ if (lan_parm < MAXCHAN) { /* try user-specified channel only */
+ lan_ch = lan_parm;
+ jstart = lan_parm;
+ jend = lan_parm+1;
+ } else {
+ jstart = 1;
+ jend = MAXCHAN;
+ }
+ memset(bmcMacAddress,0xff,sizeof(bmcMacAddress)); /*initialize to invalid*/
+ for (j = jstart; j < jend; j++) {
+ rlen = sizeof(rData);
+ iData[0] = (uchar)j; /*channel #*/
+ memset(rData,0,9); /*initialize recv data*/
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug);
+ if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */
+ continue;
+ if (ret != 0) {
+ if (fdebug) printf("get_chan_info rc = %x\n",ret);
+ break;
+ }
+ mtype = rData[1]; /* channel medium type */
+ if (mtype == 4) { /* 802.3 LAN type*/
+ if (fdebug) printf("chan[%d] = lan\n",j);
+ jlan = lan_ch; /*save prev lan chan */
+ /* Get BMC MAC for this LAN channel. */
+ /* Note: BMC MAC may not be valid yet. */
+ lan_ch = (uchar)j; /*set lan channel for GetLanEntry*/
+ ret = GetLanEntry( 5 /*MAC_ADDRESS_LAN_PARAM*/,0, &LanRecord);
+ if ( ret != 0 ) {
+ lan_ch = (uchar)jlan; /*restore lan_ch*/
+ printf( "GetBmcEthDevice: GetLanEntry failed\n" );
+ return devnum;
+ } else {
+ pb = &LanRecord.data[0];
+ if (fdebug) printf("chan[%d] BMC MAC %x:%x:%x:%x:%x:%x\n",j,
+ pb[0], pb[1], pb[2], pb[3], pb[4], pb[5] );
+ fchgmac = 0;
+ /* use the lowest valid lan channel MAC address */
+ if (!MacIsValid(bmcMacAddress)) /* old MAC not valid*/
+ fchgmac = 1;
+ else if (MacIsValid(pb) && /* new MAC is valid and*/
+ (memcmp(bmcMacAddress,pb, sizeof(bmcMacAddress)) > 0))
+ fchgmac = 1; /* new MAC lower */
+ /* if no -L 3 and this is gcm, do not pick it. */
+ if ((j == gcm_ch) && (lan_parm == PARM_INIT))
+ fchgmac = 0;
+ if (fchgmac) { /* pick this channel & MAC */
+ memcpy(bmcMacAddress,pb,sizeof(bmcMacAddress));
+ lan_ch = (uchar)j;
+ } else lan_ch = (uchar)jlan; /*restore prev lan chan*/
+ }
+ i++; /* i = num lan channels found */
+ } else if (mtype == 5) { /* serial type*/
+ if (fdebug) printf("chan[%d] = serial\n",j);
+ ser_ch = (uchar)j; /* set to last serial channel */
+ } else if (mtype == 7) { /* PCI SMBus */
+ if (fdebug) printf("chan[%d] = pci_smbus\n",j);
+ } else if (mtype == 12) { /* system interface */
+ if (fdebug) printf("chan[%d] = system_interface\n",j);
+ } else /* other channel medium types, see IPMI 1.5 Table 6-3 */
+ if (fdebug) printf("chan[%d] = %d\n",j,mtype);
+ }
+ if (i == 0) return(-2); /* no lan channels found */
+ if (fdebug) printf("lan_ch detected = %d\n",lan_ch);
+
+ /* This will work if the BMC MAC is shared with the OS */
+ /* Otherwise, wait until we get the eth dev from the gateway below */
+ devnum = FindEthNum(bmcMacAddress);
+ if ( fdebug )
+ printf("GetBmcEthDevice: channel %d, %s%d\n",lan_ch,ifpattn,devnum);
+ return devnum;
+}
+
+/* file_grep/findmatch - No longer used here, see ievents.c */
+
+/*
+ * Get_Mac
+ * This routine finds a MAC address from a given IP address.
+ * Usually for the Alert destination.
+ * It uses ARP cache to do this.
+ */
+#if defined(WIN32)
+int Get_Mac(uchar *ipadr,uchar *macadr, char *nodname)
+{
+ DWORD dwRetVal;
+ IPAddr DestIp = 0;
+ IPAddr SrcIp = 0; /* default for src ip */
+ ULONG MacAddr[2]; /* for 6-byte hardware addresses */
+ ULONG PhysAddrLen = MAC_LEN; /* default to length of six bytes */
+ BYTE *bPhysAddr;
+
+ if (!IpIsValid(ipadr)) {
+ if (fdebug) printf("Get_Mac: invalid IP addr\n");
+ return 1; /*error*/
+ }
+ memcpy(&DestIp, ipadr, 4);
+
+ /* invoke system ARP query */
+ dwRetVal = SendARP(DestIp, SrcIp, MacAddr, &PhysAddrLen);
+
+ if (dwRetVal == NO_ERROR)
+ { /* no error - get the MAC */
+ bPhysAddr = (BYTE *) & MacAddr;
+ if (PhysAddrLen) {
+ memcpy(macadr, bPhysAddr, MAC_LEN);
+ } else
+ printf("Warning: SendArp completed successfully, but returned length=0\n");
+ } else if (dwRetVal == ERROR_GEN_FAILURE)
+ { /* MAC not available in this network - get gateway MAC */
+ memcpy(macadr, rggwymac, MAC_LEN);
+ } else
+ { /* other errors */
+ printf("Error: SendArp failed with error: %d", dwRetVal);
+ switch (dwRetVal) {
+ case ERROR_INVALID_PARAMETER:
+ printf(" (ERROR_INVALID_PARAMETER)\n");
+ break;
+ case ERROR_INVALID_USER_BUFFER:
+ printf(" (ERROR_INVALID_USER_BUFFER)\n");
+ break;
+ case ERROR_BAD_NET_NAME:
+ printf(" (ERROR_GEN_FAILURE)\n");
+ break;
+ case ERROR_BUFFER_OVERFLOW:
+ printf(" (ERROR_BUFFER_OVERFLOW)\n");
+ break;
+ case ERROR_NOT_FOUND:
+ printf(" (ERROR_NOT_FOUND)\n");
+ break;
+ default:
+ printf("\n");
+ break;
+ }
+ return 1;
+ }
+ return 0;
+} /* end Get_Mac() for WIN32*/
+#elif defined(SOLARIS)
+int Get_Mac(uchar *ipadr,uchar *macadr, char *nodename)
+{
+ FILE *fparp;
+ char buff[1024];
+ /* char arpfile[] = "/proc/net/arp"; */
+ char alertfile[] = "/tmp/dest.arping";
+ char arping_cmd[128];
+ char *pb, *pm;
+ int num, i;
+ int foundit = 0;
+ int ret = 0;
+
+ if (IpIsValid(ipadr)) { /* if valid IP address */
+ sprintf(arping_cmd,
+ "ping %d.%d.%d.%d >/dev/null; arp -a -n |grep %d.%d.%d.%d >%s\n",
+ ipadr[0],ipadr[1],ipadr[2],ipadr[3],
+ ipadr[0],ipadr[1],ipadr[2],ipadr[3], alertfile);
+ } else if (nodename != NULL) { /*if valid nodename */
+ sprintf(arping_cmd,
+ "ping %s >/dev/null; arp -a |grep %s >%s\n",
+ nodename,nodename,alertfile);
+ } else ret = -1;
+
+ if (ret == 0) { /* if valid IP address */
+ /* make sure the destination is in the arp cache */
+ if (fdebug) printf("%s", arping_cmd);
+ system(arping_cmd);
+
+ fparp = fopen(alertfile,"r");
+ if (fparp == NULL) {
+ fprintf(stdout,"Get_Mac: Cannot open %s, errno = %d\n",
+ alertfile,get_errno());
+ ret = -1;
+ } else {
+ /* sample output: */
+ /* e1000g0 cooper9 255.255.255.255 o 00:07:e9:06:55:c8 */
+ while (fgets(buff, 1023, fparp)) {
+ /* should only run through loop once */
+ num = strcspn(buff," \t"); /* skip 1st word ("e1000g0") */
+ i = strspn(&buff[num]," \t"); /* skip whitespace */
+ pb = &buff[num+i];
+ num = strcspn(pb," \t"); /* skip 2nd word (nodename/IP) */
+ i = strspn(&pb[num]," \t"); /* skip whitespace */
+ pb += (num+i);
+ pm = &pb[25]; /* Now pb[25] has the MAC address */
+ { /*validate new address?*/
+ if (fdebug) printf("Get_Mac: mac=%s\n",pm);
+ foundit = 1;
+ if (!MacIsValid(macadr)) atomac(macadr,pm);
+ break;
+ }
+ } /*end while*/
+ fclose(fparp);
+ } /*end else file opened*/
+ } /*endif valid IP */
+
+ if (foundit == 0) { /* no errors, but no mac reply */
+ if (MacIsValid(rggwymac) && !MacIsValid(macadr))
+ /* this is useful if the ipadr is not in the local subnet */
+ memcpy(macadr,rggwymac,6); /* get to it from the default gateway */
+ }
+ return(ret);
+} /*end Get_Mac for Solaris*/
+#elif defined(BSD)
+int Get_Mac(uchar *ipadr,uchar *macadr, char *nodename)
+{
+ FILE *fparp;
+ char buff[1024];
+ /* char arpfile[] = "/proc/net/arp"; */
+ char alertfile[] = "/tmp/dest.arping";
+ char arping_cmd[128];
+ char *pb, *pm;
+ int num, i, j;
+ int foundit = 0;
+ int ret = 0;
+
+ if (IpIsValid(ipadr)) { /* if valid IP address */
+ sprintf(arping_cmd,
+ "ping -c2 %d.%d.%d.%d >/dev/null; arp -a -n |grep %d.%d.%d.%d >%s\n",
+ ipadr[0],ipadr[1],ipadr[2],ipadr[3],
+ ipadr[0],ipadr[1],ipadr[2],ipadr[3], alertfile);
+ } else if (nodename != NULL) { /*if valid nodename */
+ sprintf(arping_cmd,
+ "ping -c2 %s >/dev/null; arp -a |grep %s >%s\n",
+ nodename,nodename,alertfile);
+ } else ret = -1;
+
+ if (ret == 0) { /* if valid IP address */
+ /* make sure the destination is in the arp cache */
+ if (fdebug) printf("%s", arping_cmd);
+ system(arping_cmd);
+
+ fparp = fopen(alertfile,"r");
+ if (fparp == NULL) {
+ fprintf(stdout,"Get_Mac: Cannot open %s, errno = %d\n",
+ alertfile,get_errno());
+ ret = -1;
+ } else {
+ /* sample output of arp -a -n: */
+ /* ? (192.168.1.200) at 00:0e:0c:e5:df:65 on em0 [ethernet] */
+ /* sample output of arp -a: */
+ /* telcoserv (192.168.1.200) at 00:0e:0c:e5:df:65 on em0 [ethernet] */
+ while (fgets(buff, 1023, fparp)) {
+ /* should only run through loop once */
+ pb = &buff[0];
+ for (j = 0; j < 3; j++) { /* skip 3 words */
+ num = strcspn(pb," \t"); /* skip jth word */
+ i = strspn(&pb[num]," \t"); /* skip whitespace */
+ pb += (num+i);
+ }
+ pm = &pb[0]; /* Now pb[0] has the MAC address */
+ { /* no need to validate new address*/
+ if (fdebug) printf("Get_Mac: mac=%s\n",pm);
+ foundit = 1;
+ if (!MacIsValid(macadr)) atomac(macadr,pm);
+ break;
+ }
+ } /*end while*/
+ fclose(fparp);
+ } /*end else file opened*/
+ } /*endif valid IP */
+
+ if (foundit == 0) { /* no errors, but no mac reply */
+ if (MacIsValid(rggwymac) && !MacIsValid(macadr))
+ /* this is useful if the ipadr is not in the local subnet */
+ memcpy(macadr,rggwymac,6); /* get to it from the default gateway */
+ }
+ return(ret);
+} /*end Get_Mac for BSD */
+#else
+int Get_Mac(uchar *ipadr,uchar *macadr, char *nodename)
+{ /* Get_Mac for Linux */
+ FILE *fparp;
+ char buff[1024];
+ /* char arpfile[] = "/proc/net/arp"; */
+ char alertfile[] = "/tmp/dest.arping";
+ char arping_cmd[128];
+ char *pb, *pm, *px;
+ int num, i;
+ int foundit = 0;
+ int ret = 0;
+ char *_ifname;
+
+ if (strcmp(ifname,"gcm") == 0) _ifname = ifname0; /*see gcm_ch instead*/
+ else _ifname = ifname;
+
+ /* Get a MAC address for a given IP address or nodename */
+ if (IpIsValid(ipadr)) { /* if valid IP address */
+ sprintf(arping_cmd,
+ "arping -I %s -c 2 %d.%d.%d.%d |grep reply |tail -n1 >%s\n",
+ _ifname,ipadr[0],ipadr[1],ipadr[2],ipadr[3],alertfile);
+ } else if (nodename != NULL) { /*if valid nodename */
+ sprintf(arping_cmd,
+ "arping -I %s -c 2 %s |grep reply |tail -n1 >%s\n",
+ _ifname,nodename,alertfile);
+ } else ret = -1;
+
+ if (ret == 0) { /* if valid IP address */
+ /* make sure the destination is in the arp cache */
+ if (fdebug) printf("%s", arping_cmd);
+ ret = system(arping_cmd);
+
+ fparp = fopen(alertfile,"r");
+ if (fparp == NULL) {
+ fprintf(stdout,"Get_Mac: Cannot open %s, errno = %d\n",
+ alertfile,get_errno());
+ ret = -1;
+ } else {
+ ret = 0;
+ while (fgets(buff, 1023, fparp)) {
+ /* should only run through loop once */
+ num = strcspn(buff," \t"); /* skip 1st word ("Unicast") */
+ i = strspn(&buff[num]," \t");
+ pb = &buff[num+i];
+ if (strncmp(pb,"reply",5) == 0) { /* valid output */
+ /* Find the ip address */
+ pb += 6 + 5; /* skip "reply from " */
+ num = strcspn(pb," \t");
+ pb[num] = 0;
+ if (fdebug) printf("Get_Mac: ip=%s\n",pb);
+ /* IP address should already match input param */
+ if (!IpIsValid(ipadr)) /* had nodname only*/
+ atoip(ipadr,pb); /* fill in ipadr */
+ /* Now find the mac address */
+ pm = strchr(&pb[num+1],'[');
+ if (pm == NULL) pm = &pb[num+2]; /* just in case */
+ pm++;
+ px = strchr(pm,']');
+ if (px == NULL) px = pm + 17; /* just in case */
+ px[0] = 0;
+ if (fdebug) printf("Get_Mac: mac=%s\n",pm);
+ foundit = 1;
+ if (!MacIsValid(macadr)) atomac(macadr,pm);
+ break;
+ }
+ } /*end while*/
+ fclose(fparp);
+ } /*end else file opened*/
+ } /*endif valid IP */
+
+ if (foundit == 0) { /* no errors, but no mac reply */
+ if (MacIsValid(rggwymac) && !MacIsValid(macadr))
+ /* this is useful if the ipadr is not in the local subnet */
+ memcpy(macadr,rggwymac,6); /* get to it from the default gateway */
+ }
+ return(ret);
+} /* end Get_Mac() for Linux*/
+#endif
+
+#ifdef WIN32
+/*
+ * Set subnet mask based on current IP address (Windows).
+ */
+int SetSubnetMask() {
+ PMIB_IPADDRTABLE pIPAddrTable;
+ unsigned int i;
+ DWORD dwSize = 0, dwRetVal;
+ LPVOID lpMsgBuf;
+
+ pIPAddrTable = (MIB_IPADDRTABLE*) malloc( sizeof( MIB_IPADDRTABLE) );
+
+ if ( pIPAddrTable ) {
+ // Make an initial call to GetIpAddrTable to get the
+ // necessary size into the dwSize variable
+ if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
+ free( pIPAddrTable );
+ pIPAddrTable = (MIB_IPADDRTABLE *) malloc ( dwSize );
+ }
+ } else
+ printf("Memory allocation failed.\n");
+
+ if ( pIPAddrTable ) {
+ // Make a second call to GetIpAddrTable to get the
+ // actual data we want
+ if ( (dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 )) == NO_ERROR ) {
+ for(i = 0; i < pIPAddrTable->dwNumEntries; ++i) {
+ if(memcmp(&(pIPAddrTable->table[i].dwAddr), rgmyip, 4) == 0) {
+ memcpy(rgsubnet, &(pIPAddrTable->table[i].dwMask), 4);
+ free( pIPAddrTable );
+ return 1;
+ }
+ }
+ } else {
+ if (FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ dwRetVal,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPTSTR) &lpMsgBuf,
+ 0,
+ NULL )) {
+ printf("\tError: %s", lpMsgBuf);
+ }
+
+ printf("Call to GetIpAddrTable failed.\n");
+ }
+ }
+
+ if ( pIPAddrTable )
+ free( pIPAddrTable );
+
+ return 0;
+}
+
+/*
+ * Extract gateway address from routing table (Windows).
+ */
+int SetDefaultGateway() {
+ PMIB_IPFORWARDTABLE pIpForwardTable;
+ DWORD dwRetVal, dwSize;
+
+ unsigned int nord_mask;
+ unsigned int nord_ip;
+ unsigned int nord_net;
+
+ unsigned int i;
+
+ nord_mask = *((unsigned int *)rgsubnet);
+ nord_ip = *((unsigned int *)rgmyip);
+
+ nord_net = nord_ip & nord_mask;
+
+ pIpForwardTable = (MIB_IPFORWARDTABLE*) malloc(sizeof(MIB_IPFORWARDTABLE));
+ if (pIpForwardTable == NULL) {
+ printf("Error allocating memory\n");
+ return 0;
+ }
+
+ dwSize = 0;
+ if (GetIpForwardTable(pIpForwardTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
+ free(pIpForwardTable);
+ pIpForwardTable = (MIB_IPFORWARDTABLE*) malloc(dwSize);
+ if (pIpForwardTable == NULL) {
+ printf("Error allocating memory\n");
+ return 0;
+ }
+ }
+
+ /*
+ * Note that the IPv4 addresses returned in
+ * GetIpForwardTable entries are in network byte order
+ */
+ if ((dwRetVal = GetIpForwardTable(pIpForwardTable, &dwSize, 0)) == NO_ERROR) {
+ for (i = 0; i < (int) pIpForwardTable->dwNumEntries; i++) {
+ unsigned int gwaddr = pIpForwardTable->table[i].dwForwardNextHop;
+ if(nord_net == (gwaddr & nord_mask) && nord_ip != gwaddr)
+ { /* searching for gateways from our network with different address than ours */
+ memcpy(rggwyip, &gwaddr, 4);
+ return 0;
+ }
+ }
+ free(pIpForwardTable);
+ return 1;
+ }
+ else {
+ printf("\tGetIpForwardTable failed.\n");
+ free(pIpForwardTable);
+ return 0;
+ }
+
+}
+/*endif WIN32*/
+#endif
+
+/*
+ * Get_IPMac_Addr
+ * This routine finds the IP and MAC for the local interface,
+ * the default gateway, and SNMP alert destination from the
+ * BMC and OS information.
+ *
+ * Linux snmpd.conf locations (see ipmiutil.spec):
+ * RedHat, MontaVista: /etc/snmp/snmpd.conf
+ * SuSE SLES 8: /etc/ucdsnmpd.conf
+ * SuSE SLES 9: /etc/snmpd.conf
+ */
+#ifdef WIN32
+int Get_IPMac_Addr()
+{ /*for Windows*/
+ char ipstr[] = "IP Address";
+ char macstr[] = "Physical Address";
+ char gwystr[] = "Default Gateway";
+ char substr[] = "Subnet Mask";
+ int found = 0;
+ char fgetmac;
+
+ if (IpIsValid(rgmyip))
+ { /* user-specified ip, get mac */
+ if (fdebug) printf("User IP was specified\n");
+ if (!MacIsValid(rgmymac))
+ { /* no user-specified MAC, get it from IP */
+ if (fdebug) printf("No user MAC specified\n");
+ if(!GetLocalMACByIP())
+ { /* couldn't get MAC from IP, get old one */
+ if (fdebug) printf("No MAC from IP, use old\n");
+ if(IpIsValid(bmcmyip) && MacIsValid(bmcmymac))
+ {
+ printf("Using current BMC MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ bmcmymac[0], bmcmymac[1],
+ bmcmymac[2], bmcmymac[3],
+ bmcmymac[4], bmcmymac[5]);
+ memcpy(rgmymac,bmcmymac,MAC_LEN);
+ } else {
+ printf("Failed to obtain valid MAC\n");
+ }
+ } else {
+ printf("Using adapter MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ rgmymac[0], rgmymac[1],
+ rgmymac[2], rgmymac[3],
+ rgmymac[4], rgmymac[5]);
+ }
+ } else { /* user MAC available */
+ printf("Using user MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ rgmymac[0], rgmymac[1],
+ rgmymac[2], rgmymac[3],
+ rgmymac[4], rgmymac[5]);
+ }
+ } else { /* no user-specified IP */
+ if (fdebug) printf("No user IP specified\n");
+ if (!MacIsValid(rgmymac))
+ { /* no user-specified MAC, get it from interface */
+ if(!GetLocalDataByIface())
+ { /* use existing MAC an IP */
+ printf("Using current BMC IP %d.%d.%d.%d\n",
+ bmcmyip[0], bmcmyip[1],
+ bmcmyip[2], bmcmyip[3]);
+ memcpy(rgmyip,bmcmyip,4);
+ printf("Using current BMC MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ bmcmymac[0], bmcmymac[1],
+ bmcmymac[2], bmcmymac[3],
+ bmcmymac[4], bmcmymac[5]);
+ memcpy(rgmymac,bmcmymac,MAC_LEN);
+
+ }
+ } else { /* user-specified MAC */
+ if(!GetLocalIPByMAC(rgmymac))
+ { /* use existing MAC and IP */
+ printf("Using current BMC IP %d.%d.%d.%d\n",
+ bmcmyip[0], bmcmyip[1],
+ bmcmyip[2], bmcmyip[3]);
+ memcpy(rgmyip,bmcmyip,4);
+ printf("Using current BMC MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ bmcmymac[0], bmcmymac[1],
+ bmcmymac[2], bmcmymac[3],
+ bmcmymac[4], bmcmymac[5]);
+ memcpy(rgmymac,bmcmymac,MAC_LEN);
+ }
+ }
+ }
+
+ if (rghostname[0] == 0) { /*hostname not specified*/
+ if (!fipmilan)
+ gethostname(rghostname,sizeof(rghostname));
+ }
+ if (fdebug) /* show the local OS eth if and MAC */
+ printf("OS %s IP=%d.%d.%d.%d %s MAC=%02x:%02x:%02x:%02x:%02x:%02x used for arp\n",
+ ifname, osmyip[0],osmyip[1],osmyip[2],osmyip[3], rghostname,
+ osmymac[0], osmymac[1], osmymac[2], osmymac[3],
+ osmymac[4], osmymac[5]);
+
+ if(!SubnetIsValid(rgsubnet)) {
+ SetSubnetMask();
+ }
+ if (!IpIsValid(rggwyip)) { /* if gwy ip not user-specified */
+ SetDefaultGateway();
+ }
+
+ if (lan_ch == gcm_ch) {
+ if (SubnetIsSame(rgmyip,rggwyip,rgsubnet)) fgetmac = 1;
+ else fgetmac = 0;
+ } else fgetmac = 1;
+
+ if (fgetmac) {
+ if (IpIsValid(rggwyip) && !MacIsValid(rggwymac)) /*gwy mac not specified*/
+ Get_Mac(rggwyip,rggwymac,NULL);
+
+ if (IpIsValid(rggwy2ip) && !MacIsValid(rggwy2mac)) /*gwy2 mac not valid*/
+ Get_Mac(rggwy2ip,rggwy2mac,NULL);
+ }
+
+ return(0);
+} /* end Get_IPMac_Addr for Windows */
+
+#elif defined(HPUX)
+int Get_IPMac_Addr()
+{ /*for HP-UX*/
+ return(-1);
+}
+#else
+int Get_IPMac_Addr()
+{ /*for Linux*/
+#if defined(SOLARIS)
+ char rtfile[] = "/tmp/route";
+ char snmpfile[] = "/etc/snmp/conf/snmpd.conf";
+#elif defined(BSD)
+ char rtfile[] = "/tmp/route";
+ char snmpfile[] = "/etc/snmpd.config";
+#else
+ char rtfile[] = "/proc/net/route";
+ char snmpfile[] = "/etc/snmp/snmpd.conf";
+#endif
+ // char alertfile[] = "/tmp/alert.arping";
+ // FILE *fparp;
+ FILE *fprt;
+ int fd = -1;
+ int skfd;
+ uchar *pc;
+ int rc = 0;
+ int i,j;
+ uchar bnetadr[4];
+ uchar bgateadr[4];
+ char gate_addr[128];
+ char iface[16];
+ char defcommunity[19] = "public";
+ char buff[1024];
+ char alertname[60];
+ int num, nmatch;
+ struct ifreq ifr;
+ char *_ifname;
+ char fgetmac;
+
+ /* Get the IP address and associated MAC address specified. */
+ /* Local for ethN; Default Gateway; Alert Destination */
+
+ /* Get the default gateway IP */
+#if defined(SOLARIS) || defined(BSD)
+ char rtcmd[80];
+ sprintf(rtcmd,"netstat -r -n |grep default |awk '{ print $2 }' >%s",rtfile);
+ system(rtcmd);
+ /* use rtfile output from netstat -r, see also /etc/defaultroute */
+ fprt = fopen(rtfile,"r");
+ if (fprt == NULL) {
+ fprintf(stdout,"netstat: Cannot open %s, errno = %d\n",rtfile,get_errno());
+ } else {
+ while (fgets(buff, 1023, fprt)) {
+ if ((buff[0] > '0') && (buff[0] <= '9')) { /*valid*/
+ atoip(bgateadr,buff);
+ if (fdebug)
+ printf("default gateway: %s, %d.%d.%d.%d %s\n",buff,
+ bgateadr[0], bgateadr[1], bgateadr[2], bgateadr[3],ifname);
+ if (!IpIsValid(rggwyip)) /* if not user-specified */
+ memcpy(rggwyip,bgateadr,4);
+ break;
+ }
+ }
+ fclose(fprt);
+ } /*end-else good open */
+#else
+ /* cat /proc/net/route and save Gwy if Dest == 0 and Gateway != 0 */
+ fprt = fopen(rtfile,"r");
+ if (fprt == NULL) {
+ fprintf(stdout,"route: Cannot open %s, errno = %d\n",rtfile,get_errno());
+ } else {
+ char rtfmt[] = "%16s %128s %128s %X %d %d %d %128s %d %d %d\n";
+ int iflags, refcnt, use, metric, mss, window, irtt;
+ char mask_addr[128], net_addr[128];
+ uint *pnet;
+ uint *pgate;
+
+ pnet = (uint *)&bnetadr[0];
+ pgate = (uint *)&bgateadr[0];
+ while (fgets(buff, 1023, fprt)) {
+ num = sscanf(buff, rtfmt,
+ iface, net_addr, gate_addr,
+ &iflags, &refcnt, &use, &metric, mask_addr,
+ &mss, &window, &irtt);
+ if (num < 10 || !(iflags & RTF_UP))
+ continue;
+
+ j = 6;
+ for (i = 0; i < 4; i ++) {
+ bnetadr[i] = htoi(&net_addr[j]);
+ bgateadr[i] = htoi(&gate_addr[j]);
+ j -= 2;
+ }
+ if ((*pnet == 0) && (*pgate != 0)) { /* found default gateway */
+ if (fdebug)
+ printf("default gateway: %s, %d.%d.%d.%d %s\n",gate_addr,
+ bgateadr[0], bgateadr[1], bgateadr[2], bgateadr[3],iface);
+ if (!IpIsValid(rggwyip)) /* if not user-specified */
+ memcpy(rggwyip,bgateadr,4);
+ _ifname = iface; /*use this iface for gwy mac */
+ if (!fsetifn) strncpy(ifname,iface,16);
+ break;
+ }
+ } /*end while*/
+ fclose(fprt);
+ } /*end-else good open */
+#endif
+
+ /* Create a channel to the NET kernel. */
+ if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ perror("socket");
+ return(-3);
+ }
+
+ /* Find a valid local BMC MAC Address */
+ if (lan_ch == gcm_ch) {
+ /* GCM has its own unique mac address */
+ if (!MacIsValid(rgmymac)) {
+ if (MacIsValid(bmcmymac)) {
+ memcpy(rgmymac,bmcmymac,MAC_LEN); /*use existing*/
+ } else { /*error*/
+ printf("invalid MAC address for gcm\n");
+ }
+ } /*else use rgmymac if specified*/
+ _ifname = iface; /*use the iface from gwy (e.g. eth0) */
+ fsharedMAC = 0; /*gcm has separate NIC, separate MAC*/
+
+ // fd = -1;
+ fd = skfd; // get_socket_for_af(AF_INET) below;
+ } else { /*else not gcm*/
+ if (!fsetifn && !fethfound) { /*do not have ifname yet*/
+ i = FindEthNum(bmcmymac);
+ if (i >= 0) sprintf(ifname,"%s%d",ifpattn,i);
+ }
+ ifr.ifr_addr.sa_family = AF_INET;
+ if (fdebug) printf("getipmac: ifname=%s\n",ifname);
+ _ifname = ifname;
+ strcpy(ifr.ifr_name, _ifname);
+
+#ifdef SIOCGIFHWADDR
+ /* Get the local if HWADDR (MAC Address) from OS */
+ if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0) {
+ if (fdebug)
+ printf("ioctl(SIOCGIFHWADDR,%s) error, errno = %d\n",_ifname,get_errno());
+ } else memcpy(osmymac,get_ifreq_mac(&ifr),MAC_LEN); /*OS mac*/
+#endif
+
+ if (memcmp(bmcmymac,osmymac,MAC_LEN) == 0) {
+ /* osmymac and ifname were set above by FindEthNum */
+ printf("\tBMC shares IP/MAC with OS NIC %s\n",_ifname);
+ fsharedMAC = 1;
+ } /* else fsharedMAC = 0; */
+
+ if (fsharedMAC == 0) { /* then BMC has separate MAC */
+ if (!MacIsValid(rgmymac) && MacIsValid(bmcmymac))
+ memcpy(rgmymac,bmcmymac,MAC_LEN); /*use existing*/
+ } else { /* else OS & BMC share a MAC */
+ /* Use the local if HWADDR (MAC Address) from OS */
+ if (!MacIsValid(rgmymac)) { /* if not user-specified */
+ if (MacIsValid(bmcmymac))
+ memcpy(rgmymac,bmcmymac,MAC_LEN); /*use existing*/
+ else memcpy(rgmymac,osmymac,MAC_LEN); /*use OS mac*/
+ }
+ }
+ fd = skfd; // get_socket_for_af(AF_INET) below;
+ }
+
+ if (fd >= 0) { /* if valid fd, find OS IP */
+ strcpy(ifr.ifr_name, _ifname);
+ ifr.ifr_addr.sa_family = AF_INET;
+ /* Get the IFADDR (IP Address) from OS */
+ if (ioctl(fd, SIOCGIFADDR, &ifr) < 0) {
+ int err;
+ err = get_errno();
+ /* errno 99 here means that eth0 is not enabled/up/defined. */
+ if (err == 99)
+ printf("ioctl(SIOCGIFADDR) error, %s not enabled\n",_ifname);
+ else if (fdebug)
+ printf("ioctl(SIOCGIFADDR,%s) error, errno=%d\n",_ifname,err);
+ } else { /* got the local OS IP successfully */
+ pc = &ifr.ifr_addr.sa_data[2];
+ if (fdebug)
+ printf("%s addr = %d.%d.%d.%d\n",_ifname,pc[0],pc[1],pc[2],pc[3]);
+ memcpy(osmyip, pc, 4);
+ if (!IpIsValid(rgmyip) && (fsharedMAC==1)) /*not specified, shared*/
+ memcpy(rgmyip, osmyip, 4);
+
+ /* get the local OS netmask */
+ strcpy(ifr.ifr_name, _ifname);
+ if (ioctl(fd, SIOCGIFNETMASK, &ifr) < 0) {
+ if (fdebug)
+ printf("ioctl(SIOCGIFNETMASK) error, errno=%d\n",get_errno());
+ /* if leave invalid, will use default rgsubnet */
+ } else { // sizeof(struct sockaddr)
+ pc = &ifr.ifr_netmask.sa_data[2];
+ if (fdebug)
+ printf("subnet = %d.%d.%d.%d \n", pc[0],pc[1],pc[2],pc[3]);
+ memcpy(ossubnet, pc, 4);
+ if (!SubnetIsValid(rgsubnet) && fsharedMAC) /*not specified*/
+ memcpy(rgsubnet, pc, 4);
+ }
+
+#ifdef SIOCGIFHWADDR
+ /* Get the localhost OS HWADDR (MAC Address) */
+ if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
+ if (fdebug)
+ printf("ioctl(SIOCGIFHWADDR,%s) error, errno = %d\n",
+ _ifname,get_errno());
+ } else memcpy(osmymac,get_ifreq_mac(&ifr),MAC_LEN); /*OS mac*/
+#endif
+ }
+ }
+ close(skfd); /* done, close the socket */
+
+ if (rghostname[0] == 0) { /*hostname not specified*/
+ if (!fipmilan)
+ gethostname(rghostname,sizeof(rghostname));
+ }
+ if (fdebug) /* show the local OS eth if and MAC */
+ printf("OS %s IP=%d.%d.%d.%d %s MAC=%02x:%02x:%02x:%02x:%02x:%02x used for arp\n",
+ _ifname, osmyip[0],osmyip[1],osmyip[2],osmyip[3], rghostname,
+ osmymac[0], osmymac[1], osmymac[2], osmymac[3],
+ osmymac[4], osmymac[5]);
+
+ if (!IpIsValid(rgmyip) && IpIsValid(bmcmyip)) {
+ /* If no user-specified IP and there is a valid IP already in the
+ * BMC LAN configuration, use the existing BMC LAN IP. */
+ memcpy(rgmyip,bmcmyip,4);
+ if (fdebug) printf("Using current IP %d.%d.%d.%d\n",
+ bmcmyip[0], bmcmyip[1],
+ bmcmyip[2], bmcmyip[3]);
+ }
+
+ /* Get the default gateway MAC */
+ if (lan_ch == gcm_ch) {
+ if (SubnetIsSame(osmyip,rggwyip,ossubnet)) fgetmac = 1;
+ else { /* gateway is not on the same subnet as RMM/GCM */
+ fgetmac = 0; /*don't try to get mac if not the same subnet*/
+ if ((fset_ip & GWYIP) == 0) memset(rggwyip,0,4);
+ }
+ } else fgetmac = 1;
+ if (fgetmac && IpIsValid(rggwyip) && !MacIsValid(rggwymac))
+ Get_Mac(rggwyip,rggwymac,NULL); /*gwy mac not specified, so get mac*/
+
+ /* Get the Alert Destination IP */
+ /* By default, attempt to obtain this from /etc/snmp/snmpd.conf. */
+ /* cat /etc/snmp/snmpd.conf | grep trapsink |tail -n1 | cut -f2 -d' ' */
+ alertname[0] = 0; /* default to null string */
+ fprt = fopen(snmpfile,"r");
+ if (fprt == NULL) {
+ printf("snmp: Cannot open %s, errno = %d\n",snmpfile,get_errno());
+ } else {
+ // char snmpfmt[] = "%20s %60s\n";
+ // char *keywd, *value;
+ while (fgets(buff, 1023, fprt)) {
+ /* parse each line */
+ if (buff[0] == '#') continue; /*skip comment lines*/
+ /* skip leading whitespace here */
+ j = strspn(&buff[0]," \t");
+ if (strncmp(&buff[j],"com2sec",7) == 0) { /* found community line */
+ /* usu like this: "com2sec demouser default public" */
+ i = j + 7;
+ for (j = 0; j < 3; j++) {
+ num = strspn(&buff[i]," \t");
+ i += num;
+ num = strcspn(&buff[i]," \t\r\n");
+ if (j < 2) i += num;
+ }
+ buff[i+num] = 0;
+ if (fsetcommunity == 0) { /* if not user-specified */
+ strcpy(rgcommunity,&buff[i]);
+ strcpy(defcommunity,&buff[i]);
+ }
+ }
+#ifdef BSD
+ if (strncmp(&buff[j],"traphost :=",11) == 0) nmatch = 11;
+ else nmatch = 0;
+#else
+ if (strncmp(&buff[j],"trapsink",8) == 0) nmatch = 8;
+ else if (strncmp(&buff[j],"trap2sink",9) == 0) nmatch = 9;
+ else nmatch = 0;
+#endif
+ if (nmatch > 0) { /* found trapsink line match */
+ if (fdebug) printf("%s: %s",snmpfile,&buff[j]);
+ num = strspn(&buff[j+nmatch]," \t");
+ i = j + nmatch + num;
+ if (buff[i] == '`') continue;
+ num = strcspn(&buff[i]," \t\r\n");
+ strncpy(alertname,&buff[i],num); /* save alert destination */
+ alertname[num] = 0;
+ i += num;
+ num = strspn(&buff[i]," \t"); /*skip whitespace*/
+ i += num;
+ num = strcspn(&buff[i]," \t\r\n"); /*span next word*/
+ if (num != 0) { /* there is another word, that is community */
+ if (fsetcommunity == 0) { /* if not user-specified */
+ strncpy(rgcommunity,&buff[i],num); /* save community */
+ rgcommunity[num] = 0;
+ }
+ } else { /*have trapsink node with no community*/
+ /* use previously discovered default community from above */
+ strcpy(rgcommunity,defcommunity);
+ }
+ /* dont break, keep looking, use the last one */
+ }
+ } /*end while*/
+ fclose(fprt);
+ if (fdebug)
+ printf("snmp alertname=%s community=%s\n",alertname,rgcommunity);
+ } /*end else snmpfile*/
+
+ /* Get the Alert Destination MAC from the alertname. */
+ if (alertname[0] != 0) {
+#ifdef TEST
+ char arping_cmd[128];
+ char *pb, *pm, *px;
+ int num, i;
+ if (fdebug) printf("alert %s ip=%d.%d.%d.%d osip=%d.%d.%d.%d "
+ "mac=%02x:%02x:%02x:%02x:%02x:%02x "
+ "osmac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ alertname,
+ rgdestip[0], rgdestip[1], rgdestip[2], rgdestip[3],
+ osmyip[0], osmyip[1], osmyip[2], osmyip[3],
+ rgdestmac[0], rgdestmac[1], rgdestmac[2], rgdestmac[3],
+ rgdestmac[4], rgdestmac[5],
+ osmymac[0], osmymac[1], osmymac[2], osmymac[3],
+ osmymac[4], osmymac[5]);
+#endif
+ if (!IpIsValid(rgdestip)) { /* if not user-specified with -A */
+ if (IpIsValid(bmcdestip)) { /* use existing if valid */
+ memcpy(rgdestip,bmcdestip,4);
+ if (MacIsValid(bmcdestmac))
+ memcpy(rgdestmac,bmcdestmac,MAC_LEN);
+ }
+ else if ((strncmp(alertname,"localhost",9) == 0) )
+ { /* snmpd.conf = localhost (self) is the SNMP alert destination */
+ if (IpIsValid(osmyip))
+ memcpy(rgdestip,osmyip,4);
+ if (!MacIsValid(rgdestmac)) { /* if not user-specified */
+ // Get_Mac(rgdestip,rgdestmac,alertname); (wont work for local)
+ memcpy(rgdestmac,osmymac,MAC_LEN);
+ }
+ } /*endif local */
+ }
+ if (!MacIsValid(rgdestmac)) /* if MAC not vaild or user-specified */
+ {
+ /* Use arping to get MAC from alertname or IP */
+ Get_Mac(rgdestip,rgdestmac,alertname);
+ }
+ } /*endif have alertname*/
+
+ return(rc);
+} /* end Get_IPMac_Addr */
+#endif
+
+int ShowChanAcc(uchar bchan)
+{
+ LAN_RECORD LanRecord;
+ int ret = 0;
+ uchar access;
+ char *pstr;
+ uchar pb0, pb1;
+
+ if (bchan == lan_ch) pstr = "lan";
+ else if (bchan == ser_ch) pstr = "ser";
+ else pstr = "?";
+ ret = GetChanAcc(bchan, 0x40, &LanRecord);
+ if (fdebug)
+ printf(" GetChanAcc(%d), ret = %d, data = %02x %02x\n",
+ bchan,ret, LanRecord.data[0], LanRecord.data[1]);
+ pb0 = LanRecord.data[0];
+ pb1 = LanRecord.data[1];
+ if (fcanonical)
+ printf("Channel %d Access Mode %s%c ",bchan,pspace3,bdelim);
+ else
+ printf("Channel(%d=%s) Access Mode: %02x %02x : ",bchan,pstr,pb0,pb1);
+ access = pb0;
+ switch (access & 0x03) {
+ case 0: printf("Disabled, "); break;
+ case 1: printf("Pre-Boot, "); break;
+ case 2: printf("Always Avail, "); break;
+ case 3: printf("Shared, "); break;
+ }
+ if (access & 0x20) printf("PEF Alerts Disabled\n"); /*0*/
+ else printf("PEF Alerts Enabled\n"); /*1*/
+ return(ret);
+}
+
+static int GetSessionInfo(uchar *rData, int sz)
+{
+ int rv, rlen;
+ uchar ccode;
+ uchar iData[5];
+
+ iData[0] = 0x00; /*get data for this session*/
+ rlen = sz;
+ rv = ipmi_cmdraw(CMD_GET_SESSION_INFO,NETFN_APP, BMC_SA,PUBLIC_BUS,BMC_LUN,
+ iData,1,rData, &rlen, &ccode, fdebug);
+ if ((rv == 0) && (ccode != 0)) rv = ccode;
+ return(rv);
+}
+
+static int GetPefCapabilities(uchar *bmax)
+{
+ int rv, rlen;
+ uchar ccode;
+ uchar rData[MAX_BUFFER_SIZE];
+
+ rlen = sizeof(rData);
+ rv = ipmi_cmdraw(0x10, NETFN_SEVT, BMC_SA,PUBLIC_BUS,BMC_LUN,
+ NULL,0,rData, &rlen, &ccode, fdebug);
+ if ((rv == 0) && (ccode != 0)) rv = ccode;
+ if ((rv == 0) && (bmax != NULL))
+ *bmax = rData[2]; /*max num PEF table entries*/
+ return(rv);
+}
+
+int GetSerialOverLan( uchar chan, uchar bset, uchar block )
+{
+ uchar requestData[24];
+ uchar rData[MAX_BUFFER_SIZE];
+ int rlen;
+ int status, i;
+ uchar ccode;
+ uchar enable_parm, auth_parm, baud_parm;
+ ushort getsolcmd;
+ uchar user;
+
+ if (fIPMI20 && fSOL20) {
+ getsolcmd = GET_SOL_CONFIG2;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ } else {
+ getsolcmd = GET_SOL_CONFIG;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ chan = 0; /*override chan for IPMI 1.5*/
+ }
+ if (!fcanonical)
+ printf("%s, GetSOL for channel %d ...\n",progname,chan);
+
+ requestData[0] = chan; /*channel*/
+ requestData[1] = enable_parm;
+ requestData[2] = bset; /*set*/
+ requestData[3] = block; /*block*/
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd, requestData,4, rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ if (ccode == 0xC1) { /* unsupported command */
+ printf("Serial-Over-Lan not available on this platform\n");
+ return(status);
+ } else {
+ printf("SOL Enable ccode = %x\n",ccode);
+ status = ccode;
+ }
+ } else { /*success*/
+ if (fcanonical) {
+ printf("Channel %d SOL Enable %s",chan,pspace3);
+ } else {
+ printf("SOL Enable: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ }
+ if (rData[1] == 0x01) printf("%c enabled\n",bdelim);
+ else printf("%c disabled\n",bdelim);
+ }
+
+ if (!fcanonical)
+ {
+ requestData[0] = chan;
+ requestData[1] = auth_parm;
+ requestData[2] = bset; // selector
+ requestData[3] = block; // block
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("SOL Auth ccode = %x\n",ccode);
+ status = ccode;
+ } else { /*success*/
+ printf("SOL Auth: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ printf(": ");
+ show_priv(rData[1]); /* priv level = User,Admin,... */
+ printf("\n");
+ }
+
+ requestData[0] = chan;
+ requestData[1] = SOL_ACC_INTERVAL_PARAM;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("SOL Accum Interval ccode = %x\n",ccode);
+ status = ccode;
+ } else { /*success*/
+ printf("SOL Accum Interval: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ printf(": %d msec\n",(rData[1] * 5));
+ }
+
+ requestData[0] = chan;
+ requestData[1] = SOL_RETRY_PARAM;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("SOL Retry ccode = %x\n",ccode);
+ status = ccode;
+ } else { /*success*/
+ printf("SOL Retry Interval: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ printf(": %d msec\n",(rData[2] * 10));
+ }
+ }
+
+ if (!fRomley)
+ {
+ requestData[0] = chan;
+ requestData[1] = baud_parm;
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData, &rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("SOL nvol Baud ccode = %x\n",ccode);
+ status = ccode;
+ } else { /*success*/
+ uchar b;
+ if (fcanonical) {
+ printf("Channel %d SOL Baud Rate%s",chan,pspace3);
+ } else {
+ printf("SOL nvol Baud Rate: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ }
+ /* if not user-specified and previously enabled, use existing */
+ b = (rData[1] & 0x0f);
+ if ((fnewbaud == 0) && BaudValid(b)) {
+ sol_baud = b;
+ sol_bvalid = 1;
+ }
+ printf("%c %s\n",bdelim,Baud2Str(b));
+ }
+
+ if (!fcanonical)
+ {
+ requestData[0] = chan;
+ requestData[1] = SOL_VOL_BAUD_RATE_PARAM; /*0x06*/
+ requestData[2] = bset;
+ requestData[3] = block;
+ rlen = sizeof(rData);
+ status = ipmi_cmd(getsolcmd,requestData,4,rData,&rlen,&ccode,fdebug);
+ if (status != 0) return(status);
+ if (ccode) {
+ printf("SOL vol Baud ccode = %x\n",ccode);
+ status = ccode;
+ } else { /*success*/
+ printf("SOL vol Baud Rate: ");
+ for (i = 1; i < rlen; i++) printf("%02x ",rData[i]);
+ printf("%c %s\n",bdelim,Baud2Str(rData[1]));
+ }
+ }
+ }
+ if (fIPMI20) {
+ if (vend_id != VENDOR_IBM) {
+ /* IBM 0x00DC returns invalid cmd for SOL Payload commands. */
+ if (!fcanonical) {
+ requestData[0] = chan;
+ rlen = sizeof(rData);
+ status = ipmi_cmdraw(GET_PAYLOAD_SUPPORT, NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ requestData,1,rData, &rlen, &ccode, fdebug);
+ if ((status != 0) || (ccode != 0)) {
+ printf("SOL Payload Support error %d, ccode = %x\n",status,ccode);
+ if (status == 0) status = ccode;
+ } else { /*success*/
+ printf("SOL Payload Support(%d): ",chan);
+ for (i = 0; i < rlen; i++) printf("%02x ",rData[i]);
+ printf("\n");
+ }
+ } /*endif not canonical*/
+ /* get Payload Access for 4 users, not just lan_user */
+ for (user = 1; user <= show_users; user++)
+ {
+ /* mBMC doesn't support more than 1 user */
+ if (fmBMC && (user > 1)) break;
+ /* IPMI 2.0 has >= 4 users */
+ requestData[0] = chan;
+ requestData[1] = user;
+ rlen = sizeof(rData);
+ status = ipmi_cmdraw(GET_PAYLOAD_ACCESS, NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ requestData,2,rData, &rlen, &ccode, fdebug);
+ if ((status != 0) || (ccode != 0)) {
+ printf("SOL Payload Access(%d,%d) error %d, ccode = %x\n",
+ chan,user,status,ccode);
+ if (status == 0) status = ccode;
+ } else { /*success*/
+ if (fcanonical) {
+ printf("Channel %d SOL Payload Access(user%d)%s",chan,user,
+ pspace1);
+ } else {
+ printf("SOL Payload Access(%d,%d): ",chan,user);
+ for (i = 0; i < rlen; i++) printf("%02x ",rData[i]);
+ }
+ if ((rData[0] & 0x02) != 0) printf("%c enabled\n",bdelim);
+ else printf("%c disabled\n",bdelim);
+ }
+ } /*end user loop*/
+ } /*endif not IBM*/
+ }
+
+ return(status);
+} /*end GetSerialOverLan */
+
+/*
+ECHO SOL Config Enable
+CMDTOOL 20 30 21 %1 01 01
+
+ECHO SOL Authentication (Administrator)
+CMDTOOL 20 30 21 %1 02 04
+
+ECHO SOL Accumlate Interval and threshold
+CMDTOOL 20 30 21 %1 03 06 14
+
+ECHO SOL Retry Interval and threshold
+CMDTOOL 20 30 21 %1 04 06 14
+
+ECHO SOL non-volatile baud rate
+CMDTOOL 20 30 21 %1 05 07
+
+ECHO SOL volatile baud rate
+CMDTOOL 20 30 21 %1 06 07
+
+ECHO Set user Payload Access for user 1
+CMDTOOL 20 18 4c %1 01 02 00 00 00
+ */
+int SetupSerialOverLan( int benable )
+{
+ uchar requestData[24];
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar completionCode;
+ uchar enable_parm, auth_parm, baud_parm;
+ ushort setsolcmd;
+ ushort getsolcmd;
+ uchar bchan, b;
+
+ if (fIPMI20 && fSOL20) {
+ setsolcmd = SET_SOL_CONFIG2;
+ getsolcmd = GET_SOL_CONFIG2;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ bchan = lan_ch;
+ } else {
+ setsolcmd = SET_SOL_CONFIG;
+ getsolcmd = GET_SOL_CONFIG;
+ enable_parm = SOL_ENABLE_PARAM;
+ auth_parm = SOL_AUTHENTICATION_PARAM;
+ baud_parm = SOL_BAUD_RATE_PARAM;
+ bchan = 0x00; /*override chan for IPMI 1.5*/
+ }
+ memset(requestData, 0, sizeof(requestData)); /* zero-fill */
+ requestData[0] = bchan;
+ requestData[1] = enable_parm;
+ if (benable == 0)
+ requestData[2] = SOL_DISABLE_FLAG;
+ else
+ requestData[2] = SOL_ENABLE_FLAG;
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(setsolcmd, requestData,3,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == ACCESS_OK) {
+ switch( completionCode ) {
+ case 0x00: /* success */
+ break;
+ case 0xC1: /* unsupported command */
+ SELprintf("SetupSerialOverLan: SOL not available on this platform\n");
+ return 0;
+ default: /* other error */
+ SELprintf("SetupSerialOverLan: SOL_ENABLE_PARAM ccode=%x\n",
+ completionCode);
+ return -1;
+ break;
+ }
+ } else {
+ SELprintf( "SET_SOL_CONFIG, enable SOL failed\n" );
+ return -1;
+ }
+ if (benable == 0) return 0;
+
+ requestData[0] = bchan; /* channel */
+ requestData[1] = auth_parm;
+ requestData[2] = 0x00; /* set selector */
+ requestData[3] = 0x00; /* block selector */
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(getsolcmd, requestData,4,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SetupSerialOverLan: GET_SOL_AUTHENTICATION_PARAM code=%x\n",
+ completionCode);
+
+ return -1;
+ }
+ } else {
+ SELprintf( "SOL_CONFIG, get SOL authentication failed\n" );
+ return -1;
+ }
+
+ if ((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) b = SOL_PRIVILEGE_LEVEL_OPERATOR;
+ else b = SOL_PRIVILEGE_LEVEL_USER;
+ requestData[0] = bchan;
+ requestData[1] = auth_parm;
+ requestData[2] = b | ( responseData[1] & 0x80 ); /* priv | enable */
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd(setsolcmd, requestData,3,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SET_SOL_AUTHENTICATION_PARAM code=%x\n",
+ completionCode);
+
+ return -1;
+ }
+ } else {
+ SELprintf( "SET_SOL_CONFIG, set SOL authentication failed\n" );
+ return -1;
+ }
+
+ requestData[0] = bchan;
+ requestData[1] = SOL_ACC_INTERVAL_PARAM;
+ requestData[2] = sol_accum[0]; //0x04;
+ requestData[3] = sol_accum[1]; //0x32;
+ responseLength = MAX_BUFFER_SIZE;
+ if (fdebug) SELprintf("Setting SOL AccumInterval\n");
+ status = ipmi_cmd(setsolcmd, requestData,4,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != ACCESS_OK || completionCode) {
+ SELprintf("SET SOL AccumInterval ret=%d ccode=%x\n",
+ status,completionCode);
+ return -1;
+ }
+
+ /* Some BMCs return sporadic errors for SOL params (e.g. Kontron)*/
+ // if (vend_id == VENDOR_KONTRON) ;
+ // else
+ {
+ requestData[0] = bchan;
+ requestData[1] = SOL_RETRY_PARAM;
+ requestData[2] = sol_retry[0]; //0x06;
+ requestData[3] = sol_retry[1]; //0x14;
+ responseLength = MAX_BUFFER_SIZE;
+ if (fdebug) SELprintf("Setting SOL RetryInterval\n");
+ status = ipmi_cmd(setsolcmd, requestData,4,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != ACCESS_OK || completionCode) {
+ SELprintf("SET SOL RetryInterval ret=%d ccode=%x\n",
+ status,completionCode);
+ return -1;
+ }
+ }
+
+ if (fRomley) ; /* skip SOL BAUD */
+ else { /* else SOL BAUD is used, so set it. */
+ if (fnewbaud == 0) { /* no user-specified SOL baud */
+ /* if sol_bvalid, sol_baud was set to existing value above */
+ if (!sol_bvalid) {
+ status = GetSerEntry(7, (LAN_RECORD *)&responseData);
+ if (status == 0) { /* use Serial baud for SOL */
+ sol_baud = responseData[1];
+ if (fdebug) SELprintf("Serial Baud is %s\n",Baud2Str(sol_baud));
+ }
+ }
+ }
+ requestData[0] = bchan;
+ requestData[1] = baud_parm;
+ requestData[2] = sol_baud;
+ responseLength = MAX_BUFFER_SIZE;
+ if (fdebug) SELprintf("Setting SOL BAUD to %s\n",Baud2Str(sol_baud));
+ status = ipmi_cmd(setsolcmd, requestData,3,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != ACCESS_OK || completionCode) {
+ SELprintf("SET SOL BAUD ret=%d ccode=%x\n", status,completionCode);
+ return -1;
+ }
+
+ requestData[0] = bchan;
+ requestData[1] = SOL_VOL_BAUD_RATE_PARAM;
+ requestData[2] = sol_baud;
+ responseLength = MAX_BUFFER_SIZE;
+ if (fdebug)
+ printf("Setting SOL vol BAUD to %s\n",Baud2Str(sol_baud));
+ status = ipmi_cmd(setsolcmd, requestData,3,responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status != ACCESS_OK || completionCode) {
+ printf("SET SOL vol BAUD ret=%d ccode=%x\n",status,completionCode);
+ return -1;
+ }
+ }
+
+ if (fIPMI20 && fSOL20) {
+ if (vend_id == VENDOR_KONTRON && lan_user == 1) {
+ if (fdebug) SELprintf("Skipping SOL Payload Access for user %d\n",
+ lan_user);
+ } else if (vend_id == VENDOR_IBM) { /*non-conformance*/
+ if (fdebug) SELprintf("Skipping SOL Payload Access for user %d\n",
+ lan_user);
+ } else {
+ if (fdebug) SELprintf("Setting SOL Payload Access for user %d\n",
+ lan_user);
+ requestData[0] = bchan;
+ requestData[1] = lan_user; /*enable this user*/
+ requestData[2] = 0x02; /*enable std 2.0 SOL*/
+ requestData[3] = 0;
+ requestData[4] = 0;
+ requestData[5] = 0;
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmdraw(SET_PAYLOAD_ACCESS, NETFN_APP,
+ BMC_SA,PUBLIC_BUS,BMC_LUN,
+ requestData,6,responseData, &responseLength,
+ &completionCode, fdebug);
+ if (status != ACCESS_OK || completionCode) {
+ SELprintf("SET SOL Payload Access ret=%d ccode=%x\n",
+ status,completionCode);
+ return -1;
+ }
+ }
+ }
+ return 0;
+} /*end SetupSerialOverLan */
+
+static char *PefDesc(int idx, uchar stype)
+{
+ char *pdesc, *p;
+ static char mystr[60];
+ int mylen = sizeof(mystr);
+ pdesc = &mystr[0];
+ if (pefdesc != NULL) strcpy(pdesc,pefdesc[idx]); /* if Intel, pre-defined */
+ else strcpy(pdesc,"reserved"); /* else set default to detect */
+ if ((stype != 0) && (strcmp(pdesc,"reserved") == 0)) {
+ /* Dynamically set the pef desc string from the sensor type */
+ switch(stype) {
+ case 0x01: strcpy(pdesc,"Temperature"); break;
+ case 0x02: strcpy(pdesc,"Voltage"); break;
+ case 0x04: strcpy(pdesc,"Fan"); break;
+ case 0x05: strcpy(pdesc,"Chassis"); break;
+ case 0x07: strcpy(pdesc,"BIOS"); break;
+ case 0x08: strcpy(pdesc,"Power Supply"); break;
+ case 0x09: strcpy(pdesc,"Power Unit"); break;
+ case 0x0c: strcpy(pdesc,"Memory"); break;
+ case 0x0f: strcpy(pdesc,"Boot"); break;
+ case 0x12: strcpy(pdesc,"System Restart"); break;
+ case 0x13: strcpy(pdesc,"NMI"); break;
+ case 0x23: strcpy(pdesc,"Watchdog"); break;
+ case 0x20: strcpy(pdesc,"OS Critical Stop"); break;
+ default:
+#ifdef METACOMMAND
+ p = get_sensor_type_desc(stype);
+ if (p != NULL) {
+ strncpy(pdesc,p,mylen);
+ mystr[mylen-1] = 0; /*stringify*/
+ }
+#else
+ sprintf(pdesc,"Other[%02x]",stype);
+#endif
+ break;
+ }
+ if (pef_array[idx-1][4] == PEF_SEV_OK) strcat(pdesc," OK");
+ }
+ return(pdesc);
+}
+
+
+#ifdef METACOMMAND
+int i_lan(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret;
+ PEF_RECORD PefRecord;
+ LAN_RECORD LanRecord;
+ int i, idx, j;
+ int c;
+ char *pstr;
+ uchar bset;
+ int ndest = 4;
+ int idest;
+ int nciphers = 16;
+ char mystr[80];
+ char fpefok = 1;
+ uchar * pc; int sz;
+
+ // progname = argv[0];
+ printf("%s ver %s \n",progname,progver);
+ j = 0; freadonly = FLAG_INIT;
+ idx = argc; /*getopt loop counter*/
+ /* available opt chars: y O Q + = ~ _ */
+ while ((c = getopt(argc, argv,"a:b:cdef:gh:i:j:klm:n:op:q:rstu:v:w:xy:z#::A:B:C:DEF:G:H:I:J:K:L:M:N:P:Q:R:S:T:U:V:X:YZ:?")) != EOF) {
+ switch(c) {
+ case 'a': /* alert dest number (usu 1 thru 4) */
+ alertnum = atob(optarg);
+ if (alertnum > alertmax) alertnum = 1;
+ j++;
+ break;
+ case 'b': bAuth = htoi(optarg); j++; break; /*undocumented*/
+ case 'c': fcanonical = 1; bdelim = BDELIM; break;
+ case 'd': fenable = 0; fdisable = 1; freadonly = 0; break;
+ case 'e': fenable = 1; fdisable = 0; freadonly = 0; break;
+ case 'f': i = atoi(optarg); /*set arp_ctl*/
+ if (i < 0 || i > 3) printf("Invalid ARP control %d\n",i);
+ else {
+ arp_ctl = i;
+ fsetarp = 1;
+ j++;
+ }
+ break;
+ case 'l': fpefenable = 0; fenable = 2;
+ fdisable = 0; freadonly = 0; break;
+ case 'h': /* VLAN ID */
+ i = atoi(optarg);
+ if (i > 4095) vlan_enable = 0;
+ else {
+ vlan_enable = 1;
+ vlan_id = (ushort)i;
+ }
+ j++;
+ break;
+ case 'y': /* OEM LAN Failover enable/disable */
+ i = atoi(optarg);
+ if (i < 0) printf("Failover(-y) parameter is negative\n");
+ else failover_enable = i;
+ j++;
+ break;
+ case 'Q': /* VLAN Priority */
+ i = atoi(optarg);
+ if (i > 7 || i < 0) vlan_enable = 0;
+ else {
+ vlan_enable = 1;
+ vlan_prio = (uchar)i;
+ }
+ j++;
+ break;
+ case 'i': /* eth interface (ifname) */
+ fsetifn = 1;
+ i = sizeof(ifname);
+ if (strlen(optarg) > (uint)i) optarg[i] = 0;
+ strcpy(ifname,optarg);
+ if (fdebug) printf("ifname = %s\n",ifname);
+ j++;
+ break;
+ case 'j': fCustomPEF = 1; /*custom 10 PEF bytes */
+ fpefenable = 1; /* PEF is implied here */
+ freadonly = 0;
+ memset(custPEF,0,sizeof(custPEF));
+ custPEF[0] = htoi(&optarg[0]); /*action */
+ custPEF[1] = htoi(&optarg[2]); /*policy */
+ custPEF[2] = htoi(&optarg[4]); /*severity*/
+ custPEF[3] = htoi(&optarg[6]); /*genid1 */
+ custPEF[4] = htoi(&optarg[8]); /*genid2 */
+ custPEF[5] = htoi(&optarg[10]); /*sensor_type*/
+ custPEF[6] = htoi(&optarg[12]); /*sensor_num */
+ custPEF[7] = htoi(&optarg[14]); /*evt_trigger*/
+ custPEF[8] = htoi(&optarg[16]); /*data1offset*/
+ custPEF[9] = htoi(&optarg[18]); /*data1mask */
+ if (optarg[20] != 0) {
+ /* optionally get 8 extra PEF entry bytes */
+ custPEF[10] = htoi(&optarg[20]); /*data1cmp1 */
+ custPEF[11] = htoi(&optarg[22]); /*data1cmp2 */
+ custPEF[12] = htoi(&optarg[24]); /*data2mask */
+ custPEF[13] = htoi(&optarg[26]); /*data2cmp1 */
+ custPEF[14] = htoi(&optarg[28]); /*data2cmp2 */
+ custPEF[15] = htoi(&optarg[30]); /*data3mask */
+ custPEF[16] = htoi(&optarg[32]); /*data3cmp1 */
+ custPEF[17] = htoi(&optarg[34]); /*data3cmp2 */
+ }
+ j++;
+ break;
+ case 'k': fSetPEFOks = 1; j++; break; /*configure PEF OK rules */
+ case 'm': set_max_kcs_loops(atoi(optarg)); break;
+ case 'n': /* number/index in PEF table to insert new entry */
+ fpefenable = 1;
+ pefnum = atob(optarg);
+ if (pefnum >= MAXPEF) {
+ pefnum = MAXPEF - 1;
+ fAdjustPefNum = 1;
+ } else fUserPefNum = 1;
+ j++;
+ break;
+ case 'o': fdisableSOL = 1; /*disable SOL only*/
+ fpefenable = 0; /*no change to PEF*/
+ freadonly = 0;
+ break;
+ case 'r': freadonly = 1; fenable = 0; break;
+ case 's': fgetser = 1; break;
+ case 't': ftestonly = 1; freadonly = 1; break;
+ case 'v': /* user access privilege level */
+ i = atoi(optarg);
+ if (valid_priv(i)) lan_access = i & 0x0f;
+ else printf("Invalid privilege -v %d, using Admin\n",i);
+ j++;
+ break;
+ case 'w': i = atoi(optarg); /*set grat arp interval, in #sec*/
+ if (i >= 0 && i < 256) arp_interval = i * 2;
+ else printf("Invalid arp interval -w %d, skipping\n",i);
+ break;
+ case 'x': fdebug = 1; break;
+ case 'z': flanstats = 1; break;
+ case 'D': lan_dhcp = 1; j++; break;
+ case 'I': /* My BMC IP Address */
+ fset_ip |= MYIP;
+ atoip(rgmyip,optarg);
+ j++;
+ break;
+ case 'M': /* My BMC MAC Address */
+ atomac(rgmymac,optarg);
+ if (!MacIsValid(rgmymac)) printf("Invalid MAC for -M\n");
+ j++;
+ break;
+ case 'S': /* Subnet IP Address */
+ atoip(rgsubnet,optarg);
+ j++;
+ break;
+ case 'G': /* Gateway IP Address */
+ fset_ip |= GWYIP;
+ atoip(rggwyip,optarg);
+ j++;
+ break;
+ case 'g': /* Secondary Gateway IP Address */
+ fset_ip |= GWYIP;
+ atoip(rggwy2ip,optarg);
+ j++;
+ break;
+ case 'H': /* Gateway MAC Address */
+ atomac(rggwymac,optarg);
+ if (!MacIsValid(rggwymac)) printf("Invalid MAC for -H\n");
+ j++;
+ break;
+ case 'B': /* SOL Baud rate */
+ fnewbaud = 1;
+ sol_baud = Str2Baud(optarg);
+ j++;
+ break;
+ case 'A': /* Alert Dest IP Address */
+ fset_ip |= DESTIP;
+ /* allow name or ip here via Get_Mac() ? */
+ atoip(rgdestip,optarg);
+ fpefenable = 1; /* PEF is implied here */
+ j++;
+ break;
+ case 'X': /* Alert Dest MAC Address */
+ atomac(rgdestmac,optarg);
+ if (!MacIsValid(rgdestmac)) printf("Invalid MAC for -X\n");
+ fpefenable = 1; /* PEF is implied here */
+ j++;
+ break;
+ case 'K': /* Kontron IPMI hostname */
+ i = sizeof(rghostname); /*usu 18*/
+ if (strlen(optarg) > (uint)i) optarg[i] = 0;
+ strcpy(rghostname,optarg);
+ j++;
+ break;
+ case 'C': /* Community String */
+ fsetcommunity = 1;
+ i = sizeof(rgcommunity); /*usu 18*/
+ if (strlen(optarg) > (uint)i) optarg[i] = 0;
+ strcpy(rgcommunity,optarg);
+ fpefenable = 1; /* PEF is implied here */
+ j++;
+ break;
+ case 'u': /* username to set */
+ myuser = strdup_(optarg); /*remote username */
+ j++;
+ break;
+ case 'p': /* password to set */
+ fpassword = 1;
+ if (strlen(optarg) > PSW_MAX) optarg[PSW_MAX] = 0;
+ strcpy(passwordData,optarg);
+ if (fdebug) printf("Password = %s\n",passwordData);
+ /* Hide password from 'ps' */
+ memset(optarg, ' ', strlen(optarg));
+ j++;
+ break;
+ case 'q':
+ case '#':
+ usernum = atob(optarg);
+ if (usernum > 15) usernum = 0; /*MAX_IPMI_USERS = 15*/
+ j++;
+ break;
+ case 'L':
+ if (strcmp(optarg,"list") == 0) fshowchan = 1;
+ lan_ch_parm = atob(optarg);
+ if (lan_ch_parm > MAXCHAN) lan_ch_parm = PARM_INIT; /*invalid*/
+ break;
+ case 'V': /* priv level */
+ fprivset = 1;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-abcdefghijklmnopq#rstuvwxyzBDQK]\n",progname);
+ printf(" \t [-a alertnum -i eth1 -n pefnum ]\n");
+ printf(" \t [-I ipadr -M macadr -S subnet ]\n");
+ printf(" \t [-G gwyip -H gwymac -L lan_channel_num]\n");
+ printf(" \t [-A alertip -X alertmac -C community ]\n");
+ printf(" \t [-g 2nd_gwyip -v priv -B sol_baud ]\n");
+ printf(" \t [-j 10_bytes_custom_pef -b authmask ]\n");
+ printf("where -c shows Canonical, simpler output format\n");
+ printf(" -d Disables BMC LAN & PEF\n");
+ printf(" -e Enables BMC LAN & PEF\n");
+ printf(" -f set ARP Control to 1=grat, 2=resp, 3=both\n");
+ printf(" -g secondary Gateway IP (-G=primary_gwy_ip)\n");
+ printf(" -h VLAN ID (>=4096 to disable)\n");
+ printf(" -j specify custom PEF rule (10 or 18 hex bytes)\n");
+ printf(" -k add PEF oK rules, if PEF enable\n");
+ printf(" -l Enables BMC LAN only, not PEF\n");
+ printf(" -o disable Only SOL\n");
+ printf(" -p password to set \n");
+ printf(" -q/-# User number of LAN username_to_set\n");
+ printf(" -r Read-only BMC LAN & PEF settings\n");
+ printf(" -s Show some Serial settings also \n");
+ printf(" -t Test if BMC LAN is already configured\n");
+ printf(" -u username to set \n");
+ printf(" -v access priVilege: 4=Admin,3=Operator,2=User\n");
+ printf(" -w set Grat ARP Interval to specified # seconds\n");
+ printf(" -x Show eXtra debug messages\n");
+ printf(" -y OEM LAN Failover (1=enable,0=disable if Intel)\n");
+ printf(" -z Show IPMI LAN statistics\n");
+ printf(" -B Baud for SerialOverLan (19.2K,115.2K,...)\n");
+ printf(" -D Use DHCP instead of static IP (-I for server)\n");
+ printf(" -K (Kontron) IPMI hostname to set\n");
+ printf(" -Q VLAN Priority (default =0)\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ } /*end switch*/
+ nopts++;
+ } /*end while*/
+
+ if ((freadonly == FLAG_INIT) && (j > 0)) {
+ /* got some options implying set, but no -e -l -d option specified. */
+ foptmsg = 1; /*show warning message later*/
+ freadonly = 1; /*assume read only*/
+ }
+ fipmilan = is_remote();
+ if (fipmilan && !fprivset)
+ parse_lan_options('V',"4",0); /*even if freadonly request admin*/
+ if ((fsetarp == 0) && ostype == OS_WINDOWS)
+ arp_ctl = 0x03; /*grat arp & arp resp enabled */
+
+ ret = GetDeviceID( &LanRecord);
+ if (ret != 0) {
+ goto do_exit;
+ } else { /* success */
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = LanRecord.data[4] & 0x0f;
+ ipmi_min = LanRecord.data[4] >> 4;
+ show_devid( LanRecord.data[2], LanRecord.data[3], ipmi_maj, ipmi_min);
+ if (ipmi_maj == 0) fIPMI10 = 1;
+ else if (ipmi_maj == 1 && ipmi_min < 5) fIPMI10 = 1;
+ else fIPMI10 = 0; /* >= IPMI 1.5 is ok */
+ if (ipmi_maj >= 2) fIPMI20 = 1;
+ if (fIPMI20) show_users = 5;
+ else show_users = 3;
+ if (fIPMI10) {
+ printf("This IPMI v%d.%d system does not support PEF records.\n",
+ ipmi_maj,ipmi_min);
+ /* Wont handle PEF, but continue and look for BMC LAN anyway */
+ // fIPMI10 = 1;
+ // ipmi_close_();
+ // exit(1);
+ }
+ prod_id = LanRecord.data[9] + (LanRecord.data[10] << 8);
+ vend_id = LanRecord.data[6] + (LanRecord.data[7] << 8)
+ + (LanRecord.data[8] << 16);
+ /* check Device ID response for Manufacturer ID = 0x0322 (NSC) */
+ if (vend_id == VENDOR_NSC) { /* NSC = 0x000322 */
+ fmBMC = 1; /*NSC miniBMC*/
+ if (pefnum == 12) pefnum = 10; /* change CritStop pefnum to 0x0a */
+ pefdesc = &pefdesc2[0]; /*mini-BMC PEF*/
+ pefmax = 30;
+ fsharedMAC = 1; /* shared MAC with OS */
+ } else if (vend_id == VENDOR_LMC) { /* LMC (on SuperMicro) = 0x000878 */
+ pefdesc = NULL; /* unknown, see PefDesc() */
+ if (pefnum == 12) pefnum = 15; /* change CritStop pefnum */
+ pefmax = 16;
+ fsharedMAC = 0; /* not-shared BMC LAN port */
+ } else if (vend_id == VENDOR_INTEL) { /* Intel = 0x000157 */
+ pefdesc = &pefdesc1[0]; /*default Intel PEF*/
+ pefmax = 20; /*default Intel PEF*/
+ switch(prod_id) {
+ case 0x4311: /* Intel NSI2U w SE7520JR23 */
+ fmBMC = 1; /* Intel miniBMC*/
+ if (pefnum == 12) pefnum = 14; /* change CritStop pefnum */
+ pefdesc = &pefdesc2[0]; /*mini-BMC PEF*/
+ pefmax = 30;
+ fsharedMAC = 1; /* shared-MAC BMC LAN port, same MAC */
+ break;
+ case 0x0022: /* Intel TIGI2U w SE7520JR23 +IMM*/
+ fsharedMAC = 1; /* shared-MAC BMC LAN port, same MAC */
+ gcm_ch = 3; /* IMM GCM port, dedicated MAC */
+ show_users = 4;
+ break;
+ case 0x000C: /*TSRLT2*/
+ case 0x001B: /*TIGPR2U*/
+ /* fmBMC=0; Intel Sahalee BMC*/
+ fsharedMAC = 1; /* shared-MAC BMC LAN port, same MAC */
+ break;
+ case 0x0026: /*S5000 Bridgeport*/
+ case 0x0028: /*S5000PAL Alcolu*/
+ case 0x0029: /*S5000PSL StarLake*/
+ case 0x0811: /*S5000PHB TIGW1U */
+ /* fmBMC=0; Intel Sahalee ESB2 BMC*/
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ gcm_ch = 3;
+ parm7 = &iparm7[0]; /*TTL=30*/
+ break;
+ case 0x003E: /*NSN2U or CG2100 Urbanna*/
+ fiBMC = 1; /* Intel iBMC */
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ // gcm_ch = 3;
+ parm7 = &iparm7[0]; /*TTL=30*/
+ if (fsetarp == 0)
+ arp_ctl = 0x02; /*grat arp disabled, arp resp enabled */
+ arp_interval = 0x00; /*0 sec, since grat arp disabled */
+ sol_accum[0] = 0x0c; /*Intel defaults*/
+ sol_accum[1] = 0x60; /*Intel defaults*/
+ sol_retry[0] = 0x07; /*Intel defaults*/
+ sol_retry[1] = 0x32; /*Intel defaults*/
+ set_max_kcs_loops(URNLOOPS); /*longer for SetLan cmds (default 300)*/
+ break;
+ case 0x0107: /* Intel Caneland*/
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ gcm_ch = 3;
+ break;
+ case 0x0100: /*Tiger2 ia64*/
+ /* for ia64 set chan_pefon, chan_pefoff accordingly*/
+ chan_pefon = CHAN_ACC_PEFON64;
+ chan_pefoff = CHAN_ACC_PEFOFF64;
+ /* fall through */
+ default: /* else other Intel */
+ /* fmBMC = 0; * Intel Sahalee BMC*/
+ if (fIPMI20) fsharedMAC = 0; /* recent, not-shared BMC MAC */
+ else fsharedMAC = 1; /* usu IPMI 1.x has shared BMC MAC */
+ break;
+ } /*end switch*/
+ if (is_romley(vend_id,prod_id)) {
+ fRomley = 1;
+ fiBMC = 1; /* Intel iBMC */
+ fsharedMAC = 0; /* not-shared BMC LAN port, separate MAC */
+ set_max_kcs_loops(URNLOOPS); /*longer for SetLan (default 300)*/
+ fipv6 = 1;
+ if (fsetarp == 0) arp_ctl = 0x03; /*default to both for Romley*/
+ }
+ } else { /* else other vendors */
+ if (fIPMI20) fsharedMAC = 0; /* recent, not-shared BMC MAC */
+ else fsharedMAC = 1; /* usu IPMI 1.x has shared BMC MAC */
+ pefdesc = NULL; /* unknown, see PefDesc() */
+ if (pefnum == 12) pefnum = 15; /* change CritStop pefnum to 15? */
+ pefmax = 20;
+ if (!fUserPefNum) fAdjustPefNum = 1;
+ }
+ if (fmBMC) show_users = 1; /* mBMC doesn't support more than 1 user */
+ }
+
+ if (fshowchan) {
+ ret = show_channels();
+ exit(ret);
+ }
+
+ ret = GetPefCapabilities(&bset);
+ if ((ret == 0) && (bset <= MAXPEF)) pefmax = bset;
+
+ /* Get the BMC LAN channel & match it to an OS eth if. */
+ i = GetBmcEthDevice(lan_ch_parm);
+ if (i == -2) { /* no lan channels found (see lan_ch) */
+ if (lan_ch_parm == PARM_INIT)
+ printf("This system does not support IPMI LAN channels.\n");
+ else /*specified a LAN channel*/
+ printf("BMC channel %d does not support IPMI LAN.\n",lan_ch_parm);
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+ } else if (i < 0) { /* mac not found, use platform defaults */
+ i = 0; /* default to eth0, lan_ch set already. */
+ if (vend_id == VENDOR_INTEL) {
+ if ((prod_id == 0x001B) || (prod_id == 0x000c)) {
+ /* Intel TIGPR2U or TSRLT2 defaults are special */
+ if (lan_ch_parm == 6)
+ { i = 0; lan_ch = 6; }
+ else { i = 1; lan_ch = 7; }
+ ser_ch = 1;
+ }
+ }
+ }
+ if ((i == gcm_ch) && (gcm_ch != PARM_INIT) && (lan_ch_parm == PARM_INIT)) {
+ /* Has a GCM, defaulted to it, and user didn't specify -L */
+ /* Need this to avoid picking channel 3, the IMM/RMM GCM channel. */
+ lan_ch = 1; /*default BMC LAN channel*/
+ // i = 0; /*default eth0 (was eth1) */
+ }
+ if (fsetifn == 0) { /*not user specified, use the detected one*/
+ // if (lan_ch == gcm_ch) strcpy(ifname,"gcm");
+ sprintf(ifname,"%s%d",ifpattn,i); /*eth%d*/
+ }
+ if (fdebug) printf("lan_ch = %d, ifname = %s\n",lan_ch,ifname);
+
+ /* set the lan_user appropriately */
+ if (myuser == NULL) { /* if no -u param */
+ if (ipmi_reserved_user(vend_id, 1)) lan_user = 2;
+ else lan_user = 1; /*use default null user */
+ } else if (usernum != 0) lan_user = usernum; /*use -q specified usernum*/
+ /* else use default lan_user (=2) if -u and not -q */
+
+ if (ftestonly) { /*test only if BMC LAN is configured or not */
+ /* TODO: test gcm also, if present */
+ ret = GetLanEntry(4, 0, &LanRecord); /*ip addr src*/
+ if (ret == 0) {
+ if ((LanRecord.data[0] == SRC_BIOS) ||
+ (LanRecord.data[0] == SRC_DHCP)) ret = 0; /* DHCP, so ok */
+ else { /*static IP*/
+ ret = GetLanEntry(3, 0, &LanRecord); /* ip address */
+ if (ret == 0) {
+ if (!IpIsValid(LanRecord.data)) {
+ printf("invalid BMC IP address\n");
+ ret = 1; /* invalid ip */
+ } else ret = GetLanEntry(12, 0, &LanRecord); /*gateway ip*/
+ if (ret == 0) {
+ if (!IpIsValid(LanRecord.data)) {
+ printf("invalid gateway ip\n");
+ ret = 2; /*invalid gwy ip*/
+ } else ret = GetLanEntry(13, 0, &LanRecord);
+ if (ret == 0) {
+ if (!MacIsValid(&LanRecord.data[0])) {
+ printf("invalid gateway mac\n");
+ ret = 3; /*invalid gwy mac */
+ }
+ }
+ }
+ }
+ }
+ } /*endif GetLanEntry ok*/
+ if (ret == 0) printf("BMC LAN already configured\n");
+ else printf("BMC LAN not configured\n");
+ goto do_exit;
+ } /*endif ftestonly*/
+
+ memset(SessInfo,0,sizeof(SessInfo));
+ ret = GetSessionInfo(SessInfo,sizeof(SessInfo));
+ // rlen = sizeof(SessInfo)); ret = get_session_info(0,0,SessInfo,&rlen);
+ if (fdebug) printf("GetSessionInfo ret=%d, data: %02x %02x %02x %02x \n",
+ ret,SessInfo[0],SessInfo[1],SessInfo[2],SessInfo[3]);
+ if (!freadonly && fipmilan) { /* setting LAN params, and using IPMI LAN */
+ if (SessInfo[2] > 1) { /* another session is active also */
+ printf("Another session is also active, cannot change IPMI LAN settings now.\n");
+ ret = ERR_NOT_ALLOWED;
+ goto do_exit;
+ }
+ }
+
+ if (!fIPMI10) {
+ if (fcanonical)
+ { /* canonical/simple output */
+ ret = GetPefEntry(0x01, 0,(PEF_RECORD *)&LanRecord);
+ if (ret != 0) ndest = 0;
+ else { /*success*/
+ j = LanRecord.data[0];
+ mystr[0] = 0;
+ if (j == 0) strcat(mystr,"none ");
+ else {
+ if (j & 0x01) strcat(mystr,"PEFenable ");
+ if (j & 0x02) strcat(mystr,"DoEventMsgs ");
+ if (j & 0x04) strcat(mystr,"Delay ");
+ if (j & 0x08) strcat(mystr,"AlertDelay ");
+ }
+ printf("PEF Control %s%c %s\n",pspace4,bdelim,mystr);
+ }
+ } else { /* normal/full output */
+ ret = GetPefEntry(0x01, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0 && (LanRecord.data[0] != 0)) {
+ fpefok = 1;
+ bmcpefctl = LanRecord.data[0];
+ } else { /* skip PEF rules/params if disabled */
+ printf("PEF Control %s%c %s\n",pspace4,bdelim,"none ");
+ ndest = 0;
+ fpefok = 0;
+ }
+
+ if (fpefok) {
+ printf("%s, GetPefEntry ...\n",progname);
+ for (idx = 1; idx <= pefmax; idx++)
+ {
+ ret = GetPefEntry( 0x06, (ushort)idx, &PefRecord);
+ if (ret == 0) { // Show the PEF record
+ char *pa;
+ pc = (uchar *)&PefRecord;
+ sz = 21; // sizeof(PEF_RECORD) = 21
+ if (PefRecord.sensor_type == 0) {
+ if (idx <= pefnum)
+ printf("PEFilter(%02d): empty\n",idx);
+ memcpy(pef_array[idx-1], &PefRecord, sz);
+ if (fAdjustPefNum) pefnum = (char)idx;
+ } else {
+ memcpy(pef_array[idx-1], &PefRecord, sz);
+ if (PefRecord.fconfig & 0x80) pc = "enabled";
+ else pc = "disabled";
+ i = PefRecord.rec_id;
+ switch(PefRecord.action) {
+ case 0x01: pa = "alert"; break;
+ case 0x02: pa = "poweroff"; break;
+ case 0x04: pa = "reset"; break;
+ case 0x08: pa = "powercycle"; break;
+ case 0x10: pa = "OEMaction"; break;
+ case 0x20: pa = "NMI"; break;
+ default: pa = "no action";
+ }
+ printf("PEFilter(%02d): %02x %s event - %s for %s\n",
+ idx, PefRecord.sensor_type,
+ PefDesc(i,PefRecord.sensor_type), pc,pa);
+ }
+ if (fdebug) { /* show raw PEFilter record */
+ pc = &PefRecord.rec_id;
+ printf("raw PEF(%.2d): ",pc[0]);
+ for (i = 0; i < sz; i++) printf("%02x ",pc[i]);
+ printf("\n");
+ }
+ } else {
+ printf("GetPefEntry(%d), ret = %d\n",idx,ret);
+ if (ret == 0xC1) { /*PEF is not supported, so skip the rest. */
+ fpefok = 0;
+ ndest = 0; /* if no PEF, no alerts & no alert dest */
+ break;
+ }
+ }
+ }
+ } /*endif fpefok*/
+ if (fpefok) {
+ if (fdebug) ShowPef();
+ ret = GetPefEntry(0x01, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ j = LanRecord.data[0];
+ mystr[0] = 0;
+ if (j & 0x01) strcat(mystr,"PEFenable ");
+ if (j & 0x02) strcat(mystr,"DoEventMsgs ");
+ if (j & 0x04) strcat(mystr,"Delay ");
+ if (j & 0x08) strcat(mystr,"AlertDelay ");
+ printf("PEF Control: %02x : %s\n",j, mystr);
+ }
+ ret = GetPefEntry(0x02, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ j = LanRecord.data[0];
+ mystr[0] = 0;
+ if (j & 0x01) strcat(mystr,"Alert ");
+ if (j & 0x02) strcat(mystr,"PwrDn ");
+ if (j & 0x04) strcat(mystr,"Reset ");
+ if (j & 0x08) strcat(mystr,"PwrCyc ");
+ if (j & 0x10) strcat(mystr,"OEM ");
+ if (j & 0x20) strcat(mystr,"DiagInt ");
+ printf("PEF Actions: %02x : %s\n",j, mystr);
+ }
+ ret = GetPefEntry(0x03, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) printf("PEF Startup Delay: %02x : %d sec\n",
+ LanRecord.data[0],LanRecord.data[0]);
+ if (!fmBMC) {
+ ret = GetPefEntry(0x04, 0,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) printf("PEF Alert Startup Delay: %02x: %d sec\n",
+ LanRecord.data[0],LanRecord.data[0]);
+ /* fmBMC gets cc=0x80 here */
+ }
+ /* note that ndest should be read from lan param 17 below. */
+ for (i = 1; i <= ndest; i++)
+ {
+ ret = GetPefEntry(0x09, (ushort)i,(PEF_RECORD *)&LanRecord);
+ if (ret == 0) {
+ mystr[0] = 0;
+ j = LanRecord.data[2];
+ if (LanRecord.data[1] & 0x08) {
+ sprintf(mystr,"Chan[%d] Dest[%d] ",((j & 0xf0) >> 4),(j & 0x0f));
+ strcat(mystr,"Enabled ");
+ } else strcpy(mystr,"Disabled ");
+ printf("PEF Alert Policy[%d]: %02x %02x %02x %02x : %s\n",i,
+ LanRecord.data[0], LanRecord.data[1],
+ LanRecord.data[2], LanRecord.data[3],mystr);
+ }
+ } /*endfor ndest*/
+ } /*endif fpefok*/
+ } /*endif not canonical*/
+
+ if (fpefenable && !freadonly) { /* fenable or fdisable */
+ if (fSetPEFOks) pefadd = 5;
+ else pefadd = 2;
+ sz = (pefnum - 1) + pefadd + fCustomPEF;
+ printf("\n%s, SetPefEntry(1-%d) ...\n",progname,sz);
+ if (fdebug) printf("pefnum = %d, pefmax = %d\n",pefnum,pefmax);
+ for (idx = 1; idx <= pefmax; idx++)
+ {
+ // Set & Enable all PEF records
+ memset(&PefRecord.rec_id,0,sizeof(PEF_RECORD));
+ PefRecord.rec_id = (uchar)idx; /* next record, or user-specified */
+ if (idx < pefnum) { /* pefnum defaults to 12.(0x0c) */
+ if (pef_array[idx-1][7] == 0) /*empty pef record, set to default*/
+ memcpy(&PefRecord.rec_id,pef_defaults[idx-1],sizeof(PEF_RECORD));
+ else { /* set config however it was previously */
+ memcpy(&PefRecord.rec_id,pef_array[idx-1],sizeof(PEF_RECORD));
+ if (PefRecord.severity == 0)
+ PefRecord.severity = pef_defaults[idx-1][4];
+ }
+ } else if ((idx == pefnum) && /* new OS Crit Stop entry */
+ (PefRecord.sensor_type == 0)) {
+ // Set PEF values for 0x20, OS Critical Stop event
+ PefRecord.severity = PEF_SEV_CRIT;
+ PefRecord.genid1 = 0xff;
+ PefRecord.genid2 = 0xff;
+ PefRecord.sensor_type = 0x20; /* OS Critical Stop */
+ PefRecord.sensor_no = 0xff;
+ PefRecord.event_trigger = 0x6f;
+ PefRecord.data1 = 0xff;
+ PefRecord.mask1 = 0x00;
+ } else if ((idx == pefnum+1) && /* new Power Redundancy entry */
+ (PefRecord.sensor_type == 0)) {
+ // Set PEF values for 0x09/0x02/0x0b/0x41, Power Redundancy Lost
+ PefRecord.severity = PEF_SEV_WARN;
+ PefRecord.genid1 = 0xff;
+ PefRecord.genid2 = 0xff;
+ PefRecord.sensor_type = 0x09; /* Power Unit */
+ PefRecord.sensor_no = 0xff; /* usu 01 or 02 */
+ PefRecord.event_trigger = 0x0b; /* event trigger */
+ PefRecord.data1 = 0x02; /* 02 -> 41=Redundancy Lost */
+ PefRecord.mask1 = 0x00;
+ } else if (fSetPEFOks && idx == (pefnum+2)) {
+ PefRecord.severity = PEF_SEV_OK;
+ PefRecord.genid1 = 0xff;
+ PefRecord.genid2 = 0xff;
+ PefRecord.sensor_type = 0x09; /* Power Unit, Redund OK */
+ PefRecord.sensor_no = 0xff; /* usu 01 or 02 */
+ PefRecord.event_trigger = 0x0b; /* event trigger */
+ PefRecord.data1 = 0x01; /* 01 -> 40=Redundancy OK */
+ PefRecord.mask1 = 0x00;
+ } else if (fSetPEFOks && idx == (pefnum+3)) {
+ PefRecord.severity = PEF_SEV_OK;
+ PefRecord.genid1 = 0xff;
+ PefRecord.genid2 = 0xff;
+ PefRecord.sensor_type = 0x01; /* Temp OK */
+ PefRecord.sensor_no = 0xff; /* usu 01 or 02 */
+ PefRecord.event_trigger = 0x81; /* event trigger */
+ PefRecord.data1 = 0x95; /* 95 -> 50(NC),52(Crit) match */
+ PefRecord.mask1 = 0x0a;
+ } else if (fSetPEFOks && idx == (pefnum+4)) {
+ PefRecord.severity = PEF_SEV_OK;
+ PefRecord.genid1 = 0xff;
+ PefRecord.genid2 = 0xff;
+ PefRecord.sensor_type = 0x02; /* Voltage OK */
+ PefRecord.sensor_no = 0xff; /* usu 01 or 02 */
+ PefRecord.event_trigger = 0x81; /* event trigger */
+ PefRecord.data1 = 0x95; /* 95 -> 50(NC),52(Crit) match */
+ PefRecord.mask1 = 0x0a;
+ } else if (fCustomPEF && idx == (pefnum+pefadd)) {
+ /* user entered 10 or 18 PEF entry bytes */
+ PefRecord.action = custPEF[0];
+ PefRecord.policy = custPEF[1];
+ PefRecord.severity = custPEF[2];
+ PefRecord.genid1 = custPEF[3];
+ PefRecord.genid2 = custPEF[4];
+ PefRecord.sensor_type = custPEF[5];
+ PefRecord.sensor_no = custPEF[6];
+ PefRecord.event_trigger = custPEF[7];
+ PefRecord.data1 = custPEF[8];
+ PefRecord.mask1 = custPEF[9];
+ memcpy(&PefRecord.action,custPEF,18);
+ } else {
+ memcpy(&PefRecord.rec_id,pef_array[idx-1],sizeof(PEF_RECORD));
+ if (PefRecord.sensor_type == 0) continue; /* if reserved, skip it */
+ }
+ if (fdebug && (PefRecord.rec_id != idx)) {
+ /* memcpy from pef_defaults or pef_array clobbered rec_id */
+ printf("Warning: SetPef idx=%d, rec_id=%d\n",idx,PefRecord.rec_id);
+ PefRecord.rec_id = (uchar)idx; /*fix it*/
+ }
+ if (fdisable) {
+ /* Disable all PEF rules */
+ if (idx >= pefnum) PefRecord.fconfig = 0x00; /*disabled, software*/
+ else PefRecord.fconfig = 0x40; /*disabled, preset */
+ PefRecord.action = 0x00;
+ PefRecord.policy = 0x00;
+ } else { /*fenable*/
+ if (PefRecord.sensor_type != 0) { /* not an empty PEF entry */
+ /* Enable all non-empty PEF rules */
+ if (fCustomPEF && (idx == (pefnum+pefadd))) {
+ PefRecord.action = custPEF[0];
+ PefRecord.policy = custPEF[1];
+ } else {
+ PefRecord.action = 0x01; /*Alert*/
+ PefRecord.policy = 0x01; /*see Alert Policy #1*/
+ }
+ if (idx < pefnum) { /* special handling for presets, 1 thru 11 */
+ PefRecord.fconfig = 0x80; /* enabled, software */
+ ret = SetPefEntry(&PefRecord);
+ if (fdebug)
+ printf("SetPefEntry(%d/80) ret=%d\n",PefRecord.rec_id,ret);
+ // if (ret != 0) { nerrs++; lasterr = ret; }
+ // else ngood++;
+ PefRecord.fconfig = 0xC0; /* enabled, preset */
+ } else {
+ PefRecord.fconfig = 0x80; /* enabled, software */
+ }
+ } /*endif not empty*/
+ }
+ { // Show the new PEF record before setting it.
+ pc = (uchar *)&PefRecord;
+ sz = 21;
+ printf("PEFilter(%d): ",PefRecord.rec_id);
+ for (i = 0; i < sz; i++) printf("%02x ",pc[i]);
+ printf("\n");
+ }
+ ret = SetPefEntry(&PefRecord);
+ if (fdebug)
+ printf("SetPefEntry(%d) ret = %d\n", PefRecord.rec_id,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } /*end for*/
+ }
+ } /*end if not fIPMI10*/
+
+ if (!fcanonical)
+ printf("\n%s, GetLanEntry for channel %d ...\n",progname,lan_ch);
+ idest = 1;
+ for (idx = 0; idx < NLAN; idx++)
+ {
+ int ival;
+ if (fcanonical && (canon_param[idx] == 0)) continue;
+ if (idx == 8 || idx == 9) continue; /* not implemented */
+ ival = lanparams[idx].cmd;
+ if (ival >= 96 && ival <= 98) continue; /* not implemented */
+ if (ival >= 102 && ival <= 108) { /*custom IPv6 parameters*/
+ if (fipv6 == 0) continue; /*skip these*/
+ }
+ if (ival == 194 && vend_id == VENDOR_KONTRON) { /*oem hostname parm*/
+ lanparams[idx].sz = 36;
+ strcpy(lanparams[idx].desc,"IPMI Hostname");
+ } else if (ival >= 192 && ival <= 194) { /*custom DHCP parameters*/
+ if (vend_id != VENDOR_INTEL) continue;
+ if (fmBMC || fiBMC || fcanonical) continue; /*skip these*/
+ }
+ if (ival >= 20 && ival <= 25) {
+ if (!fIPMI20) continue; /*VLAN params 20-25, fIPMI20 only/opt*/
+ }
+ if ((ndest == 0) && (ival >= 18 && ival <= 19)) continue; /*skip dest*/
+ if (ival == 11) { /*grat arp interval*/
+ if (vend_id == VENDOR_SUPERMICROX) continue;
+ if (vend_id == VENDOR_SUPERMICRO) continue;
+ }
+ if (ival == 14 || ival == 15) { /*secondary gateway is optional*/
+ if (vend_id == VENDOR_KONTRON) continue;
+ }
+ if (ival == 201) { /*Get Channel Access*/
+ ret = ShowChanAcc(lan_ch);
+ } else {
+ if (ival == 18 || ival == 19) { /*dest params*/
+ if (ndest == 0) continue; /*skip if ndest==0 */
+ bset = (uchar)idest; /* dest id = 1 thru n */
+ } else bset = 0;
+ ret = GetLanEntry((uchar)ival, bset, &LanRecord);
+ }
+ if (ret == 0) { // Show the LAN record
+ pc = (uchar *)&LanRecord;
+ sz = lanparams[idx].sz;
+ if (ival == 18) { /*skip if invalid dest type param*/
+ if ((idest > 1) && (pc[2] == 0)) { idest = 1; continue; }
+ } else if (ival == 19) { /*skip if invalid dest addr param*/
+ if ((idest > 1) && !IpIsValid(&pc[3])) { idest = 1; continue; }
+ }
+ if (ival == 201) ; /* did it above */
+ else {
+ if (fcanonical) {
+ if ((ival == 19) && (idest > 1)) ; /*skip it*/
+ else {
+ j = strlen_(lanparams[idx].desc);
+ // (ival < 7) || (ival == 19) || ival == 102)
+ if (j <= 12) pstr = pspace3;
+ else pstr = pspace2;
+ printf("Channel %d %s %s%c ",lan_ch,
+ lanparams[idx].desc,pstr,bdelim);
+ }
+ } else
+ printf("Lan Param(%d) %s: ",ival,lanparams[idx].desc);
+ }
+ if (ival == 1) {
+ authmask = pc[0]; /* auth type support mask */
+ /* if (fmBMC) authmask is usually 0x15, else 0x14 */
+ } else if (ival == 3) {
+ if (IpIsValid(pc)) memcpy(bmcmyip,pc,4);
+ } else if (ival == 5) {
+ if (MacIsValid(pc)) memcpy(bmcmymac,pc,MAC_LEN);
+ } else if (ival == 6) {
+ if (SubnetIsValid(pc)) memcpy(bmcsubnet,pc,4);
+ /* else if invalid, leave default as 255.255.255.0 */
+ //} else if (ival == 7) {
+ // if (pc[0] >= 30) memcpy(bparm7,pc,3);
+ } else if (ival == 17) { /* num dest */
+ ndest = pc[0]; /* save the number of destinations */
+ } else if (ival == 19) { /* dest addr */
+ if (IpIsValid(&pc[3])) memcpy(bmcdestip,&pc[3],4);
+ if (MacIsValid(&pc[7])) memcpy(bmcdestmac,&pc[7],MAC_LEN);
+ } else if (ival == 22) { /*Cipher Suite Support*/
+ nciphers = pc[0];
+ }
+ /* now start to display data */
+ if (ival == 16) { printf("%s \n",pc); /* string */
+ } else if (ival == 194 && vend_id == VENDOR_KONTRON) {
+ printf("%s \n",pc); /* string */
+ } else if (ival == 201) { ; /* did it above */
+ } else { /* print results for all other ival's */
+ pstr = ""; /*interpreted meaning*/
+ if (fcanonical) {
+ switch(ival) {
+ case 4: /*param 4, ip src*/
+ if (pc[0] == SRC_STATIC) pstr = "Static"; /*0x01*/
+ else if (pc[0] == SRC_DHCP) pstr = "DHCP"; /*0x02*/
+ else if (pc[0] == SRC_BIOS) pstr = "BIOS"; /*0x03*/
+ else pstr = "Other";
+ printf("%s\n",pstr);
+ break;
+ case 5: /*param 5, mac addr*/
+ case 13: /*param 6, def gwy mac*/
+ printf("%02x:%02x:%02x:%02x:%02x:%02x\n",
+ pc[0], pc[1], pc[2], pc[3], pc[4], pc[5]);
+ break;
+ case 3: /*param 4, ip address*/
+ case 6: /*param 6, subnet mask*/
+ case 12: /*param 12, def gwy ip*/
+ case 14: /*param 14, sec gwy ip*/
+ case 192: /*param 192, DHCP svr ip*/
+ printf("%d.%d.%d.%d\n",pc[0], pc[1], pc[2], pc[3]);
+ break;
+ case 19: /*param 19, dest address*/
+ if (idest == 1) {
+ printf("IP=%d.%d.%d.%d "
+ "MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ pc[3], pc[4], pc[5], pc[6],
+ pc[7], pc[8], pc[9], pc[10], pc[11], pc[12]);
+ }
+ break;
+ case 102: /*param 102, IPv6 enable*/
+ if (pc[0] == 0x01) printf("enabled\n");
+ else printf("disabled\n");
+ break;
+ default:
+ printf("%02x \n",pc[0]);
+ break;
+ }
+ } else { /*not canonical */
+ if (ival == 3 || ival == 6 || ival == 12 || ival == 14
+ || ival == 192) {
+ printf("%d.%d.%d.%d",pc[0], pc[1], pc[2], pc[3]);
+ } else if (ival == 23) { /*Cipher Suites*/
+ for (i = 1; i <= nciphers; i++) printf("%2d ",pc[i]);
+ } else if (ival == 24) { /*Cipher Suite Privi Levels*/
+ for (i = 1; i < 9; i++) {
+ char c1, c2;
+ char *p;
+ p = parse_priv((pc[i] & 0x0f));
+ c1 = p[0];
+ p = parse_priv((pc[i] & 0xf0) >> 4);
+ c2 = p[0];
+ if ((i*2) >= nciphers) c2 = ' ';
+ printf(" %c %c ",c1,c2);
+ if ((i*2) > nciphers) break;
+ }
+ } else
+ for (i = 0; i < sz; i++)
+ {
+ /* print in hex, decimal, or string, based on ival */
+ if (ival == 1) { /* Auth type support */
+ pstr = &mystr[0];
+ getauthstr(authmask,pstr);
+ printf("%02x ",authmask);
+ } else if (ival == 4) { /* IP addr source */
+ if (pc[i] == SRC_STATIC) pstr = "Static"; /*0x01*/
+ else if (pc[i] == SRC_DHCP) pstr = "DHCP"; /*0x02*/
+ else if (pc[i] == SRC_BIOS) pstr = "BIOS"; /*0x03*/
+ else pstr = "Other";
+ printf("%02x ",pc[i]);
+ } else if (ival == 10) { /* grat ARP */
+ mystr[0] = 0;
+ if (pc[i] == 0) strcat(mystr,"ARP disabled ");
+ else if (pc[i] & 0x01) strcat(mystr,"Grat-ARP enabled");
+ else strcat(mystr,"Grat-ARP disabled");
+ if (pc[i] & 0x02) strcat(mystr,", ARP-resp enabled");
+ pstr = &mystr[0];
+ printf("%02x ",pc[i]);
+ } else if (ival == 11) { /* grat ARP interval */
+ float f;
+ f = (float)pc[i] / (float)2; /*500msec increments*/
+ sprintf(mystr,"%.1f sec",f);
+ pstr = &mystr[0];
+ printf("%02x ",pc[i]);
+ } else if (ival == 19) { /* dest addr */
+ if (i > 2 && i < 7) {
+ char *sepstr;
+ if (i == 3) printf("[");
+ if (i == 6) sepstr = "] ";
+ else if (i >=3 && i < 6) sepstr = ".";
+ else sepstr = " ";
+ printf("%d%s",pc[i],sepstr); /* IP address in dec */
+ }
+ else printf("%02x ",pc[i]); /* show mac/etc. in hex */
+ }
+ else printf("%02x ",pc[i]); /* show in hex */
+ } /*end for*/
+ if (ival == 2) { /*Auth type enables*/
+ pstr = &mystr[0];
+ i = 0;
+ if (lan_ch > 0) i = lan_ch - 1;
+ getauthstr(pc[i],pstr);
+ }
+ if (pstr[0] != 0) printf(": %s\n",pstr);
+ else printf("\n");
+ } /*end-else not canonical*/
+ } /*end-else others*/
+ if (ival == 18 || ival == 19) {
+ if (idest < ndest) {
+ idest++;
+ idx--; /* repeat this param*/
+ } else idest = 1;
+ }
+ } else { /* ret != 0 */
+ if (ival >= 20 && ival <= 25) { /*if errors, optional*/
+ if (fdebug) printf("GetLanEntry(%d), ret = %d\n",ival,ret);
+ } else
+ printf("GetLanEntry(%d), ret = %d\n",ival,ret);
+ if (ival == 17) ndest = 0; /*error getting num dest*/
+ }
+ } /*end for*/
+ if (fRomley) { /*get LAN Failover param*/
+ uchar b;
+ ret = lan_failover_intel(0xFF,(uchar *)&b);
+ if (ret != 0)
+ printf("Intel Lan Failover, ret = %d\n",ret);
+ else {
+ if (b == 1) pstr = "enabled";
+ else pstr = "disabled";
+ if (fcanonical)
+ printf("Intel Lan Failover %s%c %s\n",
+ pspace3, bdelim,pstr);
+ else printf("Intel Lan Failover %s%c %02x %c %s\n",
+ pspace2, bdelim,b,bdelim,pstr);
+ }
+ }
+ if (vend_id == VENDOR_SUPERMICROX || vend_id == VENDOR_SUPERMICRO) {
+ ret = oem_supermicro_get_lan_port(&bset);
+ if (ret == 0) {
+ pstr = oem_supermicro_lan_port_string(bset);
+ if (fcanonical)
+ printf("SuperMicro Lan Interface %s%c %s\n",
+ pspace2, bdelim,pstr);
+ else printf("SuperMicro Lan Interface %c %02x %c %s\n",
+ bdelim,bset,bdelim,pstr);
+ } else {
+ if (fdebug) printf("oem_supermicro_get_lan_port error %d\n",ret);
+ ret = 0; /*may not be supported on all smc plaforms*/
+ }
+ }
+ // if (fmBMC) lan_access = 0x04; /*Admin*/
+ // else lan_access = 0x04; /*Admin*/
+ if (!fIPMI10) { /* Get SOL params */
+ ret = GetSerialOverLan(lan_ch,0,0);
+ if (ret != 0) printf("GetSOL error %d\n",ret);
+ }
+ for (i = 1; i <= show_users; i++)
+ GetUser((uchar)i);
+
+ if (fgetser && !fcanonical) {
+ printf("\n%s, GetSerEntry ...\n",progname);
+ if (fmBMC) /* mBMC doesn't support serial */
+ printf("No serial channel support on this platform\n");
+ else
+ for (idx = 0; idx < NSER; idx++) {
+ int ival;
+ // if (idx == 9) continue; /* not implemented */
+ ival = serparams[idx].cmd;
+ if (ival == 201) {
+ ret = GetChanAcc(ser_ch, 0x40, &LanRecord);
+ } else {
+ ret = GetSerEntry((uchar)ival, &LanRecord);
+ }
+ if (ret == 0) { // Show the SER record
+ pc = (uchar *)&LanRecord;
+ sz = serparams[idx].sz;
+ printf("Serial Param(%d) %s: ",ival,serparams[idx].desc);
+ if (idx == 10) { /* modem init string */
+ pc[sz] = 0;
+ printf("%02x %s\n",pc[0],&pc[1]);
+ }
+ else if ((idx >= 11 && idx <= 13) || idx == 15) { /* strings */
+ printf("%s\n",pc);
+ }
+ else {
+ for (i = 0; i < sz; i++) {
+ printf("%02x ",pc[i]); /* show in hex */
+ }
+ printf("\n");
+ } /*end else*/
+ }
+ } /*end for*/
+ } /*endif fgetser*/
+
+ if (!freadonly) /* Set IPMI LAN enable/disable params. */
+ {
+ if (fipmilan) /* Sets not valid via ipmi_lan if same channel. */
+ printf("\nWarning: Setting LAN %d params while using a LAN channel.\n", lan_ch);
+
+ {
+ if (fenable && (fsharedMAC==0) && !lan_dhcp) {
+ /* must have an IP from -I option */
+ if (!IpIsValid(rgmyip)) { /* if not user-specified */
+ if (IpIsValid(bmcmyip)) {
+ memcpy(rgmyip,bmcmyip,4);
+ if (fdebug) printf("Using current IP %d.%d.%d.%d\n",
+ bmcmyip[0], bmcmyip[1],
+ bmcmyip[2], bmcmyip[3]);
+ } else {
+ printf("\nNot shared BMC LAN, must specify a unique "
+ "IP address via -I\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ }
+ }
+ /* Set LAN parameters. fenable or fdisable */
+ printf("\n%s, SetLanEntry for channel %d ...\n",progname,lan_ch);
+ /* use ifname to resolve MAC addresses below */
+ if (fdisable) {
+ if (!fIPMI10) {
+ ret = DisablePef(alertnum);
+ printf("DisablePef, ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ if (lan_user != 0) {
+ j = DisableUser(lan_user); /*disable this lan user*/
+ printf("DisableUser(%d), ret = %d\n",lan_user,j);
+ if (j != 0) { nerrs++; lasterr = j; }
+ else ngood++;
+ }
+ LanRecord.data[0] = 0x01; /* static IP address source */
+ ret = SetLanEntry(4, &LanRecord, 1);
+ printf("SetLanEntry(4), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ /* clear the BMC IP address */
+ memset(&LanRecord,0,4);
+ ret = SetLanEntry(3, &LanRecord, 4);
+ printf("SetLanEntry(3), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ /* clear the gateway IP address */
+ memset(&LanRecord,0,4);
+ ret = SetLanEntry(12, &LanRecord, 4);
+ printf("SetLanEntry(12), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ /* clear the gateway MAC address */
+ memset(&LanRecord,0,6);
+ ret = SetLanEntry(13, &LanRecord, 6);
+ printf("SetLanEntry(13), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } else if (fdisableSOL) {
+ ret = SetupSerialOverLan(0); /*disable*/
+ SELprintf("SetupSerialOverLan: ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } else { /*fenable*/
+ uchar chanctl;
+ if (bmcpefctl != 0) chanctl = chan_pefon; /*previously on*/
+ else chanctl = chan_pefoff;
+ ret = SetChanAcc(lan_ch, 0x80, chanctl);
+ if (fdebug) printf("SetChanAcc(lan/active), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ ret = SetChanAcc(lan_ch, 0x40, chanctl);
+ if (fdebug) printf("SetChanAcc(lan/nonvol), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ ret = SetUser(lan_user,myuser,passwordData);
+ printf("SetUser(%d), ret = %d\n",lan_user,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ if (fdisable && (vend_id == VENDOR_SUPERMICROX
+ || vend_id == VENDOR_SUPERMICRO) ) {
+ failover_enable = 0; /*dedicated*/
+ ret = oem_supermicro_set_lan_port(failover_enable);
+ printf("Set SuperMicro Lan port to %s, ret = %d\n",
+ oem_supermicro_lan_port_string(failover_enable),ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ }
+
+ if (fdisable || fdisableSOL) {
+ // if (nerrs > 0) printf("Warning: %d errors occurred\n",nerrs);
+ goto do_exit;
+ }
+
+ if (authmask == 0) authmask = 0x17; /*if none from GetLanEntry(1)*/
+ LanRecord.data[0] = (bAuth & authmask); /*Callback level*/
+ LanRecord.data[1] = (bAuth & authmask); /*User level */
+ LanRecord.data[2] = (bAuth & authmask); /*Operator level*/
+ LanRecord.data[3] = (bAuth & authmask); /*Admin level */
+ LanRecord.data[4] = 0; /*OEM level*/
+ if (fdebug) printf("SetLanEntry(2): %02x %02x %02x %02x %02x\n",
+ LanRecord.data[0],LanRecord.data[1],LanRecord.data[2],
+ LanRecord.data[3],LanRecord.data[4]);
+ ret = SetLanEntry(2, &LanRecord, 5);
+ printf("SetLanEntry(2), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+
+ /* Get the values to use from Linux eth0, etc. */
+ ret = Get_IPMac_Addr();
+ if (lan_dhcp) { /* use DHCP */
+ LanRecord.data[0] = SRC_DHCP; /* BMC running DHCP */
+ /* = SRC_BIOS; * address source = BIOS using DHCP */
+ ret = SetLanEntry(4, &LanRecord, 1);
+ printf("SetLanEntry(4), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ if (MacIsValid(rgmymac)) {
+ memcpy(&LanRecord,rgmymac,6);
+ ret = SetLanEntry(5, &LanRecord, 6);
+ if (ret == 0x82) { /*BMC may not allow the MAC to be set*/
+ if (fdebug)
+ printf("SetLanEntry(5), ret = %x cannot modify MAC\n",ret);
+ } else {
+ printf("SetLanEntry(5), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+
+ /* DHCP also relates to OEM LAN params 192, 193, 194 */
+ if ((vend_id == VENDOR_INTEL) && !fmBMC && !fiBMC)
+ { /*DHCP params 192-194 are Intel only*/
+ if (IpIsValid(rgmyip))
+ {
+ /* Set DHCP Server IP in param 192 from -I param. */
+ memcpy(&LanRecord,rgmyip,4);
+ ret = SetLanEntry(192, &LanRecord, 4);
+ printf("SetLanEntry(192), ret = %d\n",ret);
+ if (!MacIsValid(rgdhcpmac)) /* if MAC not set yet */
+ ret = Get_Mac(rgmyip,rgdhcpmac,NULL);
+ if (ret == 0) {
+ memcpy(&LanRecord,rgdhcpmac,MAC_LEN);
+ ret = SetLanEntry(193, &LanRecord, MAC_LEN);
+ printf("SetLanEntry(193), ret = %d\n",ret);
+ }
+ }
+ LanRecord.data[0] = 0x01; /*enable DHCP*/
+ ret = SetLanEntry(194, &LanRecord, 1);
+ printf("SetLanEntry(194), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else { /* use static IP */
+ printf("LAN%d (%s)\tip=%d.%d.%d.%d mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ lan_ch,ifname, rgmyip[0], rgmyip[1], rgmyip[2], rgmyip[3],
+ rgmymac[0], rgmymac[1], rgmymac[2], rgmymac[3],
+ rgmymac[4], rgmymac[5]);
+ if (IpIsValid(rgmyip)) {
+ if (lan_ch != gcm_ch) { /*skip if gcm*/
+ LanRecord.data[0] = 0x00; /*disable grat arp while setting IP*/
+ ret = SetLanEntry(10, &LanRecord, 1);
+ if (fdebug) printf("SetLanEntry(10,0), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ }
+ LanRecord.data[0] = 0x01; /* static IP address source */
+ ret = SetLanEntry(4, &LanRecord, 1);
+ printf("SetLanEntry(4), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ memcpy(&LanRecord,rgmyip,4);
+ ret = SetLanEntry(3, &LanRecord, 4);
+ printf("SetLanEntry(3), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ if (MacIsValid(rgmymac)) {
+ memcpy(&LanRecord,rgmymac,6);
+ ret = SetLanEntry(5, &LanRecord, 6);
+ if (ret == 0x82) {
+ /* Do not show anything, not an error if BMC does not
+ allow the BMC MAC to be changed. */
+ if (fdebug)
+ printf("SetLanEntry(5), ret = %x cannot modify MAC\n",ret);
+ } else {
+ printf("SetLanEntry(5), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+ if (!SubnetIsValid(rgsubnet)) /* not specified, use previous */
+ memcpy(rgsubnet,bmcsubnet,4);
+ memcpy(&LanRecord,rgsubnet,4);
+ ret = SetLanEntry(6, &LanRecord, 4);
+ printf("SetLanEntry(6), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ if (vend_id != VENDOR_PEPPERCON) {
+ /* may want to check bparm7 here */
+ LanRecord.data[0] = parm7[0]; /*IPv4 header, TTL */
+ LanRecord.data[1] = parm7[1]; /*IPv4 header, Flags */
+ LanRecord.data[2] = parm7[2]; /*IPv4 hdr, Precedence/Service */
+ ret = SetLanEntry(7, &LanRecord, 3);
+ printf("SetLanEntry(7), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ /* if lan_ch == 3, gcm gets error setting grat arp (ccode=0xCD) */
+ if (lan_ch != gcm_ch) { /*skip if gcm*/
+ /* 01=enable grat arp, 02=enable arp resp, 03=both */
+ LanRecord.data[0] = arp_ctl; /*grat arp*/
+ ret = SetLanEntry(10, &LanRecord, 1);
+ printf("SetLanEntry(10,%x), ret = %d\n",arp_ctl,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ LanRecord.data[0] = arp_interval; /*grat arp interval*/
+ ret = SetLanEntry(11, &LanRecord, 1);
+ printf("SetLanEntry(11), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ if ((vend_id == VENDOR_INTEL) && !fmBMC && !fiBMC) {
+ LanRecord.data[0] = 0x00; /*disable DHCP*/
+ ret = SetLanEntry(194, &LanRecord, 1);
+ printf("SetLanEntry(194), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } else { /* error, don't continue */
+ printf("Missing IP Address, can't continue. Use -I to specify\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ if (vend_id == VENDOR_KONTRON && rghostname[0] != 0) {
+ /* set the IPMI Hostname if specified */
+ sz = strlen_(rghostname);
+ /* LanRecord is larger than rghostname, bounds ok */
+ strncpy((char *)&LanRecord.data,rghostname,sz);
+ ret = SetLanEntry(194, &LanRecord, sz);
+ printf("SetLanEntry(194), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else {
+ LanRecord.data[0] = 0x31;
+ ret = SetLanEntry(195, &LanRecord, 1); /*re-read hostname*/
+ // printf("SetLanEntry(195), ret = %d\n",ret);
+ // if (ret != 0) { nerrs++; lasterr = ret; }
+ }
+ }
+ if (IpIsValid(rggwyip)) {
+ if (!MacIsValid(rggwymac)) /* if gwy MAC not set by user */
+ ret = Get_Mac(rggwyip,rggwymac,NULL);
+ printf("gateway \tip=%d.%d.%d.%d mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ rggwyip[0], rggwyip[1], rggwyip[2], rggwyip[3],
+ rggwymac[0], rggwymac[1], rggwymac[2], rggwymac[3],
+ rggwymac[4], rggwymac[5]);
+ if (!SubnetIsSame(rgmyip,rggwyip,rgsubnet))
+ printf("WARNING: IP Address and Gateway are not on the same subnet.\n");
+
+ /* Set the Default Gateway IP & MAC */
+ memcpy(&LanRecord,rggwyip,4);
+ ret = SetLanEntry(12, &LanRecord, 4);
+ printf("SetLanEntry(12), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ if (!MacIsValid(rggwymac)) { /* if gwy MAC not resolved */
+ printf(" Warning: Gateway MAC address was not resolved! "
+ "Check %s interface, use -i ethN, or use -H gwymac.\n",
+ ifname);
+ } else {
+ memcpy(&LanRecord,rggwymac,6);
+ ret = SetLanEntry(13, &LanRecord, 6);
+ printf("SetLanEntry(13), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+ if (IpIsValid(rggwy2ip)) {
+ if (!MacIsValid(rggwy2mac)) /* if gwy2 MAC not set by user */
+ ret = Get_Mac(rggwy2ip,rggwy2mac,NULL);
+ /* Set the Secondary Gateway IP & MAC */
+ memcpy(&LanRecord,rggwy2ip,4);
+ ret = SetLanEntry(14, &LanRecord, 4);
+ printf("SetLanEntry(14), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ memcpy(&LanRecord,rggwy2mac,6);
+ ret = SetLanEntry(15, &LanRecord, 6);
+ printf("SetLanEntry(15), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } /* end-else static IP */
+ ret = SetupSerialOverLan(1); /*enable*/
+ SELprintf("SetupSerialOverLan: ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ if (!IpIsValid(rgdestip) && IpIsValid(bmcdestip)) {
+ memcpy(rgdestip,bmcdestip,4);
+ if (fdebug) printf("Using current dest IP %d.%d.%d.%d\n",
+ bmcdestip[0], bmcdestip[1],
+ bmcdestip[2], bmcdestip[3]);
+ }
+ if (ndest == 0) {
+ if (fdebug) printf("ndest==0, anum=%d rgdestip=%d.%d.%d.%d\n",
+ alertnum, rgdestip[0], rgdestip[1], rgdestip[2], rgdestip[3]);
+ printf("alert dest \tnot supported\n");
+ } else if (!IpIsValid(rgdestip)) {
+ printf("alert dest \taddress not specified\n");
+ } else { /* valid alert dest ip */
+ if (!MacIsValid(rgdestmac)) /* if dest MAC not set by user */
+ ret = Get_Mac(rgdestip,rgdestmac,NULL); /*try to resolve MAC */
+ if (!MacIsValid(rgdestmac)) { /* if dest MAC not resolved */
+ printf(" Warning: Alert mac address was not resolved!"
+ " Check %s interface or use -i.\n",ifname);
+ /* use existing BMC alert dest mac (as best guess) */
+ memcpy(rgdestmac,bmcdestmac,6);
+ }
+ /* show destination data */
+ printf("alert dest %d\tip=%d.%d.%d.%d mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ alertnum, rgdestip[0], rgdestip[1], rgdestip[2], rgdestip[3],
+ rgdestmac[0], rgdestmac[1], rgdestmac[2], rgdestmac[3],
+ rgdestmac[4], rgdestmac[5]);
+ printf("snmp community \t%s\n",rgcommunity);
+ /* Only need the SNMP community if there is an Alert Destination */
+ memset(&LanRecord.data[0], 0, 18); /* make sure zero-filled */
+ strcpy(&LanRecord.data[0],rgcommunity);
+ ret = SetLanEntry(16, &LanRecord, 18);
+ printf("SetLanEntry(16), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ /* Set Alert Destination Type */
+ LanRecord.data[0] = alertnum; /* dest id = 1 */
+ LanRecord.data[1] = 0x00; /* dest type = PET, no ack */
+ LanRecord.data[2] = 0x01; /* ack timeout / retry interval */
+ LanRecord.data[3] = 0x00; /* no retries */
+ // LanRecord.data[4] = 0x69;
+ ret = SetLanEntry(18, &LanRecord, 4);
+ printf("SetLanEntry(18), ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ {
+ /* Set the Alert Destination IP & MAC (param 19) */
+ LanRecord.data[0] = alertnum; /* dest id = 1 */
+ LanRecord.data[1] = 0x00;
+ LanRecord.data[2] = 0x00;
+ memcpy(&LanRecord.data[3],rgdestip,4);
+ memcpy(&LanRecord.data[7],rgdestmac,6);
+ ret = SetLanEntry(19, &LanRecord, 13);
+ printf("SetLanEntry(19), ret = %d\n", ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ } /*endif valid alert*/
+
+ /* Now enable PEF since we have an Alert destination. */
+ if (!fdisable && !fIPMI10 && fpefenable) { /*fpefenable*/
+ ret = EnablePef(alertnum);
+ printf("EnablePef, ret = %d\n",ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ /* ChanAcc changed, so show it again */
+ j = ShowChanAcc(lan_ch);
+ }
+
+ if ((vlan_enable != PARM_INIT) && (fIPMI20)) {
+ if (vlan_enable == 0) { /*disable vlan*/
+ LanRecord.data[0] = 0x00;
+ LanRecord.data[1] = 0x00;
+ ret = SetLanEntry(20, &LanRecord, 2);
+ printf("SetLanEntry(20,disable) ret = %d\n", ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ } else { /*vlan_enable == 1, enable vlan with id */
+ LanRecord.data[0] = (vlan_id & 0x00ff);
+ LanRecord.data[1] = ((vlan_id & 0x0f00) >> 8) | 0x80;
+ ret = SetLanEntry(20, &LanRecord, 2);
+ printf("SetLanEntry(20,%d), ret = %d\n", vlan_id,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ LanRecord.data[0] = vlan_prio;
+ ret = SetLanEntry(21, &LanRecord, 1);
+ printf("SetLanEntry(21), ret = %d\n", ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ else ngood++;
+ }
+ }
+ if (failover_enable != PARM_INIT) {
+ if (fRomley) {
+ if (failover_enable > 1) failover_enable = 0; /*default*/
+ ret = lan_failover_intel(failover_enable,(uchar *)&i);
+ printf("Set Intel Lan Failover (%d), ret = %d\n",
+ failover_enable,ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ } else if (vend_id == VENDOR_SUPERMICROX
+ || vend_id == VENDOR_SUPERMICRO) {
+ if (failover_enable > 2) failover_enable = 2; /*default*/
+ ret = oem_supermicro_set_lan_port(failover_enable);
+ printf("Set SuperMicro Lan port to %s, ret = %d\n",
+ oem_supermicro_lan_port_string(failover_enable),ret);
+ if (ret != 0) { nerrs++; lasterr = ret; }
+ }
+ } /*endif failover specified*/
+ } /*end-else not via ipmi_lan*/
+ } /*endif not readonly*/
+
+ if (flanstats)
+ { /* get BMC LAN Statistics */
+#ifdef METACOMMAND
+ j = get_lan_stats(lan_ch);
+#else
+ uchar idata[2];
+ uchar rdata[20];
+ int rlen;
+ uchar cc;
+ idata[0] = lan_ch;
+ idata[1] = 0x00; /*do not clear stats*/
+ rlen = sizeof(rdata);
+ j = ipmi_cmd(GET_LAN_STATS, idata,2, rdata,&rlen, &cc, fdebug);
+ if (j == 0) { /*show BMC LAN stats*/
+ ushort *rw;
+ rw = (ushort *)&rdata[0];
+ printf("IPMI LAN channel %d statistics: \n",lan_ch);
+ printf(" \tReceived IP Packets = %d\n",rw[0]);
+ printf(" \tRecvd IP Header errors = %d\n",rw[1]);
+ printf(" \tRecvd IP Address errors = %d\n",rw[2]);
+ printf(" \tRecvd IP Fragments = %d\n",rw[3]);
+ printf(" \tTransmitted IP Packets = %d\n",rw[4]);
+ printf(" \tReceived UDP Packets = %d\n",rw[5]);
+ printf(" \tReceived Valid RMCP Pkts = %d\n",rw[6]);
+ printf(" \tReceived UDP Proxy Pkts = %d\n",rw[7]);
+ printf(" \tDropped UDP Proxy Pkts = %d\n",rw[8]);
+ }
+#endif
+ }
+
+do_exit:
+ ipmi_close_();
+ if (foptmsg) {
+ if (fset_ip != 0)
+ printf("WARNING: IP address options were specified, but no -e,-l,-d option.\n");
+ else
+ printf("WARNING: %d options were specified, but no -e,-l,-d option.\n",
+ nopts);
+ printf("Read-only usage assumed.\n");
+ }
+ if (nerrs > 0) {
+ printf("Warning: %d ok, %d errors occurred, last error = %d\n",ngood,nerrs,lasterr);
+ ret = lasterr;
+ }
+ // show_outcome(progname,ret);
+ return(ret);
+} /* end main()*/
+
+/* end ilan.c */
diff --git a/util/imb_api.h b/util/imb_api.h
new file mode 100644
index 0000000..56a940c
--- /dev/null
+++ b/util/imb_api.h
@@ -0,0 +1,708 @@
+/*M*
+// PVCS:
+// $Workfile: imb_api.h $
+// $Revision: 1.0 $
+// $Modtime: Jul 22 2002 16:40:32 $
+// $Author: arcress at users.sf.net $
+//
+// Combined include files needed for imbapi.c
+//
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+Copyright (c) 2002, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifndef _WINDEFS_H
+#define _WINDEFS_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+#define TRUE 1
+#define FALSE 0
+
+#if defined(WIN32) | defined(BSD) | defined(DOS)
+/* WIN32 defines wchar_t in stdio.h */
+/* BSD defines wchar_t in stdlib.h */
+/* DOS defines wchar_t in stdlib.h */
+#else
+ // defined(LINUX) | defined(SOLARIS)
+#ifndef _WCHAR_T
+#define _WCHAR_T
+typedef long wchar_t;
+#endif
+#endif
+
+#define far
+#define near
+#define FAR far
+#define NEAR near
+#ifndef CONST
+#define CONST const
+#endif
+typedef unsigned int UINT32;
+typedef unsigned long DWORD;
+typedef int BOOL;
+typedef unsigned char BYTE;
+typedef unsigned short WORD;
+typedef float FLOAT;
+typedef FLOAT *PFLOAT;
+typedef BOOL near *PBOOL;
+typedef BOOL far *LPBOOL;
+typedef BYTE near *PBYTE;
+typedef BYTE far *LPBYTE;
+typedef int near *PINT;
+typedef int far *LPINT;
+typedef WORD near *PWORD;
+typedef WORD far *LPWORD;
+typedef long far *LPLONG;
+typedef DWORD near *PDWORD;
+typedef DWORD far *LPDWORD;
+typedef void far *LPVOID;
+typedef CONST void far *LPCVOID;
+typedef int INT;
+typedef unsigned int UINT;
+typedef unsigned int *PUINT;
+#ifndef NTSTATUS
+typedef DWORD NTSTATUS;
+#endif
+/*
+ File structures
+*/
+#ifndef WIN32
+typedef struct _OVERLAPPED {
+ DWORD Internal;
+ DWORD InternalHigh;
+ DWORD Offset;
+ DWORD OffsetHigh;
+/* HANDLE hEvent; */
+} OVERLAPPED, *LPOVERLAPPED;
+#endif
+/*
+ * Data structure redefines
+ */
+typedef char CHAR;
+typedef short SHORT;
+typedef long LONG;
+typedef char * PCHAR;
+typedef short * PSHORT;
+typedef long * PLONG;
+typedef unsigned char UCHAR;
+typedef unsigned short USHORT;
+typedef unsigned long ULONG;
+typedef char CCHAR;
+typedef short CSHORT;
+typedef ULONG CLONG;
+typedef CCHAR * PCCHAR;
+typedef CSHORT * PCSHORT;
+typedef CLONG * PCLONG;
+typedef void * PVOID;
+#ifndef WIN32
+typedef void VOID;
+typedef struct _LARGE_INTEGER {
+ ULONG LowPart;
+ LONG HighPart;
+} LARGE_INTEGER;
+typedef struct _ULARGE_INTEGER {
+ ULONG LowPart;
+ ULONG HighPart;
+} ULARGE_INTEGER;
+#endif
+typedef LARGE_INTEGER * PLARGE_INTEGER;
+typedef LARGE_INTEGER PHYSICAL_ADDRESS;
+typedef LARGE_INTEGER * PPHYSICAL_ADDRESS;
+typedef ULARGE_INTEGER * PULARGE_INTEGER;
+typedef UCHAR BOOLEAN;
+typedef BOOLEAN *PBOOLEAN;
+typedef wchar_t WCHAR;
+typedef WCHAR *PWCHAR, *PWSTR;
+typedef CONST WCHAR *LPCWSTR, *PCWSTR;
+
+/*
+ Unicode strings are counted 16-bit character strings. If they are
+ NULL terminated, Length does not include trailing NULL.
+*/
+typedef struct _UNICODE_STRING {
+ USHORT Length;
+ USHORT MaximumLength;
+ PWSTR Buffer;
+} UNICODE_STRING;
+typedef UNICODE_STRING *PUNICODE_STRING;
+#define UNICODE_NULL ((WCHAR)0) /* winnt*/
+#define IN /* */
+#define OUT /* */
+#define OPTIONAL /* */
+
+#ifdef WIN32
+#define HandleType HANDLE
+#else
+#define HandleType long
+#define FIELD_OFFSET(type, field) ((LONG)&(((type *)0)->field))
+#define UNREFERENCED_PARAMETER(x)
+#define INVALID_HANDLE_VALUE ((HandleType)-1)
+#endif
+typedef HandleType *PHANDLE;
+/*
+ Define the method codes for how buffers are passed for I/O and FS controls
+*/
+#define METHOD_BUFFERED 0
+/*
+ Define the access check value for any access
+ The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
+ ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
+ constants *MUST* always be in sync.
+*/
+#define FILE_ANY_ACCESS 0
+/*
+ These are the generic rights.
+*/
+#define MAX_PATH 260
+// #define GetLastError() (NTstatus.Status)
+/*
+ Macro definition for defining IOCTL and FSCTL function control codes. Note
+ that function codes 0-2047 are reserved for Microsoft Corporation, and
+ 2048-4095 are reserved for customers.
+*/
+/*
+ * Linux drivers expect ioctls defined using macros defined in ioctl.h.
+ * So, instead of using the CTL_CODE defined for NT and UW, I define CTL_CODE
+ * using these macros. That way imb_if.h, where the ioctls are defined get
+ * to use the correct ioctl command we expect.
+ * Notes: I am using the generic _IO macro instead of the more specific
+ * ones. The macros expect 8bit entities, so I am cleaning what is sent to
+ * us from imb_if.h - Mahendra
+ */
+#ifdef LINUX
+#define CTL_CODE(DeviceType, Function, Method, Access)\
+ _IO(DeviceType & 0x00FF, Function & 0x00FF)
+#else
+/* WIN32 may have this defined in winsdk\include\winioctl.h */
+#ifndef CTL_CODE
+#define CTL_CODE( DeviceType, Function, Method, Access ) ((ULONG)( \
+ ((ULONG)(DeviceType) << 16) | ((ULONG)(Access) << 14) | ((ULONG)(Function) << 2) | ((ULONG)Method) \
+))
+#endif
+#endif
+#endif /*_WINDEFS_H */
+/*----------------------------------------------------------------------*/
+#ifndef _SMI_H
+#define _SMI_H
+#define SMI_Version1_00 0x00001000
+#define SMI_Version2_00 0x00002000
+/* LPVOID = (void far *) */
+/* DWORD = (unsigned long ) */
+/* typedef DWORD far *LPDWORD; */
+/* LPOVERLAPPED = struct w 4 DWORDs */
+struct smi {
+ DWORD smi_VersionNo;
+ DWORD smi_Reserved1;
+ DWORD smi_Reserved2;
+ LPVOID ntstatus; /* address of NT status block*/
+ LPVOID lpvInBuffer; /* address of buffer for input data*/
+ DWORD cbInBuffer; /* size of input buffer*/
+ LPVOID lpvOutBuffer; /* address of output buffer*/
+ DWORD cbOutBuffer; /* size of output buffer*/
+ LPDWORD lpcbBytesReturned; /* address of actual bytes of output*/
+ LPOVERLAPPED lpoOverlapped; /* address of overlapped structure*/
+};
+struct smi32 {
+ UINT32 smi_VersionNo;
+ UINT32 smi_Reserved1;
+ UINT32 smi_Reserved2;
+ UINT32 ntstatus; /* address of NT status block*/
+ UINT32 lpvInBuffer; /* address of buffer for input data*/
+ UINT32 cbInBuffer; /* size of input buffer*/
+ UINT32 lpvOutBuffer; /* address of output buffer*/
+ UINT32 cbOutBuffer; /* size of output buffer*/
+ UINT32 lpcbBytesReturned; /* address of actual bytes of output*/
+ struct { UINT32 h[4]; } lpoOverlapped; /* address of overlapped structure*/
+};
+#ifndef STATUS_SUCCESS
+typedef struct _IO_STATUS_BLOCK {
+ ULONG Status;
+ ULONG Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+/*
+ * I2C ioctl's return NTStatus codes
+ */
+#define STATUS_SUCCESS (0x00000000U)
+#define STATUS_UNSUCCESSFUL (0xC0000001U)
+#define STATUS_DEVICE_BUSY (0x80000011U)
+#ifndef WIN32
+// see <win2000ddk>\inc\winnt.h(1171)
+#define STATUS_PENDING (0x00000103U)
+#define STATUS_INVALID_PARAMETER (0xC000000DU)
+#endif
+#define STATUS_INVALID_DEVICE_REQUEST (0xC0000010U)
+#define STATUS_BUFFER_TOO_SMALL (0xC0000023U)
+#define STATUS_FILE_CLOSED (0xC0000128U)
+#define STATUS_INSUFFICIENT_RESOURCES (0xC000009AU)
+#define STATUS_NO_DATA_DETECTED (0x80000022U)
+#define STATUS_NO_SUCH_DEVICE (0xC000000EU)
+#define STATUS_ALLOTTED_EXCEEDED (0xC000000FU)
+#define STATUS_IO_DEVICE_ERROR (0xC0000185U)
+#define STATUS_TOO_MANY_OPEN_FILES (0xC000011FU)
+#define STATUS_ACCESS_DENIED (0xC0000022U)
+#define STATUS_BUFFER_OVERFLOW (0x80000005U)
+#define STATUS_CANCELLED (0xC0000120U)
+#endif /* STATUS_SUCCESS*/
+#endif /* _SMI_H*/
+/*----------------------------------------------------------------------*/
+#ifndef IMB_IF__
+#define IMB_IF__
+/*
+ * This is the structure passed in to the IOCTL_IMB_SHUTDOWN_CODE request
+ */
+typedef struct {
+ int code;
+ int delayTime;
+} ShutdownCmdBuffer;
+#define SD_NO_ACTION 0
+#define SD_RESET 1
+#define SD_POWER_OFF 2
+
+#pragma pack(1)
+/*
+ * This is the generic IMB packet format, the final checksum cant be
+ * represented in this structure and will show up as the last data byte
+ */
+typedef struct {
+ BYTE rsSa;
+ BYTE nfLn;
+ BYTE cSum1;
+ BYTE rqSa;
+ BYTE seqLn;
+ BYTE cmd;
+ BYTE data[1];
+} ImbPacket;
+#define MIN_IMB_PACKET_SIZE 7
+#define MAX_IMB_PACKET_SIZE 57 /*was 33, now 64-7=57*/
+// #define MAX_IMB_PACKET_SIZE 135 (if using flashupdt large packets)
+#define MAX_RBUFFER_SIZE 64 /*no longer used*/
+/*
+ * This is the standard IMB response format where the first byte of
+ * IMB packet data is interpreted as a command completion code.
+*/
+typedef struct {
+ BYTE rsSa;
+ BYTE nfLn;
+ BYTE cSum1;
+ BYTE rqSa;
+ BYTE seqLn;
+ BYTE cmd;
+ BYTE cCode;
+ BYTE data[1];
+} ImbRespPacket;
+#define MIN_IMB_RESPONSE_SIZE 7 /* min packet + completion code */
+#define MAX_IMB_RESPONSE_SIZE MAX_IMB_PACKET_SIZE
+/************************
+ * ImbRequestBuffer
+ ************************/
+/*D*
+// Name: ImbRequestBuffer
+// Purpose: Structure definition for holding IMB message data
+// Context: Used by SendTimedImbpMessage and SendTimedI2cMessge
+// functions in the library interface. In use, it is overlayed on a
+// char buffer of size MIN_IMB_REQ_BUF_SIZE +
+// Fields:
+// respBufSize size of the response buffer
+//
+// timeout timeout value in milli seconds
+//
+// req body of request to send
+//
+*D*/
+typedef struct {
+ BYTE rsSa;
+ BYTE cmd;
+ BYTE netFn;
+ BYTE rsLun;
+ BYTE dataLength;
+ BYTE data[16];
+} ImbRequest;
+typedef struct {
+ UINT32 flags; /* request flags*/
+#define NO_RESPONSE_EXPECTED 0x01 /*dont wait around for an IMB response*/
+ UINT32 timeOut; /* in uSec units*/
+ ImbRequest req; /* message buffer*/
+} ImbRequestBuffer;
+#define MIN_IMB_REQ_BUF_SIZE 13 /* a buffer without any request data*/
+#define MAX_IMB_REQ_SIZE (MIN_IMB_RESP_BUF_SIZE + MAX_IMB_PACKET_SIZE)
+/************************
+ * ImbResponseBuffer
+ ************************/
+/*D*
+// Name: ImbResponseBuffer
+// Purpose: Structure definition for response of a previous send
+// Context: Used by DeviceIoControl to pass the message to be sent to
+// MISSMIC port
+// Fields:
+// cCode completion code returned by firmware
+// data buffer for response data from firmware
+*D*/
+typedef struct {
+ BYTE cCode;
+ BYTE data[1];
+} ImbResponseBuffer;
+#define MIN_IMB_RESP_BUF_SIZE 1
+#define MAX_IMB_RESP_SIZE (MIN_IMB_RESP_BUF_SIZE + MAX_IMB_RESPONSE_SIZE)
+#pragma pack()
+
+/*
+ * Async message access structures and types
+ */
+typedef UINT32 ImbAsyncSeq;
+/*
+ * This is the structure passed in to IOCTL_IMB_GET_ASYNC_MSG
+*/
+typedef struct {
+ UINT32 timeOut;
+ ImbAsyncSeq lastSeq;
+} ImbAsyncRequest;
+#define ASYNC_SEQ_START 0
+typedef struct {
+ ImbAsyncSeq thisSeq;
+ BYTE data[1];
+} ImbAsyncResponse;
+#define MIN_ASYNC_RESP_SIZE sizeof( ImbAsyncSeq )
+#define MAX_ASYNC_RESP_SIZE (MIN_ASYNC_RESP_SIZE + MAX_IMB_PACKET_SIZE)
+/*
+** Driver Ioctls
+** In Linux, these calculate to:
+** IOCTL_IMB_SEND_MESSAGE =1082
+** IOCTL_IMB_GET_ASYNC_MSG =1088
+** IOCTL_IMB_MAP_MEMORY =108e
+** IOCTL_IMB_UNMAP_MEMORY =1090
+** IOCTL_IMB_SHUTDOWN_CODE =1092
+** IOCTL_IMB_REGISTER_ASYNC_OBJ =1098
+** IOCTL_IMB_DEREGISTER_ASYNC_OBJ=109a
+** IOCTL_IMB_CHECK_EVENT =109c
+** IOCTL_IMB_POLL_ASYNC =1094
+*/
+#define FILE_DEVICE_IMB 0x00008010
+#define IOCTL_IMB_BASE 0x00000880
+#define IOCTL_IMB_SEND_MESSAGE CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 2), METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_GET_ASYNC_MSG CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 8), METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_MAP_MEMORY CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 14),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_UNMAP_MEMORY CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 16),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_SHUTDOWN_CODE CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 18),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_REGISTER_ASYNC_OBJ CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 24),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_DEREGISTER_ASYNC_OBJ CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 26),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_CHECK_EVENT CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 28),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_IMB_POLL_ASYNC CTL_CODE(FILE_DEVICE_IMB, (IOCTL_IMB_BASE + 20),METHOD_BUFFERED, FILE_ANY_ACCESS)
+#endif /* IMB_IF__ */
+/*----------------------------------------------------------------------*/
+/* No asynchronous messages available */
+#define IMB_MSG_NOT_AVAILABLE ((NTSTATUS)0xE0070012L)
+#ifdef IMBLOG_H__
+/* Define the facility codes */
+#define FACILITY_RPC_STUBS 0x3
+#define FACILITY_RPC_RUNTIME 0x2
+#define FACILITY_IO_ERROR_CODE 0x4
+#define IMB_IO_ERROR_CODE 0x7
+
+#define STATUS_SEVERITY_WARNING 0x2
+#define STATUS_SEVERITY_SUCCESS 0x0
+#define STATUS_SEVERITY_INFORMATIONAL 0x1
+#define STATUS_SEVERITY_ERROR 0x3
+/* Not enough memory for internal storage of device %1. */
+#define INSUFFICIENT_RESOURCES ((NTSTATUS)0xE0070001L)
+
+#define INVALID_INPUT_BUFFER ((NTSTATUS)0xE0070002L)
+
+#define INVALID_OUTPUT_BUFFER ((NTSTATUS)0xE0070003L)
+
+#define IMB_SEND_TIMEOUT ((NTSTATUS)0xE0070004L)
+
+#define IMB_RECEIVE_TIMEOUT ((NTSTATUS)0xE0070005L)
+
+#define IMB_IF_SEND_TIMEOUT ((NTSTATUS)0xE0070006L)
+
+#define IMB_IF_RECEIVE_TIMEOUT ((NTSTATUS)0xE0040007L)
+
+#define HARDWARE_FAILURE ((NTSTATUS)0xE0040008L)
+
+#define DRIVER_FAILURE ((NTSTATUS)0xE0040009L)
+
+#define IMB_INVALID_IF_RESPONSE ((NTSTATUS)0xE004000AL)
+
+#define IMB_INVALID_PACKET ((NTSTATUS)0xE004000BL)
+
+#define IMB_RESPONSE_DATA_OVERFLOW ((NTSTATUS)0xE004000CL)
+
+#define IMB_INVALID_REQUEST ((NTSTATUS)0xE007000DL)
+
+#define INVALID_DRIVER_IOCTL ((NTSTATUS)0xE007000EL)
+
+#define INVALID_DRIVER_REQUEST ((NTSTATUS)0xE007000FL)
+
+#define IMB_CANT_GET_SMS_BUFFER ((NTSTATUS)0xE0070010L)
+
+#define INPUT_BUFFER_TOO_SMALL ((NTSTATUS)0xE0070011L)
+
+#define IMB_SEND_ERROR ((NTSTATUS)0xE0070013L)
+#endif /* IMBLOG_H__ */
+/*----------------------------------------------------------------------*/
+#ifndef IMBAPI_H__
+#define IMBAPI_H__
+#include <sys/types.h>
+#if defined(MACOS)
+/* has caddr_t */
+#else
+#ifndef _SYS_TYPES_H
+#ifndef _CADDR_T
+#define _CADDR_T
+ typedef char * caddr_t;
+#endif
+#endif
+#endif
+
+#define WRITE_READ_I2C 0x52
+#define WRITE_EMP_BUFFER 0x7a
+#define GET_DEVICE_ID 0x1
+#define CMD_GET_DEVICE_ID 0x01
+#define SEND_MESSAGE 0x34
+#define GET_MESSAGE 0x33
+#define BMC_SA 0x20
+#define BMC_LUN 0
+#define APP_NETFN 0x06
+#define IPMI_09_VERSION 0x90
+#define IPMI_10_VERSION 0x01
+
+#define IPMI_15_VERSION 0x51
+
+#ifndef IPMI10_GET_DEVICE_ID_RESP_LENGTH
+#define IPMI10_GET_DEVICE_ID_RESP_LENGTH 12
+#endif
+
+#define IPMB_CHANNEL 0x0
+#define EMP_CHANNEL 0x1
+#define LAN_CHANNEL 0x2
+#define ANY_CHANNEL 0xFF
+#define RESERVED_LUN 0x3
+#define IPMB_LUN 0x2
+#define EMP_LUN 0x0
+
+#define PUBLIC_BUS 0
+
+#define BMC_CONTROLLER 0x20
+#define FPC_CONTROLLER 0x22
+typedef enum {
+ ACCESN_OK,
+ ACCESN_ERROR,
+ ACCESN_OUT_OF_RANGE,
+ ACCESN_END_OF_DATA,
+ ACCESN_UNSUPPORTED,
+ ACCESN_INVALID_TRANSACTION,
+ ACCESN_TIMED_OUT
+} ACCESN_STATUS;
+#pragma pack(1)
+/*
+ * Request structure provided to SendTimedImbpRequest()
+*/
+typedef struct {
+ unsigned char cmdType;
+ unsigned char rsSa;
+ unsigned char busType;
+ unsigned char netFn;
+ unsigned char rsLun;
+ unsigned char * data;
+ int dataLength;
+} IMBPREQUESTDATA;
+/*
+ * Request structure provided to SendTimedI2cRequest()
+*/
+typedef struct {
+ unsigned char rsSa;
+ unsigned char busType;
+ unsigned char numberOfBytesToRead;
+ unsigned char * data;
+ int dataLength;
+} I2CREQUESTDATA;
+#pragma pack()
+/*#ifdef IMB_API
+ *
+ * This section is provided to be able to compile using imb_if.h
+ *
+ *
+ * function return type. This is also defined in the local instrumentation
+ * so we ifdef here to avoid conflict.
+*/
+#define METHOD_BUFFERED 0
+#define FILE_ANY_ACCESS 0
+/*
+ * This is necessary to compile using memIf.h
+ */
+typedef enum _INTERFACE_TYPE
+{
+ Internal,
+ Isa,
+ Eisa,
+ MicroChannel,
+ TurboChannel,
+ MaximumInterfaceType
+} INTERFACE_TYPE, * PINTERFACE_TYPE;
+#ifdef WIN32
+/* From memIf.h */
+#pragma pack(1)
+typedef struct
+{
+ INTERFACE_TYPE InterfaceType; // Isa, Eisa, etc....
+ ULONG BusNumber; // Bus number
+ PHYSICAL_ADDRESS BusAddress; // Bus-relative address
+ ULONG AddressSpace; // 0 is memory, 1 is I/O
+ ULONG Length; // Length of section to map
+} PHYSICAL_MEMORY_INFO, * PPHYSICAL_MEMORY_INFO;
+#pragma pack()
+#endif
+/*#else // not IMB_API */
+/*
+ * These are defined in imb_if.h but are needed by users of the imbapi library
+*/
+#define ASYNC_SEQ_START 0
+/*
+ * This is the generic IMB packet format, the final checksum cant be
+ * represented in this structure and will show up as the last data byte
+ */
+/*#endif // IMB_API */
+
+/******************************
+ * FUNCTION PROTOTYPES
+ ******************************/
+#ifdef LINK_LANDESK
+#define SendTimedImbpRequest ia_SendTimedImbpRequest
+#define StartAsyncMesgPoll ia_StartAsyncMesgPoll
+#define SendTimedI2cRequest ia_SendTimedI2cRequest
+#define SendTimedEmpMessageResponse ia_SendTimedEmpMessageResponse
+#define SendTimedEmpMessageResponse_Ex ia_SendTimedEmpMessageResponse_Ex
+#define SendTimedLanMessageResponse ia_SendTimedLanMessageResponse
+#define SendTimedLanMessageResponse_Ex ia_SendTimedLanMessageResponse_Ex
+#define SendAsyncImbpRequest ia_SendAsyncImbpRequest
+#define GetAsyncImbpMessage ia_GetAsyncImbpMessage
+#define GetAsyncImbpMessage_Ex ia_GetAsyncImbpMessage_Ex
+#define IsAsyncMessageAvailable ia_IsAsyncMessageAvailable
+#define RegisterForImbAsyncMessageNotification ia_RegisterForImbAsyncMessageNotification
+#define UnRegisterForImbAsyncMessageNotification ia_UnRegisterForImbAsyncMessageNotification
+#define SetShutDownCode ia_SetShutDownCode
+#define GetIpmiVersion ia_GetIpmiVersion
+#else
+int initIPMI(void);
+int termIPMI(void);
+#endif
+
+ACCESN_STATUS
+SendTimedImbpRequest (
+ IMBPREQUESTDATA *reqPtr,
+ int timeOut,
+ BYTE * respDataPtr,
+ int * respDataLen,
+ BYTE * completionCode
+ );
+ACCESN_STATUS
+SendTimedI2cRequest (
+ I2CREQUESTDATA *reqPtr,
+ int timeOut,
+ BYTE * respDataPtr,
+ int * respDataLen,
+ BYTE * completionCode
+ );
+ACCESN_STATUS
+SendAsyncImbpRequest (
+ IMBPREQUESTDATA *reqPtr,
+ BYTE * seqNo
+ );
+ACCESN_STATUS
+GetAsyncImbpMessage (
+ ImbPacket * msgPtr,
+ DWORD * msgLen,
+ DWORD timeOut,
+ ImbAsyncSeq * seqNo,
+ DWORD channelNumber
+ );
+ACCESN_STATUS
+GetAsyncImbpMessage_Ex (
+ ImbPacket * msgPtr,
+ DWORD * msgLen,
+ DWORD timeOut,
+ ImbAsyncSeq * seqNo,
+ DWORD channelNumber,
+ BYTE * sessionHandle,
+ BYTE * privilege
+ );
+ACCESN_STATUS
+UnmapPhysicalMemory( int virtualAddress, int Length );
+ACCESN_STATUS
+StartAsyncMesgPoll(void);
+ACCESN_STATUS
+MapPhysicalMemory (
+ int startAddress,
+ int addressLength,
+ int *virtualAddress
+ );
+ACCESN_STATUS
+SetShutDownCode (
+ int delayTime,
+ int code
+ );
+ACCESN_STATUS
+SendTimedEmpMessageResponse (
+ ImbPacket * ptr,
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut
+ );
+ACCESN_STATUS
+SendTimedEmpMessageResponse_Ex (
+ ImbPacket * ptr,
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut,
+ BYTE sessionHandle,
+ BYTE channelNumber
+ );
+ACCESN_STATUS
+SendTimedLanMessageResponse (
+ ImbPacket * ptr,
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut
+ );
+ACCESN_STATUS
+SendTimedLanMessageResponse_Ex (
+ ImbPacket * ptr,
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut ,
+ BYTE sessionHandle,
+ BYTE channelNumber
+ );
+ACCESN_STATUS
+IsAsyncMessageAvailable (HandleType eventId);
+ACCESN_STATUS
+RegisterForImbAsyncMessageNotification (HandleType *handleId);
+ACCESN_STATUS
+UnRegisterForImbAsyncMessageNotification (HandleType handleId,int iFlag);
+BYTE GetIpmiVersion(void);
+#endif /* IMBAPI_H__ */
diff --git a/util/imbapi.c b/util/imbapi.c
new file mode 100644
index 0000000..cbc8fa1
--- /dev/null
+++ b/util/imbapi.c
@@ -0,0 +1,2594 @@
+/*M*
+// PVCS:
+// $Workfile: imbapi.c $
+// $Revision: 1.12 $
+// $Modtime: 06 Aug 2001 13:16:56 $
+//
+// Purpose: This file contains the entry point that opens the IMB device
+// in order to issue the IMB driver API related IOCTLs.
+// This file implements the IMB driver API for the Server
+// Management Agents.
+//
+// $Log: //epg-scc/sst/projectdatabases/isc/isc3x/LNWORK/SRC/imbapi/imbapi.c.v $
+//
+// 04/04/02 ARCress - Mods for open-source & various compile cleanup mods
+// 05/28/02 ARCress - fixed buffer size error
+// 04/08/03 ARCress - misc cleanup
+// 01/20/04 ARCress - added WIN32 flags
+// 05/24/05 ARCress - added LINK_LANDESK flags
+// 08/24/06 ARCress - mods for addtl DEBUG (dbgmsg)
+// 03/19/08 ARCress - fix for SendTimedLan(IpmiVersion) if IPMI 2.0
+*M*/
+/*----------------------------------------------------------------------*
+The BSD License
+Copyright (c) 2002-2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#if defined(SOLARIS) || defined(BSD)
+#undef IMB_API
+#else
+/* Ok for WIN32, LINUX, SCO_UW, etc., but not Solaris */
+#define IMB_API 1
+#endif
+
+#ifdef IMB_API
+
+#ifdef WIN32
+#define NO_MACRO_ARGS 1
+#include <windows.h>
+#include <stdio.h>
+#define uint unsigned int
+
+#else /* LINUX, SCO_UW, UNIX */
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#endif
+#include "imb_api.h"
+
+#ifdef SCO_UW
+#define NO_MACRO_ARGS 1
+#define __FUNCTION__ "func"
+#define IMB_DEVICE "/dev/instru/mismic"
+#else
+#define IMB_DEVICE "/dev/imb"
+#define PAGESIZE EXEC_PAGESIZE
+#endif
+
+/*Just to make the DEBUG code cleaner.*/
+#if defined(DBG_IPMI) || defined(LINUX_DEBUG)
+#include <stdarg.h>
+static void dbgmsg( char *pattn, ... )
+{
+ va_list arglist;
+ FILE *fdlog;
+
+ fdlog = fopen( "imbdbg.log", "a+" );
+ if (fdlog == NULL) fdlog = stdout;
+ va_start( arglist, pattn );
+ vfprintf( fdlog, pattn, arglist );
+ va_end( arglist );
+ fclose(fdlog);
+}
+#endif
+#ifdef NO_MACRO_ARGS
+#define DEBUG(format, args) /*not_debug*/
+#else
+#ifdef LINUX_DEBUG
+#define DEBUG(format, args...) dbgmsg(format, ##args)
+// #define DEBUG(format, args...) printf(format, ##args)
+#else
+#define DEBUG(format, args...) /*not_debug*/
+#endif
+#endif
+
+#define IMB_OPEN_TIMEOUT 400
+#define IMB_MAX_RETRIES 2
+#define IMB_DEFAULT_TIMEOUT (1000) /*timeout for SendTimedImb in msec*/
+#define ERR_NO_DRV -16 /*cannot open IPMI driver*/
+
+#define LOCAL_IPMB 1 /*instead of METACOMMAND_IPMB*/
+
+int ipmi_timeout_ia = IMB_DEFAULT_TIMEOUT; /* in msec */
+#ifdef METACOMMAND_IPMB /*++++ not used*/
+extern int ipmi_cmd_ipmb(BYTE cmd, BYTE netfn, BYTE sa, BYTE bus, BYTE lun,
+ BYTE *pdata, int sdata, BYTE *presp,
+ int *sresp, BYTE *pcc, char fdebugcmd); /*ipmilan.c*/
+#endif
+#ifdef METACOMMAND
+extern FILE *fpdbg;
+extern FILE *fperr;
+#else
+static FILE *fpdbg = NULL;
+static FILE *fperr = NULL;
+#endif
+
+/* uncomment out the #define below or use -DLINUX_DEBUG_MAX in the makefile
+// if you want a dump of the memory to debug mmap system call in
+// MapPhysicalMemory() below.
+//
+//#define LINUX_DEBUG_MAX 1 */
+//#define IMB_MEMORY 1 */
+
+/*keep it simple. use global varibles for event objects and handles
+//pai 10/8 */
+
+/* UnixWare should eventually have its own source code file. Right now
+// new code has been added based on the existing policy of using
+// pre-processor directives to separate os-specific code (pai 11/21) */
+
+static int IpmiVersion;
+static HandleType AsyncEventHandle = 0;
+// static void * AsyncEventObject = 0;
+
+/*////////////////////////////////////////////////////////////////////////////
+// GLOBAL VARIABLES
+///////////////////////////////////////////////////////////////////////////// */
+
+#if defined(__i386__) || defined(__i586__) || defined(__i686__)
+// static DWORD ioctl_sendmsg = 0x1082; /* force 0x1082 if 32-bit */
+static DWORD ioctl_sendmsg = IOCTL_IMB_SEND_MESSAGE;
+#else
+static DWORD ioctl_sendmsg = IOCTL_IMB_SEND_MESSAGE;
+#endif
+
+static IO_STATUS_BLOCK NTstatus; /*dummy place holder. See deviceiocontrol. */
+static HandleType hDevice1; /*used in open_imb() */
+static HandleType hDevice; /*used to call DeviceIoControl()*/
+/*mutex_t deviceMutex; */
+#ifdef LINUX_DEBUG
+static char fdebug = 1;
+#else
+static char fdebug = 0;
+#endif
+
+#ifdef LINK_LANDESK
+#define SendTimedImbpRequest ia_SendTimedImbpRequest
+#define StartAsyncMesgPoll ia_StartAsyncMesgPoll
+#define SendTimedI2cRequest ia_SendTimedI2cRequest
+#define SendTimedEmpMessageResponse ia_SendTimedEmpMessageResponse
+#define SendTimedEmpMessageResponse_Ex ia_SendTimedEmpMessageResponse_Ex
+#define SendTimedLanMessageResponse ia_SendTimedLanMessageResponse
+#define SendTimedLanMessageResponse_Ex ia_SendTimedLanMessageResponse_Ex
+#define SendAsyncImbpRequest ia_SendAsyncImbpRequest
+#define GetAsyncImbpMessage ia_GetAsyncImbpMessage
+#define GetAsyncImbpMessage_Ex ia_GetAsyncImbpMessage_Ex
+#define IsAsyncMessageAvailable ia_IsAsyncMessageAvailable
+#define RegisterForImbAsyncMessageNotification ia_RegisterForImbAsyncMessageNotification
+#define UnRegisterForImbAsyncMessageNotification ia_UnRegisterForImbAsyncMessageNotification
+#define SetShutDownCode ia_SetShutDownCode
+#define GetIpmiVersion ia_GetIpmiVersion
+#endif
+
+int open_imb(int fskipcmd);
+
+void set_fps(void)
+{
+ if (fpdbg == NULL) fpdbg = stdout;
+ if (fperr == NULL) fperr = stdout;
+}
+
+#ifndef WIN32
+DWORD GetLastError(void) { return(NTstatus.Status); }
+
+/*///////////////////////////////////////////////////////////////////////////
+// DeviceIoControl
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: DeviceIoControl
+// Purpose: Simulate NT DeviceIoControl using unix calls and structures.
+// Context: called for every NT DeviceIoControl
+// Returns: FALSE for fail and TRUE for success. Same as standarad NTOS call
+// as it also sets Ntstatus.status.
+// Parameters: Standard NT call parameters, see below.
+// Notes: none
+*F*/
+static BOOL
+DeviceIoControl(
+ HandleType dummy_hDevice, /* handle of device */
+ DWORD dwIoControlCode, /* control code of operation to perform*/
+ LPVOID lpvInBuffer, /* address of buffer for input data */
+ DWORD cbInBuffer, /* size of input buffer */
+ LPVOID lpvOutBuffer, /* address of output buffer */
+ DWORD cbOutBuffer, /* size of output buffer */
+ LPDWORD lpcbBytesReturned, /* address of actual bytes of output */
+ LPOVERLAPPED lpoOverlapped /* address of overlapped struct */
+ )
+{
+ struct smi s;
+ int rc, max_i;
+ int ioctl_status;
+
+ DEBUG("DeviceIoControl: hDevice1=%x hDevice=%x ioctl=%x\n",
+ hDevice1,hDevice,dwIoControlCode);
+ rc = open_imb(1); /*open if needed, set fskipcmd to avoid recursion*/
+ if (rc == 0) {
+#ifdef DBG_IPMI
+ dbgmsg("DeviceIoControl: open_imb failed %d\n", rc);
+#endif
+ return FALSE;
+ }
+
+ /*-------------dont use locking--------------
+ //lock the mutex, before making the request....
+ if(mutex_lock(&deviceMutex) != 0) {
+ return(FALSE);
+ }
+ *-------------------------------------------*/
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: ioctl cmd = 0x%lx ", __FUNCTION__,dwIoControlCode);
+ DEBUG("cbInBuffer %d cbOutBuffer %d\n", cbInBuffer, cbOutBuffer);
+#endif
+ /* Test for Intel imb driver max buf size */
+ /* Max was 41, too small. Calculate real max - ARCress 6/01/05 */
+ max_i = MAX_IMB_PACKET_SIZE + MIN_IMB_REQ_BUF_SIZE; /*33 + 13*/
+ if (cbInBuffer > max_i) cbInBuffer = max_i;
+
+ s.lpvInBuffer = lpvInBuffer;
+ s.cbInBuffer = cbInBuffer;
+ s.lpvOutBuffer = lpvOutBuffer;
+ s.cbOutBuffer = cbOutBuffer;
+ s.lpcbBytesReturned = lpcbBytesReturned;
+ s.lpoOverlapped = lpoOverlapped;
+ s.ntstatus = (LPVOID)&NTstatus; /*dummy place holder. Linux IMB driver
+ //doesnt return status or info via it.*/
+#ifdef IMB_DEBUG
+ if (fdebug) {
+ int j, n;
+ char *tag;
+ unsigned int *bi;
+ unsigned char *b;
+
+ printf("ioctl %x smi buffer:\n",dwIoControlCode);
+ /* show arg/smi structure */
+ bi = (unsigned int *)&s;
+ n = ( sizeof(struct smi) / sizeof(int) );
+ printf("smi(%p), (sz=%d/szint=%d)->%d:\n", bi, sizeof(struct smi),
+ sizeof(int),n);
+ for (j = 0; j < n; j++) {
+ switch(j) {
+ case 0: tag = "version "; break;
+ case 2: tag = "reserved1"; break;
+ case 4: tag = "reserved2"; break;
+ case 6: tag = "ntstatus "; break;
+ case 8: tag = "pinbuf "; break;
+ case 10: tag = "sinbuf "; break;
+ case 12: tag = "poutbuf"; break;
+ case 14: tag = "soutbuf"; break;
+ case 16: tag = "cbRet "; break;
+ case 18: tag = "pOverlap"; break;
+ default: tag = "other ";
+ }
+ printf("bi[%d]%s: %08x \n",j,tag,bi[j]);
+ } /*end for*/
+ }
+#endif
+
+ if ( (ioctl_status = ioctl(hDevice1, dwIoControlCode,&s) ) <0) {
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s %s: ioctl cmd = 0x%x failed %d \n",
+ __FILE__,__FUNCTION__,dwIoControlCode,ioctl_status);
+#endif
+#ifdef DBG_IPMI
+ dbgmsg("DeviceIoControl: ioctl cmd = 0x%x failed %d \n",
+ dwIoControlCode,ioctl_status);
+#endif
+ /* mutex_unlock(&deviceMutex); */
+ return FALSE;
+ }
+ /*-------------dont use locking--------------
+ mutex_unlock(&deviceMutex);
+ *-------------------------------------------*/
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: ioctl_status %d bytes returned = %d \n",
+ __FUNCTION__, ioctl_status, *lpcbBytesReturned);
+#endif
+
+/*MR commented this just as in Sol1.10. lpcbBytesReturned has the right data
+// *lpcbBytesReturned = NTstatus.Information; */
+
+ if (ioctl_status == STATUS_SUCCESS) {
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s returning true\n", __FUNCTION__);
+#endif
+ return (TRUE);
+ }
+ else {
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s returning false\n", __FUNCTION__);
+#endif
+ return (FALSE);
+ }
+}
+#endif
+
+static void _dump_buf(char *tag, BYTE *pbuf, int sz, char fshowascii)
+{
+ BYTE line[17];
+ BYTE a;
+ int i, j;
+ char *stag;
+ FILE *fpdbg1;
+
+#ifdef DBG_IPMI
+ fpdbg1 = fopen( "imbdbg.log", "a+" );
+ if (fpdbg1 == NULL) fpdbg1 = stdout;
+#else
+ fpdbg1 = stdout;
+#endif
+ if (tag == NULL) stag = "dump_buf"; /*safety valve*/
+ else stag = tag;
+ fprintf(fpdbg1,"%s (len=%d): ", stag,sz);
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ if (sz < 0) { fprintf(fpdbg1,"\n"); return; } /*safety valve*/
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) {
+ line[j] = 0;
+ j = 0;
+ fprintf(fpdbg1,"%s\n %04x: ",line,i);
+ }
+ if (fshowascii) {
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ }
+ fprintf(fpdbg1,"%02x ",pbuf[i]);
+ }
+ if (fshowascii) {
+ if ((j > 0) && (j < 16)) {
+ /* space over the remaining number of hex bytes */
+ for (i = 0; i < (16-j); i++) fprintf(fpdbg1," ");
+ }
+ else j = 16;
+ line[j] = 0;
+ }
+ fprintf(fpdbg1,"%s\n",line);
+#ifdef DBG_IPMI
+ if (fpdbg1 != stdout) fclose(fpdbg1);
+#endif
+ return;
+}
+
+#ifdef LOCAL_IPMB
+#define SMS_MSG_LUN 0x02
+extern void os_usleep(int s, int u); /*subs.c*/
+static int sendSeq = 1;
+static BYTE cksum(const BYTE *buf, register int len)
+{ /* 8-bit 2s compliment checksum */
+ register BYTE csum;
+ register int i;
+ csum = 0;
+ for (i = 0; i < len; i++) csum = (csum + buf[i]) % 256;
+ csum = -csum;
+ return(csum);
+}
+
+// SendTimedIpmbpRequest
+ACCESN_STATUS
+SendTimedIpmbpRequest (
+ IMBPREQUESTDATA *reqPtr, /* request info and data */
+ int timeOut, /* how long to wait, in mSec units */
+ BYTE *respDataPtr, /* where to put response data */
+ int *respDataLen, /* how much response data there is */
+ BYTE *completionCode /* request status from bmc controller*/
+ )
+{
+ BYTE responseData[MAX_IMB_REQ_SIZE];
+ ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData;
+ DWORD respLength = sizeof( responseData );
+ DWORD reqLength;
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ BOOL status;
+ int i;
+
+ req->req.rsSa = BMC_SA;
+ req->req.cmd = SEND_MESSAGE;
+ req->req.netFn = APP_NETFN;
+ req->req.rsLun = BMC_LUN; /*=0*/
+ req->req.data[0] = reqPtr->busType;
+ req->req.data[1] = reqPtr->rsSa;
+ req->req.data[2] = ((reqPtr->netFn << 2) | (reqPtr->rsLun & 0x03));
+ req->req.data[3] = cksum(&req->req.data[1],2);
+ req->req.data[4] = BMC_SA;
+ req->req.data[5] = ((sendSeq << 2) | (SMS_MSG_LUN & 0x03));
+ req->req.data[6] = reqPtr->cmdType;
+ for (i = 0; i < reqPtr->dataLength; i++)
+ req->req.data[7+i] = reqPtr->data[i];
+ req->req.data[7+i] = cksum(&req->req.data[4], reqPtr->dataLength + 3);
+ req->req.dataLength = reqPtr->dataLength + 8;
+
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+ reqLength = req->req.dataLength + MIN_IMB_REQ_BUF_SIZE;
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ reqLength,
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL);
+ if (fdebug) printf("sendIpmb: send_message status=%d rlen=%d cc=%x\n",
+ status,respLength,resp->cCode);
+ if ( status != TRUE ) {
+ DWORD error;
+ error = GetLastError();
+ return ACCESN_ERROR;
+ }
+ if ( respLength == 0 ) {
+ return ACCESN_ERROR;
+ }
+ sendSeq++;
+ if ( resp->cCode != 0) {
+ *completionCode = resp->cCode;
+ *respDataLen = 0;
+ return ACCESN_OK;
+ }
+
+ /*
+ * Sent ok, wait for GetMessage response
+ */
+ for (i=0; i < 10; i++) /* RETRIES=10 for GetMessage */
+ {
+ //req->req.busType = PUBLIC_BUS; /*=0*/
+ req->req.rsSa = BMC_SA;
+ req->req.cmd = GET_MESSAGE;
+ req->req.netFn = APP_NETFN;
+ req->req.rsLun = BMC_LUN; /*=0*/
+ req->req.dataLength = 0;
+ reqLength = req->req.dataLength + MIN_IMB_REQ_BUF_SIZE;
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ reqLength,
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL);
+ if (fdebug) printf("sendIpmb: get_message status=%d rlen=%d cc=%x\n",
+ status,respLength,resp->cCode);
+ if ( status != TRUE ) {
+ DWORD error;
+ error = GetLastError();
+ return ACCESN_ERROR;
+ }
+ if ( respLength == 0 ) {
+ return ACCESN_ERROR;
+ }
+ if ( (resp->cCode != 0x80) && (resp->cCode != 0x83) )
+ break; /*success, exit loop*/
+ os_usleep(0,1000); /* 1 msec*/
+ } /*end-for*/
+
+ /*
+ * give the caller his response
+ */
+ *completionCode = resp->cCode;
+ *respDataLen = 0;
+ if (( respLength > 1 ) && ( respDataPtr)) {
+ /* check that resp cmd & netfn match */
+ *respDataLen = respLength - 7;
+ memcpy( respDataPtr, &resp->data[7], *respDataLen);
+ }
+ return ACCESN_OK;
+}
+#endif
+
+/*///////////////////////////////////////////////////////////////////////////
+// SendTimedImbpRequest
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: SendTimedImbpRequest
+// Purpose: This function sends a request for BMC implemented function
+// Context: Used by Upper level agents (sis modules) to access BMC implemented functionality.
+// Returns: OK else error status code
+// Parameters:
+// reqPtr
+// timeOut
+// respDataPtr
+// respLen
+// Notes: none
+*F*/
+ACCESN_STATUS
+SendTimedImbpRequest (
+ IMBPREQUESTDATA *reqPtr, /* request info and data */
+ int timeOut, /* how long to wait, in mSec units */
+ BYTE *respDataPtr, /* where to put response data */
+ int *respDataLen, /* how much response data there is */
+ BYTE *completionCode /* request status from bmc controller*/
+ )
+{
+ BYTE responseData[MAX_IMB_REQ_SIZE];
+ ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData;
+ DWORD respLength = sizeof( responseData );
+ DWORD reqLength;
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ BOOL status;
+
+
+ req->req.rsSa = reqPtr->rsSa;
+ req->req.cmd = reqPtr->cmdType;
+ req->req.netFn = reqPtr->netFn;
+ req->req.rsLun = reqPtr->rsLun;
+ req->req.dataLength = (BYTE)reqPtr->dataLength;
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("cmd=%02x, pdata=%p, datalen=%d, size=%d\n", req->req.cmd,
+ reqPtr->data, reqPtr->dataLength, sizeof(requestData));
+#endif
+ memcpy( req->req.data, reqPtr->data, reqPtr->dataLength );
+
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: rsSa 0x%x cmd 0x%x netFn 0x%x rsLun 0x%x\n", __FUNCTION__,
+ req->req.rsSa, req->req.cmd, req->req.netFn, req->req.rsLun);
+#endif
+ reqLength = req->req.dataLength + MIN_IMB_REQ_BUF_SIZE;
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ reqLength,
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl returned status = %d\n",__FUNCTION__, status);
+#endif
+#ifdef DBG_IPMI
+ printf("%s: rsSa %x cmd %x netFn %x lun %x, status=%d, cc=%x, rlen=%d\n",
+ __FUNCTION__, req->req.rsSa, req->req.cmd, req->req.netFn,
+ req->req.rsLun, status, resp->cCode, respLength );
+ dbgmsg("SendTimedImb: rsSa %x cmd %x netFn %x lun %x, status=%d, cc=%x, rlen=%d\n",
+ req->req.rsSa, req->req.cmd, req->req.netFn,
+ req->req.rsLun, status, resp->cCode, respLength );
+ if (req->req.cmd == 0x34) {
+ _dump_buf("requestData",requestData,reqLength,0); //if DBG_IPMI
+ _dump_buf("responseData",responseData,respLength,0); //if DBG_IPMI
+ }
+#endif
+
+ if( status != TRUE ) {
+ DWORD error;
+ error = GetLastError();
+ return ACCESN_ERROR;
+ }
+ if( respLength == 0 ) {
+ return ACCESN_ERROR;
+ }
+
+ /*
+ * give the caller his response
+ */
+ *completionCode = resp->cCode;
+ *respDataLen = 0;
+
+ if(( respLength > 1 ) && ( respDataPtr))
+ {
+ *respDataLen = respLength - 1;
+ memcpy( respDataPtr, resp->data, *respDataLen);
+ }
+
+
+ return ACCESN_OK;
+}
+
+
+/*////////////////////////////////////////////////////////////////////
+// open_imb
+////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: open_imb
+// Purpose: To open imb device
+// Context: Called from each routine to make sure that open is done.
+// Returns: returns 0 for Fail and 1 for Success, sets hDevice to open
+// handle.
+// Parameters: none
+// Notes: none
+*F*/
+#ifdef WIN32
+#define IMB_DEVICE_WIN "\\\\.\\Imb"
+int open_imb(int fskipcmd)
+{
+/* This routine will be called from all other routines before doing any
+ interfacing with imb driver. It will open only once. */
+ IMBPREQUESTDATA requestData;
+ BYTE respBuffer[MAX_IMB_RESP_SIZE];
+ DWORD respLength;
+ BYTE completionCode;
+ int ret;
+
+ set_fps();
+ if (hDevice1 == 0) /*INVALID_HANDLE_VALUE*/
+ {
+ //
+ // Open IMB driver device
+ //
+ hDevice = CreateFile( IMB_DEVICE_WIN,
+ GENERIC_READ | GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL,
+ OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL,
+ NULL
+ );
+ if (hDevice == NULL || hDevice == INVALID_HANDLE_VALUE) {
+ if (fdebug) printf("ipmi_open_ia: error opening %s to imbdrv.sys\n",
+ IMB_DEVICE_WIN);
+ return (0); /*FALSE*/
+ }
+
+ if (fskipcmd) {
+ IpmiVersion = IPMI_15_VERSION;
+ return (1); /*TRUE*/
+ }
+ // Detect the IPMI version for processing requests later.
+ // This is a crude but most reliable method to differentiate
+ // between old IPMI versions and the 1.0 version. If we had used the
+ // version field instead then we would have had to revalidate all the
+ // older platforms (pai 4/27/99)
+ requestData.cmdType = GET_DEVICE_ID;
+ requestData.rsSa = BMC_SA;
+ requestData.rsLun = BMC_LUN;
+ requestData.netFn = APP_NETFN ;
+ requestData.busType = PUBLIC_BUS;
+ requestData.data = NULL;
+ requestData.dataLength = 0;
+ respLength = sizeof(respBuffer);
+ ret = SendTimedImbpRequest ( &requestData, IMB_OPEN_TIMEOUT,
+ respBuffer, &respLength, &completionCode);
+ if ( (ret != ACCESN_OK ) || ( completionCode != 0) )
+ {
+ if (fdebug) /*GetDeviceId failed*/
+ printf("ipmi_open_ia: imbdrv request error, ret=%d ccode=%x\n",
+ ret,completionCode);
+ CloseHandle(hDevice);
+ return (0); /*FALSE*/
+ }
+ hDevice1 = hDevice;
+
+ if (respLength < (IPMI10_GET_DEVICE_ID_RESP_LENGTH-1))
+ IpmiVersion = IPMI_09_VERSION;
+ else {
+ if ( respBuffer[4] == 0x01 )
+ IpmiVersion = IPMI_10_VERSION;
+ else /* IPMI 1.5 or 2.0 */
+ IpmiVersion = IPMI_15_VERSION;
+ }
+ }
+ return (1); /*TRUE*/
+
+} /*end open_imb for Win32 */
+
+#else /* LINUX, SCO_UW, etc. */
+
+int open_imb(int fskipcmd)
+{
+/* This routine will be called from all other routines before doing any
+ interfacing with imb driver. It will open only once. */
+ IMBPREQUESTDATA requestData;
+ BYTE respBuffer[MAX_IMB_RESP_SIZE];
+ int respLength;
+ BYTE completionCode;
+
+ int ret_code;
+
+ set_fps();
+
+ if (hDevice1 == 0)
+ {
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: opening the driver, ioctl_sendmsg = %x\n",
+ __FUNCTION__, ioctl_sendmsg);
+#endif
+ /* %%%%* IOCTL_IMB_SEND_MESSAGE = 0x1082
+ printf("ipmi_open_ia: "
+ "IOCTL_IMB_SEND_MESSAGE =%x \n" "IOCTL_IMB_GET_ASYNC_MSG=%x \n"
+ "IOCTL_IMB_MAP_MEMORY = %x \n" "IOCTL_IMB_UNMAP_MEMORY= %x \n"
+ "IOCTL_IMB_SHUTDOWN_CODE=%x \n" "IOCTL_IMB_REGISTER_ASYNC_OBJ =%x \n"
+ "IOCTL_IMB_DEREGISTER_ASYNC_OBJ=%x \n"
+ "IOCTL_IMB_CHECK_EVENT =%x \n" "IOCTL_IMB_POLL_ASYNC =%x \n",
+ IOCTL_IMB_SEND_MESSAGE, IOCTL_IMB_GET_ASYNC_MSG,
+ IOCTL_IMB_MAP_MEMORY, IOCTL_IMB_UNMAP_MEMORY, IOCTL_IMB_SHUTDOWN_CODE,
+ IOCTL_IMB_REGISTER_ASYNC_OBJ, IOCTL_IMB_DEREGISTER_ASYNC_OBJ,
+ IOCTL_IMB_CHECK_EVENT , IOCTL_IMB_POLL_ASYNC); *%%%%*/
+
+ /*O_NDELAY flag will cause problems later when driver makes
+ //you wait. Hence removing it. */
+ /*if ((hDevice1 = open(IMB_DEVICE,O_RDWR|O_NDELAY)) <0) */
+ if ((hDevice1 = open(IMB_DEVICE,O_RDWR)) <0)
+ {
+ hDevice1 = 0;
+#ifndef WIN32
+ /* dont always display open errors if Linux */
+ if (fdebug)
+#endif
+ {
+ /*debug or not 1st time */
+ printf("imbapi ipmi_open_ia: open(%s) failed, %s\n",
+ IMB_DEVICE,strerror(errno));
+ }
+ return (0);
+ }
+
+ if (fskipcmd) {
+ IpmiVersion = IPMI_15_VERSION;
+ return (1); /*TRUE*/
+ }
+ /* Detect the IPMI version for processing requests later.
+ // This is a crude but most reliable method to differentiate
+ // between old IPMI versions and the 1.0 version. If we had used the
+ // version field instead then we would have had to revalidate all
+ // the older platforms (pai 4/27/99) */
+ requestData.cmdType = GET_DEVICE_ID;
+ requestData.rsSa = BMC_SA;
+ requestData.rsLun = BMC_LUN;
+ requestData.netFn = APP_NETFN ;
+ requestData.busType = PUBLIC_BUS;
+ requestData.data = NULL;
+ requestData.dataLength = 0;
+ respLength = sizeof(respBuffer);
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: opened driver, getting IPMI version\n", __FUNCTION__);
+#endif
+ ret_code = SendTimedImbpRequest(&requestData,
+ IMB_OPEN_TIMEOUT, respBuffer, &respLength,
+ &completionCode);
+ if ( (ret_code != ACCESN_OK) || (completionCode != 0) )
+ {
+ printf("ipmi_open_ia: SendTimedImbpRequest error. Ret = %d CC = 0x%02X\n",
+ ret_code, completionCode);
+ close(hDevice1);
+ hDevice1 = 0;
+ return (0);
+ }
+
+ if (respLength < (IPMI10_GET_DEVICE_ID_RESP_LENGTH-1))
+ IpmiVersion = IPMI_09_VERSION;
+ else {
+ if ( respBuffer[4] == 0x01 )
+ IpmiVersion = IPMI_10_VERSION;
+ else /* IPMI 1.5 or 2.0 */
+ IpmiVersion = IPMI_15_VERSION;
+ }
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: IPMI version 0x%x\n", __FUNCTION__, IpmiVersion);
+#endif
+
+/*
+//initialise a mutex
+ if(mutex_init(&deviceMutex , USYNC_THREAD, NULL) != 0)
+ {
+ return(0);
+ }
+*/
+
+ }
+
+ return (1);
+} /*end open_imb()*/
+
+#endif
+
+int close_imb(void)
+{
+ int rc = 0;
+ if (hDevice1 != 0) {
+#ifdef WIN32
+ CloseHandle(hDevice1);
+#else
+ rc = close(hDevice1);
+#endif
+ }
+ return(rc);
+}
+
+#ifndef LINK_LANDESK
+/* If there is not a LANDESK lib, provide these 2 functions for apps
+ * that may be already be coded to that interface.
+ */
+int initIPMI(void)
+{ /* for compatibility with LanDesk programs*/
+ int rc;
+ rc = open_imb(0); /*sets hDevice1*/
+ if (rc == 1) rc = 0;
+ else rc = -1;
+ return(rc);
+}
+int termIPMI(void)
+{ /* for compatibility with LanDesk programs*/
+ return(close_imb());
+}
+#endif
+
+/*---------------------------------------------------------------------*
+ * ipmi_open_ia & ipmi_close_ia
+ *---------------------------------------------------------------------*/
+int ipmi_open_ia(char fdebugcmd)
+{
+ int rc = 0;
+ fdebug = fdebugcmd;
+ rc = open_imb(0); /*sets hDevice1*/
+ if (rc == 1) rc = 0;
+ else rc = -1;
+ return(rc);
+}
+
+int ipmi_close_ia(void)
+{
+ int rc = 0;
+ rc = close_imb();
+ return(rc);
+}
+
+
+int ipmi_cmdraw_ia(BYTE cmd, BYTE netfn, BYTE lun, BYTE sa, BYTE bus,
+ BYTE *pdata, BYTE sdata, BYTE *presp, int *sresp,
+ BYTE *pcc, char fdebugcmd)
+{
+ IMBPREQUESTDATA requestData;
+ int status = 0;
+ char *imbDev;
+ BYTE * pc;
+ int sz, i;
+#ifndef WIN32
+ struct stat stbuf;
+#endif
+
+ if (fdebug) printf("ipmi_cmdraw_ia(%02x,%02x,%02x,%02x,bus=%02x)\n",
+ cmd,netfn,lun,sa,bus);
+#ifdef METACOMMAND_IPMB /*++++ not used*/
+ if (bus != PUBLIC_BUS) {
+ if (fdebug) printf("ipmi_cmdraw_ia: bus=%x, using ipmb\n",bus);
+ status = ipmi_cmd_ipmb(cmd,netfn,lun,sa,bus,pdata,sdata,presp,sresp,
+ pcc,fdebugcmd);
+ return(status);
+ }
+#endif
+ set_fps();
+
+ requestData.cmdType = cmd;
+ requestData.rsSa = sa;
+ requestData.busType = bus;
+ requestData.netFn = netfn;
+ requestData.rsLun = lun;
+ requestData.dataLength = sdata;
+ requestData.data = pdata;
+
+ if (fdebugcmd) {
+ sz = sizeof(IMBPREQUESTDATA);
+ pc = (BYTE *)&requestData.cmdType;
+ fprintf(fpdbg,"ipmi_cmdraw_ia: request (len=%d): ",sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ pc = requestData.data;
+ sz = requestData.dataLength;
+ fprintf(fpdbg," req.data=%p, dlen=%d: ", pc, sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ }
+
+#ifdef WIN32
+ imbDev = "[imbdrv]";
+ if (1)
+#else
+ imbDev = "/dev/imb";
+ if (stat(imbDev, &stbuf) == -1) {
+ fprintf(fperr,"ipmi_cmdraw_ia: No IMB driver found (%s)\n",imbDev);
+ return(ERR_NO_DRV);
+ } else /* imb device node is there */
+#endif
+ {
+ sz = *sresp; /* note that sresp must be pre-set */
+ memset(presp, 0, sz);
+ for ( i =0 ; i < IMB_MAX_RETRIES; i++)
+ {
+ *sresp = sz; /* retries may need to re-init *sresp */
+#ifdef LOCAL_IPMB
+ if (bus != PUBLIC_BUS)
+ status = SendTimedIpmbpRequest(&requestData, ipmi_timeout_ia, presp, sresp, pcc);
+ else
+#endif
+ status = SendTimedImbpRequest(&requestData, ipmi_timeout_ia, presp, sresp, pcc);
+ if((status) == 0 ) { break; }
+ if (fdebugcmd) // only gets here if error
+ fprintf(fpdbg,"ipmi_cmdraw_ia: sendImbRequest error status=%x, ccode=%x\n",
+ (uint)status, *pcc);
+ }
+ }
+
+ if (fdebugcmd) { /* if debug, show both good and bad statuses */
+ fprintf(fpdbg,"ipmi_cmdraw_ia: sendImbRequest status=%x, ccode=%x\n",
+ (uint)status, *pcc);
+ if (status == 0) {
+ BYTE * pc; int sz;
+ sz = *sresp;
+ pc = (BYTE *)presp;
+ fprintf(fpdbg,"ipmi_cmdraw_ia: response (len=%d): ",sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ }
+ }
+ if (status == 1) status = -3; /*LAN_ERR_RECV_FAIL, a meaningful error*/
+ return(status);
+} /* end ipmi_cmdraw_ia() */
+
+/*---------------------------------------------------------------------*/
+/*Used only by UW. Left here for now. IMB driver will not accept this
+//ioctl. */
+ACCESN_STATUS
+StartAsyncMesgPoll()
+{
+
+ DWORD retLength;
+ BOOL status;
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl cmd = %x\n",__FUNCTION__,IOCTL_IMB_POLL_ASYNC);
+#endif
+ status = DeviceIoControl ( hDevice,
+ IOCTL_IMB_POLL_ASYNC,
+ NULL,
+ 0,
+ NULL,
+ 0,
+ & retLength,
+ 0
+ );
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status == TRUE ) {
+ return ACCESN_OK;
+ } else {
+ return ACCESN_ERROR;
+ }
+
+}
+
+/*/////////////////////////////////////////////////////////////////////////////
+// SendTimedI2cRequest
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: SendTimedI2cRequest
+// Purpose: This function sends a request to a I2C device
+// Context: Used by Upper level agents (sis modules) to access dumb I2c devices
+// Returns: ACCESN_OK else error status code
+// Parameters:
+// reqPtr
+// timeOut
+// respDataPtr
+// respLen
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+SendTimedI2cRequest (
+ I2CREQUESTDATA *reqPtr, /* I2C request */
+ int timeOut, /* how long to wait, mSec units */
+ BYTE *respDataPtr, /* where to put response data */
+ int *respDataLen, /* size of response buffer and */
+ /* size of returned data */
+ BYTE *completionCode /* request status from BMC */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData;
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+
+ struct WriteReadI2C { /* format of a write/read I2C request */
+ BYTE busType;
+ BYTE rsSa;
+ BYTE count;
+ BYTE data[1];
+ } * wrReq = (struct WriteReadI2C *) req->req.data;
+
+#define MIN_WRI2C_SIZE 3 /* size of write/read request minus any data */
+
+
+ /*
+ // If the Imb driver is not present return AccessFailed
+ */
+
+ req->req.rsSa = BMC_SA;
+ req->req.cmd = WRITE_READ_I2C;
+ req->req.netFn = APP_NETFN;
+ req->req.rsLun = BMC_LUN;
+ req->req.dataLength = reqPtr->dataLength + MIN_WRI2C_SIZE;
+
+ wrReq->busType = reqPtr->busType;
+ wrReq->rsSa = reqPtr->rsSa;
+ wrReq->count = reqPtr->numberOfBytesToRead;
+
+ memcpy( wrReq->data, reqPtr->data, reqPtr->dataLength );
+
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof( requestData ),
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE ) {
+ DWORD error;
+ error = GetLastError();
+ return ACCESN_ERROR;
+ }
+ if( respLength == 0 ) {
+ return ACCESN_ERROR;
+ }
+
+ /*
+ // give the caller his response
+ */
+ *completionCode = resp->cCode;
+ *respDataLen = respLength - 1;
+
+ if(( *respDataLen ) && (respDataPtr))
+ memcpy( respDataPtr, resp->data, *respDataLen);
+
+ return ACCESN_OK;
+
+}
+
+/*This is not a API exported by the driver in stricter sense. It is
+//added to support EMP functionality. Upper level software could have
+//implemented this function.(pai 5/4/99) */
+/*/////////////////////////////////////////////////////////////////////////////
+// SendTimedEmpMessageResponse
+///////////////////////////////////////////////////////////////////////////// */
+
+/*F*
+// Name: SendTimedEmpMessageResponse
+// Purpose: This function sends a response message to the EMP port
+// Context:
+// Returns: OK else error status code
+// Parameters:
+//
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+SendTimedEmpMessageResponse (
+ ImbPacket *ptr, /* pointer to the original request from EMP */
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut /* how long to wait, in mSec units */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ /*ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData; */
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ int i,j;
+
+ /*form the response packet first */
+ req->req.rsSa = BMC_SA;
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.cmd = WRITE_EMP_BUFFER;
+ else
+ req->req.cmd = SEND_MESSAGE;
+ req->req.netFn = APP_NETFN;
+ req->req.rsLun = 0;
+
+ i = 0;
+ if (IpmiVersion != IPMI_09_VERSION)
+ req->req.data[i++] = EMP_CHANNEL;
+
+ req->req.data[i++] = ptr->rqSa;
+ req->req.data[i++] = (((ptr->nfLn & 0xfc) | 0x4) | ((ptr->seqLn) & 0x3));
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.data[i++] = ((~(req->req.data[0] + req->req.data[1])) +1);
+ else
+ req->req.data[i++] = ((~(req->req.data[1] + req->req.data[2])) +1);
+
+ req->req.data[i++] = BMC_SA; /*though software is responding, we have to
+ //provide BMCs slave address as responder
+ //address. */
+
+ req->req.data[i++] = ( (ptr->seqLn & 0xfc) | (ptr->nfLn & 0x3) );
+
+ req->req.data[i++] = ptr->cmd;
+ for ( j = 0 ; j < responseDataLen ; ++j,++i)
+ req->req.data[i] = responseDataBuf[j];
+
+ req->req.data[i] = 0;
+ if (IpmiVersion == IPMI_09_VERSION)
+ j = 0;
+ else
+ j = 1;
+ for ( ; j < ( i -3); ++j)
+ req->req.data[i] += req->req.data[j+3];
+ req->req.data[i] = ~(req->req.data[i]) +1;
+ ++i;
+ req->req.dataLength = (BYTE)i;
+
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof(requestData),
+ responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+
+ if ( (status != TRUE) || (respLength != 1) || (responseData[0] != 0) )
+ {
+ return ACCESN_ERROR;
+ }
+ return ACCESN_OK;
+}
+
+
+/*This is not a API exported by the driver in stricter sense. It is added to support
+// EMP functionality. Upper level software could have implemented this function.(pai 5/4/99) */
+/*///////////////////////////////////////////////////////////////////////////
+// SendTimedEmpMessageResponse_Ex
+//////////////////////////////////////////////////////////////////////////// */
+
+/*F*
+// Name: SendTimedEmpMessageResponse_Ex
+// Purpose: This function sends a response message to the EMP port
+// Context:
+// Returns: OK else error status code
+// Parameters:
+//
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+SendTimedEmpMessageResponse_Ex (
+
+ ImbPacket * ptr, /* pointer to the original request from EMP */
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut, /* how long to wait, in mSec units*/
+ BYTE sessionHandle, /*This is introduced in IPMI1.5,this is required to be sent in
+ //send message command as a parameter,which is then used by BMC
+ //to identify the correct DPC session to send the mesage to. */
+ BYTE channelNumber /*There are 3 different channels on which DPC communication goes on
+ //Emp - 1,Lan channel one - 6,Lan channel two(primary channel) - 7. */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ /* ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData; */
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ int i,j;
+
+ /*form the response packet first */
+ req->req.rsSa = BMC_SA;
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.cmd = WRITE_EMP_BUFFER;
+ else
+ req->req.cmd = SEND_MESSAGE;
+ req->req.netFn = APP_NETFN;
+ req->req.rsLun = 0;
+
+ i = 0;
+
+ /*checking for the IPMI version & then assigning the channel number for EMP
+ //Actually the channel number is same in both the versions.This is just to
+ //maintain the consistancy with the same method for LAN.
+ //This is the 1st byte of the SEND MESSAGE command. */
+ if (IpmiVersion == IPMI_10_VERSION)
+ req->req.data[i++] = EMP_CHANNEL;
+ else if (IpmiVersion == IPMI_15_VERSION)
+ req->req.data[i++] = channelNumber;
+
+ /*The second byte of data for SEND MESSAGE starts with session handle */
+ req->req.data[i++] = sessionHandle;
+
+ /*Then it is the response slave address for SEND MESSAGE. */
+ req->req.data[i++] = ptr->rqSa;
+
+ /*Then the net function + lun for SEND MESSAGE command. */
+ req->req.data[i++] = (((ptr->nfLn & 0xfc) | 0x4) | ((ptr->seqLn) & 0x3));
+
+ /*Here the checksum is calculated.The checksum calculation starts after the channel number.
+ //so for the IPMI 1.5 version its a checksum of 3 bytes that is session handle,response slave
+ //address & netfun+lun. */
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.data[i++] = ((~(req->req.data[0] + req->req.data[1])) +1);
+ else
+ {
+ if (IpmiVersion == IPMI_10_VERSION)
+ req->req.data[i++] = ((~(req->req.data[1] + req->req.data[2])) +1);
+ else
+ req->req.data[i++] = ((~(req->req.data[2]+ req->req.data[3])) +1);
+ }
+
+ /*This is the next byte of the message data for SEND MESSAGE command.It is the request
+ //slave address. */
+ req->req.data[i++] = BMC_SA; /*though software is responding, we have to
+ //provide BMCs slave address as responder
+ //address. */
+
+ /*This is just the sequence number,which is the next byte of data for SEND MESSAGE */
+ req->req.data[i++] = ( (ptr->seqLn & 0xfc) | (ptr->nfLn & 0x3) );
+
+ /*The next byte is the command like get software ID(00).*/
+ req->req.data[i++] = ptr->cmd;
+
+ /*after the cmd the data ,which is sent by DPC & is retrived using the get message earlier
+ // is sent back to DPC. */
+ for ( j = 0 ; j < responseDataLen ; ++j,++i)
+ req->req.data[i] = responseDataBuf[j];
+
+ req->req.data[i] = 0;
+
+ /*The last byte of data for SEND MESSAGE command is the check sum ,which is calculated
+ //from the next byte of the previous checksum that is the request slave address. */
+ if (IpmiVersion == IPMI_09_VERSION)
+ j = 0;
+ else
+ {
+ if (IpmiVersion == IPMI_10_VERSION)
+ j = 1;
+ else
+ j = 2;
+ }
+ for ( ; j < ( i -3); ++j)
+ req->req.data[i] += req->req.data[j+3];
+ req->req.data[i] = ~(req->req.data[i]) +1;
+ ++i;
+ req->req.dataLength = (BYTE)i;
+
+ /*The flags & timeouts are used by the driver internally. */
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof(requestData),
+ responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if (fdebug) {
+ printf("SendTimedEmp(%x,%x): status=%d cc=%x rlen=%d i=%d\n",
+ sessionHandle, channelNumber,
+ status,responseData[0],respLength,i);
+ _dump_buf("requestData",requestData,sizeof(requestData),0);
+ }
+ if ( (status != TRUE) || (respLength != 1) || (responseData[0] != 0) )
+ {
+ return ACCESN_ERROR;
+ }
+ return ACCESN_OK;
+
+
+}
+
+/*This is not a API exported by the driver in stricter sense. It is
+//added to support EMP functionality. Upper level software could have
+//implemented this function.(pai 5/4/99) */
+/*///////////////////////////////////////////////////////////////////////////
+// SendTimedLanMessageResponse
+///////////////////////////////////////////////////////////////////////////// */
+
+/*F*
+// Name: SendTimedLanMessageResponse
+// Purpose: This function sends a response message to the DPC Over Lan
+// Context:
+// Returns: OK else error status code
+// Parameters:
+//
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+SendTimedLanMessageResponse(
+ ImbPacket *ptr, /* pointer to the original request from EMP */
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut /* how long to wait, in mSec units */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ /* ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData; */
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ int i,j;
+
+ /*form the response packet first */
+ req->req.rsSa = BMC_SA;
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.cmd = WRITE_EMP_BUFFER;
+ else
+ req->req.cmd = SEND_MESSAGE;
+ req->req.netFn = APP_NETFN;
+
+ /* After discussion with firmware team (Shailendra), the lun number needs to stay at 0
+ // even though the DPC over Lan firmware EPS states that the lun should be 1 for DPC
+ // Over Lan. - Simont (5/17/00) */
+ req->req.rsLun = 0;
+
+ i = 0;
+ if (IpmiVersion != IPMI_09_VERSION)
+ req->req.data[i++] = LAN_CHANNEL;
+
+ req->req.data[i++] = ptr->rqSa;
+ req->req.data[i++] = (((ptr->nfLn & 0xfc) | 0x4) | ((ptr->seqLn) & 0x3));
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.data[i++] = ((~(req->req.data[0] + req->req.data[1])) +1);
+ else
+ req->req.data[i++] = ((~(req->req.data[1] + req->req.data[2])) +1);
+
+ req->req.data[i++] = BMC_SA; /*though software is responding, we have to
+ //provide BMCs slave address as responder
+ //address. */
+
+ req->req.data[i++] = ( (ptr->seqLn & 0xfc) | (ptr->nfLn & 0x3) );
+
+ req->req.data[i++] = ptr->cmd;
+ for ( j = 0 ; j < responseDataLen ; ++j,++i)
+ req->req.data[i] = responseDataBuf[j];
+
+ req->req.data[i] = 0;
+ if (IpmiVersion == IPMI_09_VERSION)
+ j = 0;
+ else
+ j = 1;
+ for ( ; j < ( i -3); ++j)
+ req->req.data[i] += req->req.data[j+3];
+ req->req.data[i] = ~(req->req.data[i]) +1;
+ ++i;
+ req->req.dataLength = (BYTE)i;
+
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof(requestData),
+ responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+
+ if (fdebug) {
+ printf("SendTimedLan(): status=%d cc=%x rlen=%d i=%d\n",
+ status, responseData[0],respLength,i);
+ _dump_buf("requestData",requestData,sizeof(requestData),0);
+ }
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if ( (status != TRUE) || (respLength != 1) || (responseData[0] != 0) )
+ {
+ return ACCESN_ERROR;
+ }
+ return ACCESN_OK;
+}
+
+
+/*This is not a API exported by the driver in stricter sense. It is
+//added to support EMP functionality. Upper level software could have
+//implemented this function.(pai 5/4/99) */
+/*///////////////////////////////////////////////////////////////////////////
+// SendTimedLanMessageResponse_Ex
+///////////////////////////////////////////////////////////////////////////// */
+
+/*F*
+// Name: SendTimedLanMessageResponse_Ex
+// Purpose: This function sends a response message to the DPC Over Lan
+// Context:
+// Returns: OK else error status code
+// Parameters:
+//
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+SendTimedLanMessageResponse_Ex(
+ ImbPacket *ptr, /* pointer to the original request from EMP */
+ char *responseDataBuf,
+ int responseDataLen,
+ int timeOut , /* how long to wait, in mSec units */
+ BYTE sessionHandle, /*This is introduced in IPMI1.5,this is required to be sent in
+ //send message command as a parameter,which is then used by BMC
+ //to identify the correct DPC session to send the mesage to. */
+ BYTE channelNumber /*There are 3 different channels on which DPC communication goes on
+ //Emp - 1,Lan channel one - 6,Lan channel two(primary channel) - 7. */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ /* ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData; */
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+ int i,j;
+
+ /*form the response packet first */
+ req->req.rsSa = BMC_SA;
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.cmd = WRITE_EMP_BUFFER;
+ else
+ req->req.cmd = SEND_MESSAGE;
+ req->req.netFn = APP_NETFN;
+
+ /* After discussion with firmware team (Shailendra), the lun number needs to stay at 0
+ // even though the DPC over Lan firmware EPS states that the lun should be 1 for DPC
+ // Over Lan. - Simont (5/17/00) */
+ req->req.rsLun = 0;
+
+ i = 0;
+
+ /*checking for the IPMI version & then assigning the channel number for Lan accordingly.
+ //This is the 1st byte of the SEND MESSAGE command. */
+ if (IpmiVersion == IPMI_10_VERSION)
+ req->req.data[i++] = LAN_CHANNEL;
+ else if (IpmiVersion == IPMI_15_VERSION)
+ req->req.data[i++] = channelNumber;
+
+ /*The second byte of data for SEND MESSAGE starts with session handle */
+ req->req.data[i++] = sessionHandle;
+
+ /*Then it is the response slave address for SEND MESSAGE. */
+ req->req.data[i++] = ptr->rqSa;
+
+ /*Then the net function + lun for SEND MESSAGE command. */
+ req->req.data[i++] = (((ptr->nfLn & 0xfc) | 0x4) | ((ptr->seqLn) & 0x3));
+
+ /*Here the checksum is calculated.The checksum calculation starts after the channel number.
+ //so for the IPMI 1.5 version its a checksum of 3 bytes that is session handle,response slave
+ //address & netfun+lun. */
+ if (IpmiVersion == IPMI_09_VERSION)
+ req->req.data[i++] = ((~(req->req.data[0] + req->req.data[1])) +1);
+ else
+ {
+ if (IpmiVersion == IPMI_10_VERSION)
+ req->req.data[i++] = ((~(req->req.data[1] + req->req.data[2])) +1);
+ else
+ req->req.data[i++] = ((~(req->req.data[2]+ req->req.data[3])) +1);
+ }
+
+ /*This is the next byte of the message data for SEND MESSAGE command.It is the request
+ //slave address. */
+ req->req.data[i++] = BMC_SA; /*though software is responding, we have to
+ //provide BMC's slave address as responder
+ //address. */
+
+ /*This is just the sequence number,which is the next byte of data for SEND MESSAGE */
+ req->req.data[i++] = ( (ptr->seqLn & 0xfc) | (ptr->nfLn & 0x3) );
+
+ /*The next byte is the command like get software ID(00). */
+ req->req.data[i++] = ptr->cmd;
+
+ /*after the cmd the data ,which is sent by DPC & is retrived using the get message earlier
+ // is sent back to DPC. */
+ for ( j = 0 ; j < responseDataLen ; ++j,++i)
+ req->req.data[i] = responseDataBuf[j];
+
+ req->req.data[i] = 0;
+
+ /*The last byte of data for SEND MESSAGE command is the check sum ,which is calculated
+ //from the next byte of the previous checksum that is the request slave address. */
+ if (IpmiVersion == IPMI_09_VERSION)
+ j = 0;
+ else
+ {
+ if (IpmiVersion == IPMI_10_VERSION)
+ j = 1;
+ else
+ j = 2;
+ }
+ for ( ; j < ( i -3); ++j)
+ req->req.data[i] += req->req.data[j+3];
+ req->req.data[i] = ~(req->req.data[i]) +1;
+ ++i;
+ req->req.dataLength = (BYTE)i;
+
+ /*The flags & timeouts are used by the driver internally */
+ req->flags = 0;
+ req->timeOut = timeOut * 1000; /* convert to uSec units */
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof(requestData),
+ responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+ if (fdebug) {
+ printf("SendTimedLan(%x,%x): status=%d cc=%x rlen=%d i=%d\n",
+ sessionHandle, channelNumber,
+ status,responseData[0],respLength,i);
+ if (responseData[0] != 0) /*0xcc == invalid request data*/
+ {
+ BYTE *pb;
+ pb = (BYTE *)req->req.data;
+ printf("SendMessage data: %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ pb[0], pb[1], pb[2], pb[3], pb[4], pb[5], pb[6], pb[7]);
+ _dump_buf("requestData",requestData,sizeof(requestData),0);
+ }
+ }
+
+ if ( (status != TRUE) || (respLength != 1) || (responseData[0] != 0) )
+ {
+ return ACCESN_ERROR;
+ }
+ return ACCESN_OK;
+}
+
+
+
+/*/////////////////////////////////////////////////////////////////////////
+//SendAsyncImbpRequest
+/////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: SendAsyncImbpRequest
+// Purpose: This function sends a request for Asynchronous IMB implemented function
+// Context: Used by Upper level agents (sis modules) to access Asynchronous IMB implemented functionality.
+// Returns: OK else error status code
+// Parameters:
+// reqPtr Pointer to Async IMB request
+// seqNo Sequence Munber
+// Notes: none
+*F*/
+ACCESN_STATUS
+SendAsyncImbpRequest (
+ IMBPREQUESTDATA *reqPtr, /* request info and data */
+ BYTE * seqNo /* sequence number used in creating IMB msg */
+ )
+{
+
+ BOOL status;
+ BYTE responseData[MAX_IMB_RESP_SIZE];
+ ImbResponseBuffer * resp = (ImbResponseBuffer *) responseData;
+ DWORD respLength = sizeof( responseData );
+ BYTE requestData[MAX_IMB_RESP_SIZE];
+ ImbRequestBuffer * req = (ImbRequestBuffer *) requestData;
+
+ req->req.rsSa = reqPtr->rsSa;
+ req->req.cmd = reqPtr->cmdType;
+ req->req.netFn = reqPtr->netFn;
+ req->req.rsLun = reqPtr->rsLun;
+ req->req.dataLength = (BYTE)reqPtr->dataLength;
+
+ memcpy( req->req.data, reqPtr->data, reqPtr->dataLength );
+
+ req->flags = NO_RESPONSE_EXPECTED;
+ req->timeOut = 0; /* no timeouts for async sends */
+
+ status = DeviceIoControl( hDevice,
+ ioctl_sendmsg,
+ requestData,
+ sizeof( requestData ),
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE ) {
+ DWORD error;
+ error = GetLastError();
+ return ACCESN_ERROR;
+ }
+ if( respLength != 2 ) {
+ return ACCESN_ERROR;
+ }
+ /*
+ // give the caller his sequence number
+ */
+ *seqNo = resp->data[0];
+
+ return ACCESN_OK;
+
+}
+
+/*///////////////////////////////////////////////////////////////////////////
+//GetAsyncImbpMessage
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: GetAsyncImbpMessage
+// Purpose: This function gets the next available async message with a message id
+// greater than SeqNo. The message looks like an IMB packet
+// and the length and Sequence number is returned
+// Context: Used by Upper level agents (sis modules) to access Asynchronous IMB implemented functionality.
+// Returns: OK else error status code
+// Parameters:
+// msgPtr Pointer to Async IMB request
+// msgLen Length
+// timeOut Time to wait
+// seqNo Sequence Munber
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+GetAsyncImbpMessage (
+ ImbPacket * msgPtr, /* request info and data */
+ DWORD *msgLen, /* IN - length of buffer, OUT - msg len */
+ DWORD timeOut, /* how long to wait for the message */
+ ImbAsyncSeq *seqNo, /* previously returned seq number */
+ /* (or ASYNC_SEQ_START) */
+ DWORD channelNumber
+ )
+{
+
+ BOOL status;
+ BYTE responseData[MAX_ASYNC_RESP_SIZE], lun, b;
+ ImbAsyncResponse * resp = (ImbAsyncResponse *) responseData;
+ DWORD respLength = sizeof( responseData );
+ ImbAsyncRequest req;
+ BYTE *msgb;
+
+ while(1)
+ {
+
+
+ if( (msgPtr == NULL) || (msgLen == NULL) || ( seqNo == NULL) )
+ return ACCESN_ERROR;
+
+ msgb = (BYTE *)msgPtr;
+ req.timeOut = timeOut * 1000; /* convert to uSec units */
+ req.lastSeq = *seqNo;
+
+
+ status = DeviceIoControl( hDevice,
+ IOCTL_IMB_GET_ASYNC_MSG,
+ & req,
+ sizeof( req ),
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE ) {
+ DWORD error = GetLastError();
+ /*
+ // handle "msg not available" specially. it is
+ // different from a random old error.
+ */
+ switch( error ) {
+ case IMB_MSG_NOT_AVAILABLE:
+ return ACCESN_END_OF_DATA;
+ default:
+ return ACCESN_ERROR;
+ }
+ return ACCESN_ERROR;
+ }
+ if( respLength < MIN_ASYNC_RESP_SIZE ) {
+ return ACCESN_ERROR;
+ }
+ respLength -= MIN_ASYNC_RESP_SIZE;
+
+ if( *msgLen < respLength ) {
+ return ACCESN_ERROR;
+ }
+
+
+ /*same code as in NT section */
+ if ( IpmiVersion == IPMI_09_VERSION)
+ {
+
+ switch( channelNumber) {
+ case IPMB_CHANNEL:
+ lun = IPMB_LUN;
+ break;
+
+ case EMP_CHANNEL:
+ lun = EMP_LUN;
+ break;
+
+ default:
+ lun = RESERVED_LUN;
+ break;
+ }
+
+ b = (((ImbPacket *)(resp->data))->nfLn) & 0x3;
+ if (channelNumber != ANY_CHANNEL) {
+ if ( (lun == RESERVED_LUN) ||
+ (lun != b) )
+ {
+ *seqNo = resp->thisSeq;
+ continue;
+ }
+ }
+
+ memcpy( msgPtr, resp->data, respLength );
+ *msgLen = respLength;
+ /* Hack to return actual lun */
+ if (channelNumber == ANY_CHANNEL)
+ msgb[respLength] = b;
+ }
+ else
+ {
+ /* it is a 1.0 or above version */
+
+ b = resp->data[0];
+ if ((channelNumber != ANY_CHANNEL) &&
+ (channelNumber != b))
+ {
+ *seqNo = resp->thisSeq;
+ continue;
+ }
+
+ memcpy(msgPtr, &(resp->data[1]), respLength-1);
+ *msgLen = respLength-1;
+ /* Hack to return actual channel */
+ if (channelNumber == ANY_CHANNEL)
+ msgb[respLength-1] = b;
+
+ }
+
+ /*
+ // give the caller his sequence number
+ */
+ *seqNo = resp->thisSeq;
+
+ return ACCESN_OK;
+
+ } /*while (1) */
+}
+
+
+/*///////////////////////////////////////////////////////////////////////////
+//GetAsyncImbpMessage_Ex
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: GetAsyncImbpMessage_Ex
+// Purpose: This function gets the next available async message with a message id
+// greater than SeqNo. The message looks like an IMB packet
+// and the length and Sequence number is returned
+// Context: Used by Upper level agents (sis modules) to access Asynchronous IMB implemented functionality.
+// Returns: OK else error status code
+// Parameters:
+// msgPtr Pointer to Async IMB request
+// msgLen Length
+// timeOut Time to wait
+// seqNo Sequence Munber
+// Notes: none
+*F*/
+
+ACCESN_STATUS
+GetAsyncImbpMessage_Ex (
+ ImbPacket * msgPtr, /* request info and data */
+ DWORD *msgLen, /* IN - length of buffer, OUT - msg len */
+ DWORD timeOut, /* how long to wait for the message */
+ ImbAsyncSeq *seqNo, /* previously returned seq number */
+ /* (or ASYNC_SEQ_START) */
+ DWORD channelNumber,
+ BYTE * sessionHandle,
+ BYTE * privilege
+ )
+{
+
+ BOOL status;
+ BYTE responseData[MAX_ASYNC_RESP_SIZE], lun, b;
+ ImbAsyncResponse * resp = (ImbAsyncResponse *) responseData;
+ DWORD respLength = sizeof( responseData );
+ ImbAsyncRequest req;
+ BYTE *msgb;
+
+ while(1)
+ {
+
+
+ if( (msgPtr == NULL) || (msgLen == NULL) || ( seqNo == NULL) )
+ return ACCESN_ERROR;
+
+ msgb = (BYTE *)msgPtr;
+ req.timeOut = timeOut * 1000; /* convert to uSec units */
+ req.lastSeq = *seqNo;
+
+
+ status = DeviceIoControl( hDevice,
+ IOCTL_IMB_GET_ASYNC_MSG,
+ & req,
+ sizeof( req ),
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ NULL
+ );
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE ) {
+ DWORD error = GetLastError();
+ /*
+ // handle "msg not available" specially. it is
+ // different from a random old error.
+ */
+ switch( error ) {
+ case IMB_MSG_NOT_AVAILABLE:
+ return ACCESN_END_OF_DATA;
+ default:
+ return ACCESN_ERROR;
+ }
+ return ACCESN_ERROR;
+ }
+ if( respLength < MIN_ASYNC_RESP_SIZE ) {
+ return ACCESN_ERROR;
+ }
+ respLength -= MIN_ASYNC_RESP_SIZE;
+
+ if( *msgLen < respLength ) {
+ return ACCESN_ERROR;
+ }
+
+
+ /*same code as in NT section */
+ if ( IpmiVersion == IPMI_09_VERSION)
+ {
+
+ switch( channelNumber) {
+ case IPMB_CHANNEL:
+ lun = IPMB_LUN;
+ break;
+
+ case EMP_CHANNEL:
+ lun = EMP_LUN;
+ break;
+
+ default:
+ lun = RESERVED_LUN;
+ break;
+ }
+
+ b = ((((ImbPacket *)(resp->data))->nfLn) & 0x3);
+ if (channelNumber != ANY_CHANNEL) {
+ if ( (lun == RESERVED_LUN) ||
+ (lun != b) )
+ {
+ *seqNo = resp->thisSeq;
+ continue;
+ }
+ }
+
+ memcpy( msgPtr, resp->data, respLength );
+ *msgLen = respLength;
+ /* Hack to return actual lun */
+ if (channelNumber == ANY_CHANNEL)
+ msgb[respLength] = b;
+
+ }
+ else
+ {
+ if((sessionHandle ==NULL) || (privilege ==NULL))
+ return ACCESN_ERROR;
+
+ /*With the new IPMI version the get message command returns the
+ //channel number along with the privileges.The 1st 4 bits of the
+ //second byte of the response data for get message command represent
+ //the channel number & the last 4 bits are the privileges. */
+ *privilege = (resp->data[0] & 0xf0)>> 4;
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("GetAsy: chan=%x chan_parm=%x\n",resp->data[0],channelNumber);
+#endif
+ b = (resp->data[0] & 0x0f);
+ if ((channelNumber != ANY_CHANNEL) &&
+ (channelNumber != b) )
+ {
+ *seqNo = resp->thisSeq;
+ continue;
+ }
+
+
+ /*The get message command according to IPMI 1.5 spec now even
+ //returns the session handle.This is required to be captured
+ //as it is required as request data for send message command. */
+ *sessionHandle = resp->data[1];
+ memcpy( msgPtr, &(resp->data[2]), respLength-1 );
+ *msgLen = respLength-1;
+
+ /* Hack to return actual channel */
+ if (channelNumber == ANY_CHANNEL)
+ msgb[respLength-1] = b;
+
+ }
+
+ /*
+ // give the caller his sequence number
+ */
+ *seqNo = resp->thisSeq;
+
+ return ACCESN_OK;
+
+ } /*while (1) */
+}
+
+
+
+/*//////////////////////////////////////////////////////////////////////////////
+//IsAsyncMessageAvailable
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: IsMessageAvailable
+// Purpose: This function waits for an Async Message
+//
+// Context: Used by Upper level agents access Asynchronous IMB based
+// messages
+// Returns: OK else error status code
+// Parameters:
+// eventId
+//
+// Notes: This call will block the calling thread if no Async events are
+// are available in the queue.
+//
+*F*/
+ACCESN_STATUS
+IsAsyncMessageAvailable (HandleType eventId )
+{
+ int dummy;
+ int respLength = 0;
+ BOOL status;
+
+ /* confirm that app is not using a bad Id */
+
+
+ if ( AsyncEventHandle != eventId) {
+#ifdef LINUX
+ printf("Invalid AsyncHandle %x!=%x\n",AsyncEventHandle,eventId);
+#endif
+ return ACCESN_ERROR;
+ }
+
+ dummy = 0;
+ status = DeviceIoControl(hDevice,
+ IOCTL_IMB_CHECK_EVENT,
+ &AsyncEventHandle,
+ sizeof(HandleType),
+ &dummy,
+ sizeof(int),
+ (LPDWORD) & respLength,
+ NULL
+ );
+ // if (fdebug)
+ // printf("IsAsyncMessageAvail: status=%d rlen=%d dummy=%x\n",
+ // status, respLength, dummy);
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE )
+ return ACCESN_ERROR;
+
+
+ return ACCESN_OK;
+}
+
+
+/*I have retained this commented code because later we may want to use
+//DPC message specific Processing (pai 11/21) */
+
+#ifdef NOT_COMPILED_BUT_LEFT_HERE_FOR_NOW
+
+/*//////////////////////////////////////////////////////////////////////////////
+//GetAsyncDpcMessage
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: GetAsyncDpcMessage
+// Purpose: This function gets the next available async message from
+// the DPC client.
+//
+// Context: Used by Upper level agents access Asynchronous IMB based
+// messages sent by the DPC client.
+// Returns: OK else error status code
+// Parameters:
+// msgPtr Pointer to Async IMB request
+// msgLen Length
+// timeOut Time to wait
+// seqNo Sequence Munber
+// Notes: This call will block the calling thread if no Async events are
+// are available in the queue.
+//
+*F*/
+
+ACCESN_STATUS
+GetAsyncDpcMessage (
+ ImbPacket * msgPtr, /* request info and data */
+ DWORD * msgLen, /* IN - length of buffer, OUT - msg len */
+ DWORD timeOut, /* how long to wait for the message */
+ ImbAsyncSeq * seqNo, /* previously returned seq number (or ASYNC_SEQ_START) */
+ )
+{
+ BOOL status;
+ BYTE responseData[MAX_ASYNC_RESP_SIZE];
+ ImbAsyncResponse * resp = (ImbAsyncResponse *) responseData;
+ DWORD respLength = sizeof( responseData );
+ ImbAsyncRequest req;
+
+ if( msgPtr == NULL || msgLen == NULL || seqNo == NULL )
+ return ACCESN_ERROR;
+
+ req.lastSeq = *seqNo;
+
+
+ hEvt = CreateEvent (NULL, TRUE, FALSE, NULL) ;
+ if (!hEvt) {
+ return ACCESN_ERROR;
+ }
+
+ status = DeviceIoControl( hDevice,
+ IOCTL_IMB_GET_DPC_MSG,
+ & req,
+ sizeof( req ),
+ & responseData,
+ sizeof( responseData ),
+ & respLength,
+ &ovl
+ );
+
+ if( status != TRUE ) {
+ DWORD error = GetLastError();
+ /*
+ // handle "msg not available" specially. it is different from
+ // a random old error.
+ //
+ */
+ if (!status)
+ {
+ switch (error )
+ {
+ case ERROR_IO_PENDING:
+
+ WaitForSingleObject (hEvt, INFINITE) ;
+ ResetEvent (hEvt) ;
+ break;
+
+ case IMB_MSG_NOT_AVAILABLE:
+
+ CloseHandle(hEvt);
+ return ACCESN_END_OF_DATA;
+
+ default:
+ CloseHandle(hEvt);
+ return ACCESN_ERROR;
+
+ }
+ }
+
+
+
+ if (
+ ( GetOverlappedResult(hDevice,
+ &ovl,
+ (LPDWORD)&respLength,
+ TRUE
+ ) == 0 ) || (respLength <= 0)
+ )
+
+ {
+
+ CloseHandle(hEvt);
+ return ACCESN_ERROR;
+
+ }
+
+
+ }
+
+ if( respLength < MIN_ASYNC_RESP_SIZE ) {
+ CloseHandle(hEvt);
+ return ACCESN_ERROR;
+ }
+
+ respLength -= MIN_ASYNC_RESP_SIZE;
+
+ if( *msgLen < respLength ) {
+
+ /* The following code should have been just return ACCESN_out_of_range */
+ CloseHandle(hEvt);
+ return ACCESN_ERROR;
+ }
+
+ memcpy( msgPtr, resp->data, respLength );
+
+ *msgLen = respLength;
+ /*
+ // give the caller his sequence number
+ */
+ *seqNo = resp->thisSeq;
+
+ CloseHandle(hEvt);
+
+
+ return ACCESN_OK;
+
+}
+#endif /*NOT_COMPILED_BUT_LEFT_HERE_FOR_NOW*/
+
+
+
+/*/////////////////////////////////////////////////////////////////////////////
+//RegisterForImbAsyncMessageNotification
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: RegisterForImbAsyncMessageNotification
+// Purpose: This function Registers the calling application
+// for Asynchronous notification when a sms message
+// is available with the IMB driver.
+//
+// Context: Used by Upper level agents to know that an async
+// SMS message is available with the driver.
+// Returns: OK else error status code
+// Parameters:
+// handleId pointer to the registration handle
+//
+// Notes: The calling application should use the returned handle to
+// get the Async messages..
+*F*/
+ACCESN_STATUS
+RegisterForImbAsyncMessageNotification (HandleType *handleId)
+
+{
+ BOOL status;
+ DWORD respLength ;
+ int dummy;
+
+ /*allow only one app to register */
+
+ if( (handleId == NULL ) || (AsyncEventHandle) )
+ return ACCESN_ERROR;
+
+
+ status = DeviceIoControl(hDevice,
+ IOCTL_IMB_REGISTER_ASYNC_OBJ,
+ &dummy,
+ sizeof( int ),
+ &AsyncEventHandle,
+ sizeof(HandleType),
+ (LPDWORD) & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( (respLength != sizeof(int)) || (status != TRUE )) {
+ if (fdebug) {
+ printf("RegisterForImbAsync error status=%d, len=%d sizeint=%d\n", status, respLength, sizeof(int));
+ if( respLength != sizeof(int)) printf("Async len err\n");
+ if( status != TRUE) printf("Async status err\n");
+ }
+ return ACCESN_ERROR;
+ }
+
+ *handleId = AsyncEventHandle;
+
+#ifndef NO_MACRO_ARGS
+ DEBUG("handleId = %x AsyncEventHandle %x\n", *handleId, AsyncEventHandle);
+#endif
+ return ACCESN_OK;
+}
+
+
+
+
+
+/*/////////////////////////////////////////////////////////////////////////////
+//UnRegisterForImbAsyncMessageNotification
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: UnRegisterForImbAsyncMessageNotification
+// Purpose: This function un-registers the calling application
+// for Asynchronous notification when a sms message
+// is available with the IMB driver.
+//
+// Context: Used by Upper level agents to un-register
+// for async. notification of sms messages
+// Returns: OK else error status code
+// Parameters:
+// handleId pointer to the registration handle
+// iFlag value used to determine where this function was called from
+// _it is used currently on in NetWare environment_
+//
+// Notes:
+*F*/
+ACCESN_STATUS
+UnRegisterForImbAsyncMessageNotification (HandleType handleId, int iFlag)
+
+{
+ BOOL status;
+ DWORD respLength ;
+ int dummy;
+
+ iFlag = iFlag; /* to keep compiler happy We are not using this flag*/
+
+ if ( AsyncEventHandle != handleId)
+ return ACCESN_ERROR;
+
+ status = DeviceIoControl(hDevice,
+ IOCTL_IMB_DEREGISTER_ASYNC_OBJ,
+ &AsyncEventHandle,
+ sizeof(HandleType),
+ &dummy,
+ (DWORD)sizeof(int ),
+ (LPDWORD) & respLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if( status != TRUE )
+ return ACCESN_ERROR;
+
+ return ACCESN_OK;
+}
+
+
+/*///////////////////////////////////////////////////////////////////////////
+// SetShutDownCode
+///////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: SetShutDownCode
+// Purpose: To set the shutdown action code
+// Context: Called by the System Control Subsystem
+// Returns: none
+// Parameters:
+// code shutdown action code which can be either
+// SD_NO_ACTION, SD_RESET, SD_POWER_OFF as defined in imb_if.h
+*F*/
+
+ACCESN_STATUS
+SetShutDownCode (
+ int delayTime, /* time to delay in 100ms units */
+ int code /* what to do when time expires */
+ )
+{
+ DWORD retLength;
+ BOOL status;
+ ShutdownCmdBuffer cmd;
+
+ /*
+ // If Imb driver is not present return AccessFailed
+ */
+ if(hDevice == INVALID_HANDLE_VALUE)
+ return ACCESN_ERROR;
+
+ cmd.code = code;
+ cmd.delayTime = delayTime;
+
+ status = DeviceIoControl( hDevice,
+ IOCTL_IMB_SHUTDOWN_CODE,
+ & cmd,
+ sizeof( cmd ),
+ NULL,
+ 0,
+ & retLength,
+ NULL
+ );
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: DeviceIoControl status = %d\n",__FUNCTION__, status);
+#endif
+
+ if(status == TRUE)
+ return ACCESN_OK;
+ else
+ return ACCESN_ERROR;
+}
+
+#ifdef IMB_MEMORY
+/*/////////////////////////////////////////////////////////////////////////
+// MapPhysicalMemory
+/////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: MapPhysicalMemory
+// Purpose: This function maps specified range of physical memory in calling
+// pocesse's address space
+// Context: Used by Upper level agents (sis modules) to access
+// system physical memory
+// Returns: ACCESN_OK else error status code
+// Parameters:
+//
+// startAddress starting physical address of the memory to be mapped
+// addressLength length of the physical memory to be mapped
+// virtualAddress pointer to the mapped virtual address
+// Notes: none
+*F*/
+/*///////////////////////////////////////////////////////////////////////////
+// UnmapPhysicalMemory
+//////////////////////////////////////////////////////////////////////////// */
+/*F*
+// Name: UnMapPhysicalMemory
+// Purpose: This function unmaps the previously mapped physical memory
+// Context: Used by Upper level agents (sis modules)
+// Returns: ACCESN_OK else error status code
+// Parameters:
+//
+// addressLength length of the physical memory to be mapped
+// virtualAddress pointer to the mapped virtual address
+// Notes: none
+*F*/
+#ifdef WIN32
+ACCESN_STATUS
+MapPhysicalMemory (
+ int startAddress, // physical address to map in
+ int addressLength, // how much to map
+ int *virtualAddress // where it got mapped to
+ )
+{
+ DWORD retLength;
+ BOOL status;
+ PHYSICAL_MEMORY_INFO pmi;
+
+ if ( startAddress == (int) NULL || addressLength <= 0 )
+ return ACCESN_OUT_OF_RANGE;
+
+ pmi.InterfaceType = Internal;
+ pmi.BusNumber = 0;
+ pmi.BusAddress.HighPart = (LONG)0x0;
+ pmi.BusAddress.LowPart = (LONG)startAddress;
+ pmi.AddressSpace = (LONG) 0;
+ pmi.Length = addressLength;
+
+ status = DeviceIoControl ( hDevice,
+ IOCTL_IMB_MAP_MEMORY,
+ & pmi,
+ sizeof(PHYSICAL_MEMORY_INFO),
+ virtualAddress,
+ sizeof(PVOID),
+ & retLength,
+ 0
+ );
+ if( status == TRUE ) {
+ return ACCESN_OK;
+ } else {
+ return ACCESN_ERROR;
+ }
+}
+
+ACCESN_STATUS
+UnmapPhysicalMemory (
+ int virtualAddress, // what memory to unmap
+ int Length )
+{
+ DWORD retLength;
+ BOOL status;
+
+ status = DeviceIoControl ( hDevice,
+ IOCTL_IMB_UNMAP_MEMORY,
+ & virtualAddress,
+ sizeof(PVOID),
+ NULL,
+ 0,
+ & retLength,
+ 0
+ );
+
+ if( status == TRUE ) {
+ return ACCESN_OK;
+ } else {
+ return ACCESN_ERROR;
+ }
+}
+
+#else /*Linux, SCO, UNIX, etc.*/
+
+ACCESN_STATUS
+MapPhysicalMemory(int startAddress,int addressLength, int *virtualAddress )
+{
+ int fd, i;
+ unsigned int length = addressLength;
+ off_t startpAddress = (off_t)startAddress;
+ unsigned int diff;
+ caddr_t startvAddress;
+
+ if ((startAddress == (int) NULL) || (addressLength <= 0))
+ return ACCESN_ERROR;
+
+ if ( (fd = open("/dev/mem", O_RDONLY)) < 0) {
+ char buf[128];
+
+ sprintf(buf,"%s %s: open(%s) failed",
+ __FILE__,__FUNCTION__,"/dev/mem");
+ perror(buf);
+ return ACCESN_ERROR ;
+ }
+
+ /* aliging the offset to a page boundary and adjusting the length */
+ diff = (int)startpAddress % PAGESIZE;
+ startpAddress -= diff;
+ length += diff;
+
+ if ( (startvAddress = mmap( (caddr_t)0,
+ length,
+ PROT_READ,
+ MAP_SHARED,
+ fd,
+ startpAddress
+ ) ) == (caddr_t)-1)
+ {
+ char buf[128];
+
+ sprintf(buf,"%s %s: mmap failed", __FILE__,__FUNCTION__);
+ perror(buf);
+ close(fd);
+ return ACCESN_ERROR;
+ }
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: mmap of 0x%x success\n",__FUNCTION__,startpAddress);
+#endif
+#ifdef LINUX_DEBUG_MAX
+/* dont want this memory dump for normal level of debugging.
+// So, I have put it under a stronger debug symbol. mahendra */
+
+ for(i=0; i < length; i++)
+ {
+ printf("0x%x ", (startvAddress[i]));
+ if(isascii(startvAddress[i])) {
+ printf("%c ", (startvAddress[i]));
+ }
+ }
+#endif /*LINUX_DEBUG_MAX */
+
+ *virtualAddress = (int)(startvAddress + diff);
+ return ACCESN_OK;
+}
+
+ACCESN_STATUS
+UnmapPhysicalMemory( int virtualAddress, int Length )
+{
+ unsigned int diff = 0;
+
+ /* page align the virtual address and adjust length accordingly */
+ diff = ((unsigned int) virtualAddress) % PAGESIZE;
+ virtualAddress -= diff;
+ Length += diff;
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: calling munmap(0x%x,%d)\n",__FUNCTION__,virtualAddress,Length);
+#endif
+
+ if(munmap((caddr_t)virtualAddress, Length) != 0)
+ {
+ char buf[128];
+
+ sprintf(buf,"%s %s: munmap failed", __FILE__,__FUNCTION__);
+ perror(buf);
+ return ACCESN_ERROR;
+
+ }
+#ifndef NO_MACRO_ARGS
+ DEBUG("%s: munmap(0x%x,%d) success\n",__FUNCTION__,virtualAddress,Length);
+#endif
+
+ return ACCESN_OK;
+}
+#endif /*unix*/
+
+#endif /*IMB_MEMORY*/
+
+
+/*/////////////////////////////////////////////////////////////////////////////
+// GetIpmiVersion
+//////////////////////////////////////////////////////////////////////////// */
+
+/*F*
+// Name: GetIpmiVersion
+// Purpose: This function returns current IPMI version
+// Context:
+// Returns: IPMI version
+// Parameters:
+// reqPtr
+// timeOut
+// respDataPtr
+// respLen
+// Notes: svuppula
+*F*/
+BYTE GetIpmiVersion()
+{
+ return ((BYTE)IpmiVersion);
+}
+
+#ifdef IMBDLL
+/* Inlude this routine if building WIN32 imbapi.dll */
+BOOL WINAPI DllMain(HINSTANCE hInstance, ULONG ulReason, LPVOID pvReserved)
+{
+ switch(ulReason)
+ {
+ case DLL_PROCESS_ATTACH:
+ case DLL_THREAD_ATTACH:
+ break;
+ case DLL_PROCESS_DETACH:
+ case DLL_THREAD_DETACH:
+ break;
+ default:
+ return FALSE;
+ }
+ return TRUE;
+}
+#endif
+
+#endif
+/*end of imbapi.c*/
diff --git a/util/ipicmg.c b/util/ipicmg.c
new file mode 100644
index 0000000..c549151
--- /dev/null
+++ b/util/ipicmg.c
@@ -0,0 +1,1911 @@
+/*
+ * ipicmg.c
+ *
+ * This module handles PICMG extended IPMI commands.
+ *
+ * Change History:
+ * 06/03/2010 ARCress - new, included in source tree
+ * 08/15/2011 ARCress - updated with PICMG 2.3
+ *
+ *----------------------------------------------------------------------
+ * Copyright (c) 2010 Kontron. All right reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Kontron, or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * THE COPYRIGHT HOLDER AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL THE
+ * COPYRIGHT HOLDER OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR
+ * DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *----------------------------------------------------------------------
+ */
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include "ipmicmd.h"
+#include "ipicmg.h"
+
+/* Misc PICMG defines */
+#define PICMG_EXTENSION_ATCA_MAJOR_VERSION 2
+#define PICMG_EXTENSION_AMC0_MAJOR_VERSION 4
+#define PICMG_EXTENSION_UTCA_MAJOR_VERSION 5
+
+
+#define PICMG_EKEY_MODE_QUERY 0
+#define PICMG_EKEY_MODE_PRINT_ALL 1
+#define PICMG_EKEY_MODE_PRINT_ENABLED 2
+#define PICMG_EKEY_MODE_PRINT_DISABLED 3
+
+#define PICMG_EKEY_MAX_CHANNEL 16
+#define PICMG_EKEY_MAX_FABRIC_CHANNEL 15
+#define PICMG_EKEY_MAX_INTERFACE 3
+
+#define PICMG_EKEY_AMC_MAX_CHANNEL 16
+#define PICMG_EKEY_AMC_MAX_DEVICE 15 /* 4 bits */
+
+/* Global data */
+static char * progname = "ipicmg";
+static char * progver = "2.93";
+static char fdebug = 0;
+static char fset_mc = 0;
+static uint8_t g_bus = PUBLIC_BUS;
+static uint8_t g_sa = BMC_SA;
+static uint8_t g_lun = BMC_LUN;
+static uint8_t g_addrtype = ADDR_SMI;
+static uint8_t g_fruid = 0;
+static unsigned char PicmgExtMajorVersion;
+
+typedef enum picmg_bused_resource_mode {
+ PICMG_BUSED_RESOURCE_SUMMARY,
+} t_picmg_bused_resource_mode ;
+
+
+typedef enum picmg_card_type {
+ PICMG_CARD_TYPE_CPCI,
+ PICMG_CARD_TYPE_ATCA,
+ PICMG_CARD_TYPE_AMC,
+ PICMG_CARD_TYPE_RESERVED
+} t_picmg_card_type ;
+
+/* This is the version of the PICMG Extenstion */
+static t_picmg_card_type PicmgCardType = PICMG_CARD_TYPE_RESERVED;
+
+const struct valstr picmg_frucontrol_vals[] = {
+ { 0, "Cold Reset" },
+ { 1, "Warm Reset" },
+ { 2, "Graceful Reboot" },
+ { 3, "Issue Diagnostic Interrupt" },
+ { 4, "Quiesce" },
+ { 5, NULL },
+};
+
+const struct valstr picmg_clk_family_vals[] = {
+ { 0x00, "Unspecified" },
+ { 0x01, "SONET/SDH/PDH" },
+ { 0x02, "Reserved for PCI Express" },
+ { 0x03, "Reserved" }, /* from 03h to C8h */
+ { 0xC9, "Vendor defined clock family" }, /* from C9h to FFh */
+ { 0x00, NULL },
+};
+
+const struct oemvalstr picmg_clk_accuracy_vals[] = {
+ { 0x01, 10, "PRS" },
+ { 0x01, 20, "STU" },
+ { 0x01, 30, "ST2" },
+ { 0x01, 40, "TNC" },
+ { 0x01, 50, "ST3E" },
+ { 0x01, 60, "ST3" },
+ { 0x01, 70, "SMC" },
+ { 0x01, 80, "ST4" },
+ { 0x01, 90, "DUS" },
+ { 0x02, 0xE0, "PCI Express Generation 2" },
+ { 0x02, 0xF0, "PCI Express Generation 1" },
+ { 0xffffff, 0x00, NULL }
+};
+
+const struct oemvalstr picmg_clk_resource_vals[] = {
+ { 0x0, 0, "On-Carrier Device 0" },
+ { 0x0, 1, "On-Carrier Device 1" },
+ { 0x1, 1, "AMC Site 1 - A1" },
+ { 0x1, 2, "AMC Site 1 - A2" },
+ { 0x1, 3, "AMC Site 1 - A3" },
+ { 0x1, 4, "AMC Site 1 - A4" },
+ { 0x1, 5, "AMC Site 1 - B1" },
+ { 0x1, 6, "AMC Site 1 - B2" },
+ { 0x1, 7, "AMC Site 1 - B3" },
+ { 0x1, 8, "AMC Site 1 - B4" },
+ { 0x2, 0, "ATCA Backplane" },
+ { 0xffffff, 0x00, NULL }
+};
+
+const struct oemvalstr picmg_clk_id_vals[] = {
+ { 0x0, 0, "Clock 0" },
+ { 0x0, 1, "Clock 1" },
+ { 0x0, 2, "Clock 2" },
+ { 0x0, 3, "Clock 3" },
+ { 0x0, 4, "Clock 4" },
+ { 0x0, 5, "Clock 5" },
+ { 0x0, 6, "Clock 6" },
+ { 0x0, 7, "Clock 7" },
+ { 0x0, 8, "Clock 8" },
+ { 0x0, 9, "Clock 9" },
+ { 0x0, 10, "Clock 10" },
+ { 0x0, 11, "Clock 11" },
+ { 0x0, 12, "Clock 12" },
+ { 0x0, 13, "Clock 13" },
+ { 0x0, 14, "Clock 14" },
+ { 0x0, 15, "Clock 15" },
+ { 0x1, 1, "TCLKA" },
+ { 0x1, 2, "TCLKB" },
+ { 0x1, 3, "TCLKC" },
+ { 0x1, 4, "TCLKD" },
+ { 0x1, 5, "FLCKA" },
+ { 0x2, 1, "CLK1A" },
+ { 0x2, 2, "CLK1A" },
+ { 0x2, 3, "CLK1A" },
+ { 0x2, 4, "CLK1A" },
+ { 0x2, 5, "CLK1A" },
+ { 0x2, 6, "CLK1A" },
+ { 0x2, 7, "CLK1A" },
+ { 0x2, 8, "CLK1A" },
+ { 0x2, 9, "CLK1A" },
+ { 0xffffff, 0x00, NULL }
+};
+
+const struct valstr picmg_busres_id_vals[] = {
+ { 0x0, "Metallic Test Bus pair #1" },
+ { 0x1, "Metallic Test Bus pair #2" },
+ { 0x2, "Synch clock group 1 (CLK1)" },
+ { 0x3, "Synch clock group 2 (CLK2)" },
+ { 0x4, "Synch clock group 3 (CLK3)" },
+ { 0x5, NULL }
+};
+const struct valstr picmg_busres_board_cmd_vals[] = {
+ { 0x0, "Query" },
+ { 0x1, "Release" },
+ { 0x2, "Force" },
+ { 0x3, "Bus Free" },
+ { 0x4, NULL }
+};
+
+const struct valstr picmg_busres_shmc_cmd_vals[] = {
+ { 0x0, "Request" },
+ { 0x1, "Relinquish" },
+ { 0x2, "Notify" },
+ { 0x3, NULL }
+};
+
+const struct oemvalstr picmg_busres_board_status_vals[] = {
+ { 0x0, 0x0, "In control" },
+ { 0x0, 0x1, "No control" },
+ { 0x1, 0x0, "Ack" },
+ { 0x1, 0x1, "Refused" },
+ { 0x1, 0x2, "No control" },
+ { 0x2, 0x0, "Ack" },
+ { 0x2, 0x1, "No control" },
+ { 0x3, 0x0, "Accept" },
+ { 0x3, 0x1, "Not Needed" },
+ { 0xffffff, 0x00, NULL }
+};
+
+const struct oemvalstr picmg_busres_shmc_status_vals[] = {
+ { 0x0, 0x0, "Grant" },
+ { 0x0, 0x1, "Busy" },
+ { 0x0, 0x2, "Defer" },
+ { 0x0, 0x3, "Deny" },
+
+ { 0x1, 0x0, "Ack" },
+ { 0x1, 0x1, "Error" },
+
+ { 0x2, 0x0, "Ack" },
+ { 0x2, 0x1, "Error" },
+ { 0x2, 0x2, "Deny" },
+
+ { 0xffffff, 0x00, NULL }
+};
+
+void
+ipmi_picmg_help (void)
+{
+ printf(" properties - get PICMG properties\n");
+ printf(" frucontrol - FRU control\n");
+ printf(" addrinfo - get address information\n");
+ printf(" activate - activate a FRU\n");
+ printf(" deactivate - deactivate a FRU\n");
+ printf(" policy get - get the FRU activation policy\n");
+ printf(" policy set - set the FRU activation policy\n");
+ printf(" portstate get - get port state \n");
+ printf(" portstate getdenied - get all denied[disabled] port description\n");
+ printf(" portstate getgranted - get all granted[enabled] port description\n");
+ printf(" portstate getall - get all port state description\n");
+ printf(" portstate set - set port state \n");
+ printf(" amcportstate get - get port state \n");
+ printf(" amcportstate set - set port state \n");
+ printf(" led prop - get led properties\n");
+ printf(" led cap - get led color capabilities\n");
+ printf(" led get - get led state\n");
+ printf(" led set - set led state\n");
+ printf(" power get - get power level info\n");
+ printf(" power set - set power level\n");
+ printf(" clk get - get clk state\n");
+ printf(" clk getdenied - get all(up to 16) denied[disabled] clock descriptions\n");
+ printf(" clk getgranted - get all(up to 16) granted[enabled] clock descriptions\n");
+ printf(" clk getall - get all(up to 16) clock descriptions\n");
+ printf(" clk set - set clk state\n");
+ printf(" busres summary - display brief bused resource status info \n");
+}
+
+struct sAmcAddrMap {
+ unsigned char ipmbLAddr;
+ char* amcBayId;
+ unsigned char siteNum;
+} amcAddrMap[] = {
+ {0xFF, "reserved", 0},
+ {0x72, "A1" , 1},
+ {0x74, "A2" , 2},
+ {0x76, "A3" , 3},
+ {0x78, "A4" , 4},
+ {0x7A, "B1" , 5},
+ {0x7C, "B2" , 6},
+ {0x7E, "B3" , 7},
+ {0x80, "B4" , 8},
+ {0x82, "reserved", 0},
+ {0x84, "reserved", 0},
+ {0x86, "reserved", 0},
+ {0x88, "reserved", 0},
+};
+
+int
+ipmi_picmg_getaddr(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char msg_data[5];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_ADDRESS_INFO_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+ msg_data[0] = 0; /* picmg identifier */
+ msg_data[1] = 0; /* default fru id */
+
+ if(argc > 0) {
+ msg_data[1] = (uint8_t)strtoul(argv[0], NULL,0); /* FRU ID */
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting address information CC: 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf("Hardware Address : 0x%02x\n", rsp[1]);
+ printf("IPMB-0 Address : 0x%02x\n", rsp[2]);
+ printf("FRU ID : 0x%02x\n", rsp[4]);
+ printf("Site ID : 0x%02x\n", rsp[5]);
+
+ printf("Site Type : ");
+ switch (rsp[6]) {
+ case PICMG_ATCA_BOARD:
+ printf("ATCA board\n");
+ break;
+ case PICMG_POWER_ENTRY:
+ printf("Power Entry Module\n");
+ break;
+ case PICMG_SHELF_FRU:
+ printf("Shelf FRU\n");
+ break;
+ case PICMG_DEDICATED_SHMC:
+ printf("Dedicated Shelf Manager\n");
+ break;
+ case PICMG_FAN_TRAY:
+ printf("Fan Tray\n");
+ break;
+ case PICMG_FAN_FILTER_TRAY:
+ printf("Fan Filter Tray\n");
+ break;
+ case PICMG_ALARM:
+ printf("Alarm module\n");
+ break;
+ case PICMG_AMC:
+ printf("AMC");
+ printf(" -> IPMB-L Address: 0x%02x\n", amcAddrMap[rsp[5]].ipmbLAddr);
+ break;
+ case PICMG_PMC:
+ printf("PMC\n");
+ break;
+ case PICMG_RTM:
+ printf("RTM\n");
+ break;
+ default:
+ if (rsp[6] >= 0xc0 && rsp[6] <= 0xcf) {
+ printf("OEM\n");
+ } else {
+ printf("unknown\n");
+ }
+ }
+
+ return 0;
+}
+
+int
+ipmi_picmg_properties(void * intf, int show )
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ unsigned char PicmgExtMajorVersion;
+ struct ipmi_rq req;
+ unsigned char msg_data;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_PICMG_PROPERTIES_CMD;
+ req.msg.data = &msg_data;
+ req.msg.data_len = 1;
+ msg_data = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error %d getting picmg properties\n", rv);
+ return rv;
+ }
+
+ if( show )
+ {
+ printf("PICMG identifier : 0x%02x\n", rsp[0]);
+ printf("PICMG Ext. Version : %i.%i\n", rsp[1]&0x0f,
+ (rsp[1]&0xf0) >> 4);
+ printf("Max FRU Device ID : 0x%02x\n", rsp[2]);
+ printf("FRU Device ID : 0x%02x\n", rsp[3]);
+ }
+
+ /* We cache the major extension version ...
+ to know how to format some commands */
+ PicmgExtMajorVersion = rsp[1]&0x0f;
+
+ if( PicmgExtMajorVersion == PICMG_CPCI_MAJOR_VERSION ) {
+ PicmgCardType = PICMG_CARD_TYPE_CPCI;
+ }
+ else if( PicmgExtMajorVersion == PICMG_ATCA_MAJOR_VERSION) {
+ PicmgCardType = PICMG_CARD_TYPE_ATCA;
+ }
+ else if( PicmgExtMajorVersion == PICMG_AMC_MAJOR_VERSION) {
+ PicmgCardType = PICMG_CARD_TYPE_AMC;
+ }
+
+ return 0;
+}
+
+
+
+#define PICMG_FRU_DEACTIVATE (unsigned char) 0x00
+#define PICMG_FRU_ACTIVATE (unsigned char) 0x01
+
+int
+ipmi_picmg_fru_activation(void * intf, int argc, char ** argv, unsigned char state)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ struct picmg_set_fru_activation_cmd cmd;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_FRU_ACTIVATION_CMD;
+ req.msg.data = (unsigned char*) &cmd;
+ req.msg.data_len = 3;
+
+ cmd.picmg_id = 0; /* PICMG identifier */
+ cmd.fru_id = atob(argv[0]); /* FRU ID */
+ cmd.fru_state = state;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error %d on activation/deactivation of FRU\n",rv);
+ return rv;
+ }
+ if (rsp[0] != 0x00) {
+ printf("Error, invalid response\n");
+ }
+
+ return 0;
+}
+
+
+int
+ipmi_picmg_fru_activation_policy_get(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[4];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_FRU_POLICY_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+
+ msg_data[0] = 0; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU ID */
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf(" %s\n", ((rsp[1] & 0x01) == 0x01) ?
+ "activation locked" : "activation not locked");
+ printf(" %s\n", ((rsp[1] & 0x02) == 0x02) ?
+ "deactivation locked" : "deactivation not locked");
+
+ return 0;
+}
+
+int
+ipmi_picmg_fru_activation_policy_set(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[4];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_SET_FRU_POLICY_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ msg_data[0] = 0; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU ID */
+ msg_data[2] = atob(argv[1])& 0x03; /* FRU act policy mask */
+ msg_data[3] = atob(argv[2])& 0x03; /* FRU act policy set bits */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+#define PICMG_MAX_LINK_PER_CHANNEL 4
+
+int
+ipmi_picmg_portstate_get(void * intf, int interfc, uchar channel, int mode)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char msg_data[4];
+ struct fru_picmgext_link_desc* d; /* descriptor pointer for rec. data */
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_PORT_STATE_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = (interfc & 0x3)<<6; /* interface */
+ msg_data[1] |= (channel & 0x3F); /* channel number */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else if( mode == PICMG_EKEY_MODE_QUERY )
+ printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ if (rsp_len >= 6) {
+ int index;
+ /* add support for more than one link per channel */
+ for(index=0;index<PICMG_MAX_LINK_PER_CHANNEL;index++){
+ if( rsp_len > (1+ (index*5))){
+ d = (struct fru_picmgext_link_desc *) &(rsp[1 + (index*5)]);
+
+ if
+ (
+ mode == PICMG_EKEY_MODE_PRINT_ALL
+ ||
+ mode == PICMG_EKEY_MODE_QUERY
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_ENABLED
+ &&
+ rsp[5 + (index*5) ] == 0x01
+ )
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_DISABLED
+ &&
+ rsp[5 + (index*5) ] == 0x00
+ )
+ )
+ {
+ printf(" Link Grouping ID: 0x%02x\n", d->grouping);
+ printf(" Link Type Extension: 0x%02x\n", d->ext);
+ printf(" Link Type: 0x%02x ", d->type);
+ if (d->type == 0 || d->type == 0xff)
+ {
+ printf("Reserved %d\n",d->type);
+ }
+ else if (d->type >= 0x06 && d->type <= 0xef)
+ {
+ printf("Reserved %d\n",d->type);
+ }
+ else if (d->type >= 0xf0 && d->type <= 0xfe)
+ {
+ printf("OEM GUID Definition %d\n",d->type);
+ }
+ else
+ {
+ switch (d->type)
+ {
+ case FRU_PICMGEXT_LINK_TYPE_BASE:
+ printf("PICMG 3.0 Base Interface 10/100/1000\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET:
+ printf("PICMG 3.1 Ethernet Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND:
+ printf("PICMG 3.2 Infiniband Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR:
+ printf("PICMG 3.3 Star Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_LINK_TYPE_PCIE:
+ printf("PCI Express Fabric Interface\n");
+ break;
+ default:
+ printf("Invalid\n");
+ break;
+ }
+ }
+ printf(" Link Designator: \n");
+ printf(" Port Flag: 0x%02x\n", d->desig_port);
+ printf(" Interface: 0x%02x - ", d->desig_if);
+ switch (d->desig_if)
+ {
+ case FRU_PICMGEXT_DESIGN_IF_BASE:
+ printf("Base Interface\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_FABRIC:
+ printf("Fabric Interface\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL:
+ printf("Update Channel\n");
+ break;
+ case FRU_PICMGEXT_DESIGN_IF_RESERVED:
+ printf("Reserved\n");
+ break;
+ default:
+ printf("Invalid");
+ break;
+ }
+ printf(" Channel Number: 0x%02x\n", d->desig_channel);
+ printf(" STATE: %s\n",
+ ( rsp[5 +(index*5)] == 0x01) ?"enabled":"disabled");
+ printf("\n");
+ }
+ }
+ }
+ }
+ else
+ {
+ printf("Unexpected answer len %d, can't print result\n",rsp_len);
+ }
+
+ return 0;
+}
+
+
+int
+ipmi_picmg_portstate_set(void * intf, int interfc, uchar channel,
+ uchar port, int type, int typeext, int group, int enable)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char msg_data[6];
+ // struct fru_picmgext_link_desc* d;
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_SET_PORT_STATE_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 6;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = (channel & 0x3f) | ((interfc & 3) << 6);
+ msg_data[2] = (port & 0xf) | ((type & 0xf) << 4);
+ msg_data[3] = ((type >> 4) & 0xf) | ((typeext & 0xf) << 4);
+ msg_data[4] = group & 0xff;
+ msg_data[5] = (unsigned char) (enable & 0x01); /* en/dis */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+
+
+/* AMC.0 commands */
+
+#define PICMG_AMC_MAX_LINK_PER_CHANNEL 4
+
+int
+ipmi_picmg_amc_portstate_get(void * intf,int device,uchar channel,
+ int mode)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[4];
+
+ struct fru_picmgext_amc_link_info* d; /* descriptor pointer for rec. data */
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_AMC_GET_PORT_STATE_CMD;
+ req.msg.data = msg_data;
+
+ /* FIXME : add check for AMC or carrier device */
+ if(device == -1 || PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ req.msg.data_len = 2; /* for amc only channel */
+ }else{
+ req.msg.data_len = 3; /* for carrier channel and device */
+ }
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = channel ;
+ msg_data[2] = (uchar)device ;
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else if ( mode == PICMG_EKEY_MODE_QUERY )
+ printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ if (rsp_len >= 5) {
+ int index;
+
+ /* add support for more than one link per channel */
+ for(index=0;index<PICMG_AMC_MAX_LINK_PER_CHANNEL;index++){
+
+ if( rsp_len > (1+ (index*4))){
+ unsigned char type;
+ unsigned char ext;
+ unsigned char grouping;
+ unsigned char port;
+ unsigned char enabled;
+ d = (struct fru_picmgext_amc_link_info *)&(rsp[1 + (index*4)]);
+
+
+ /* Removed endianness check here, probably not required
+ as we dont use bitfields */
+ port = d->linkInfo[0] & 0x0F;
+ type = ((d->linkInfo[0] & 0xF0) >> 4 )|(d->linkInfo[1] & 0x0F );
+ ext = ((d->linkInfo[1] & 0xF0) >> 4 );
+ grouping = d->linkInfo[2];
+
+
+ enabled = rsp[4 + (index*4) ];
+
+ if
+ (
+ mode == PICMG_EKEY_MODE_PRINT_ALL
+ ||
+ mode == PICMG_EKEY_MODE_QUERY
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_ENABLED
+ &&
+ enabled == 0x01
+ )
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_DISABLED
+ &&
+ enabled == 0x00
+ )
+ )
+ {
+ if(device == -1 || PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ printf(" Link device : AMC\n");
+ }else{
+ printf(" Link device : 0x%02x\n", device );
+ }
+
+ printf(" Link Grouping ID: 0x%02x\n", grouping);
+
+ if (type == 0 || type == 1 ||type == 0xff)
+ {
+ printf(" Link Type Extension: 0x%02x\n", ext);
+ printf(" Link Type: Reserved\n");
+ }
+ else if (type >= 0xf0 && type <= 0xfe)
+ {
+ printf(" Link Type Extension: 0x%02x\n", ext);
+ printf(" Link Type: OEM GUID Definition\n");
+ }
+ else
+ {
+ if (type <= FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE )
+ {
+ printf(" Link Type Extension: %s\n",
+ amc_link_type_ext_str[type][ext]);
+ printf(" Link Type: %s\n",
+ amc_link_type_str[type]);
+ }
+ else{
+ printf(" Link Type Extension: 0x%02x\n", ext);
+ printf(" Link Type: undefined\n");
+ }
+ }
+ printf(" Link Designator: \n");
+ printf(" Channel Number: 0x%02x\n", channel);
+ printf(" Port Flag: 0x%02x\n", port );
+ printf(" STATE: %s\n",
+ ( enabled == 0x01 )?"enabled":"disabled");
+ printf("\n");
+ }
+ }
+ }
+ }
+ else
+ {
+ printf("ipmi_picmg_amc_portstate_get: "
+ "Unexpected answer, can't print result\n");
+ }
+
+ return 0;
+}
+
+
+int
+ipmi_picmg_amc_portstate_set(void * intf, uchar channel, uchar port,
+ int type, int typeext, int group, int enable, int device)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char msg_data[7];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_AMC_SET_PORT_STATE_CMD;
+ req.msg.data = msg_data;
+
+ msg_data[0] = 0x00; /* PICMG identifier*/
+ msg_data[1] = channel; /* channel id */
+ msg_data[2] = port & 0xF; /* port flags */
+ msg_data[2] |= (type & 0x0F)<<4; /* type */
+ msg_data[3] = (type & 0xF0)>>4; /* type */
+ msg_data[3] |= (typeext & 0x0F)<<4; /* extension */
+ msg_data[4] = (group & 0xFF); /* group */
+ msg_data[5] = (enable & 0x01); /* state */
+ req.msg.data_len = 6;
+
+ /* device id - only for carrier needed */
+ if (device >= 0) {
+ msg_data[6] = (uchar)device;
+ req.msg.data_len = 7;
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+
+int
+ipmi_picmg_get_led_properties(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_FRU_LED_PROPERTIES_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf("General Status LED Properties: 0x%2x\n\r", rsp[1] );
+ printf("App. Specific LED Count: 0x%2x\n\r", rsp[2] );
+
+ return 0;
+}
+
+int
+ipmi_picmg_get_led_capabilities(void * intf, int argc, char ** argv)
+{
+ int i;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_LED_COLOR_CAPABILITIES_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* LED-ID */
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf("LED Color Capabilities: %02x", rsp[1] );
+ for ( i=0 ; i<8 ; i++ ) {
+ if ( rsp[1] & (0x01 << i) ) {
+ printf("%s, ", led_color_str[ i ]);
+ }
+ }
+ printf("\n\r");
+
+ printf("Default LED Color in\n\r");
+ printf(" LOCAL control: %s\n\r", led_color_str[ rsp[2] ] );
+ printf(" OVERRIDE state: %s\n\r", led_color_str[ rsp[3] ] );
+
+ return 0;
+}
+
+int
+ipmi_picmg_get_led_state(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_FRU_LED_STATE_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* LED-ID */
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf("LED states: %x ", rsp[1] );
+ if (rsp[1] == 0x1)
+ printf("[LOCAL CONTROL]\n\r");
+ else if (rsp[1] == 0x2)
+ printf("[OVERRIDE]\n\r");
+ else if (rsp[1] == 0x4)
+ printf("[LAMPTEST]\n\r");
+ else
+ printf("\n\r");
+
+ printf(" Local Control function: %x ", rsp[2] );
+ if (rsp[2] == 0x0)
+ printf("[OFF]\n\r");
+ else if (rsp[2] == 0xff)
+ printf("[ON]\n\r");
+ else
+ printf("[BLINKING]\n\r");
+
+ printf(" Local Control On-Duration: %x\n\r", rsp[3] );
+ printf(" Local Control Color: %x [%s]\n\r", rsp[4], led_color_str[ rsp[4] ]);
+
+ /* override state or lamp test */
+ if (rsp[1] == 0x02) {
+ printf(" Override function: %x ", rsp[5] );
+ if (rsp[2] == 0x0)
+ printf("[OFF]\n\r");
+ else if (rsp[2] == 0xff)
+ printf("[ON]\n\r");
+ else
+ printf("[BLINKING]\n\r");
+
+ printf(" Override On-Duration: %x\n\r", rsp[6] );
+ printf(" Override Color: %x [%s]\n\r", rsp[7], led_color_str[ rsp[7] ]);
+
+ }else if (rsp[1] == 0x06) {
+ printf(" Override function: %x ", rsp[5] );
+ if (rsp[2] == 0x0)
+ printf("[OFF]\n\r");
+ else if (rsp[2] == 0xff)
+ printf("[ON]\n\r");
+ else
+ printf("[BLINKING]\n\r");
+ printf(" Override On-Duration: %x\n\r", rsp[6] );
+ printf(" Override Color: %x [%s]\n\r", rsp[7], led_color_str[ rsp[7] ]);
+ printf(" Lamp test duration: %x\n\r", rsp[8] );
+ }
+
+ return 0;
+}
+
+int
+ipmi_picmg_set_led_state(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_SET_FRU_LED_STATE_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 6;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* LED-ID */
+ msg_data[3] = atob(argv[2]); /* LED function */
+ msg_data[4] = atob(argv[3]); /* LED on duration */
+ msg_data[5] = atob(argv[4]); /* LED color */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+
+ return 0;
+}
+
+int
+ipmi_picmg_get_power_level(void * intf, int argc, char ** argv)
+{
+ int i;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_GET_POWER_LEVEL_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* Power type */
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ printf("Dynamic Power Configuration: %s\n", (rsp[1]&0x80)==0x80?"enabled":"disabled" );
+ printf("Actual Power Level: %i\n", (rsp[1] & 0xf));
+ printf("Delay to stable Power: %i\n", rsp[2]);
+ printf("Power Multiplier: %i\n", rsp[3]);
+
+
+ for ( i = 1; i+3 < rsp_len ; i++ ) {
+ printf(" Power Draw %i: %i\n", i, (rsp[i+3]) * rsp[3] / 10);
+ }
+ return 0;
+}
+
+int
+ipmi_picmg_set_power_level(void * intf, int argc, char ** argv)
+{
+ // int i;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_SET_POWER_LEVEL_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* power level */
+ msg_data[3] = atob(argv[2]); /* present to desired */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+int
+ipmi_picmg_bused_resource(void * intf, t_picmg_bused_resource_mode mode)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+ memset(&req, 0, sizeof(req));
+
+ switch ( mode ) {
+ case PICMG_BUSED_RESOURCE_SUMMARY:
+ {
+ t_picmg_busres_resource_id resource;
+ t_picmg_busres_board_cmd_types cmd =PICMG_BUSRES_BOARD_CMD_QUERY;
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_BUSED_RESOURCE_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+ /* IF BOARD
+ query for all resources
+ */
+ for( resource=PICMG_BUSRES_METAL_TEST_BUS_1;resource<=PICMG_BUSRES_SYNC_CLOCK_GROUP_3;resource+=(t_picmg_busres_resource_id)1 ) {
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = (unsigned char) cmd;
+ msg_data[2] = (unsigned char) resource;
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("bused resource control: no response\n");
+ else printf("bused resource control: returned Completion Code 0x%02x\n",rv);
+ return rv;
+ } else {
+ printf("Resource 0x%02x '%-26s' : 0x%02x [%s] \n" ,
+ resource, val2str(resource,picmg_busres_id_vals),
+ rsp[1], oemval2str(cmd,rsp[1],
+ picmg_busres_board_status_vals));
+ }
+ }
+ }
+ break;
+ default: rv = -1;
+ break;
+ }
+
+ return rv;
+}
+
+int
+ipmi_picmg_fru_control(void * intf, int argc, char ** argv)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_FRU_CONTROL_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = atob(argv[0]); /* FRU-ID */
+ msg_data[2] = atob(argv[1]); /* control option */
+
+ printf("FRU Device Id: %d FRU Control Option: %s\n\r", msg_data[1], \
+ val2str( msg_data[2], picmg_frucontrol_vals));
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("frucontrol: no response\n");
+ else printf("frucontrol: returned Completion Code 0x%02x\n",rv);
+ return rv;
+ } else {
+ printf("frucontrol: ok\n");
+ }
+
+ return 0;
+}
+
+
+int
+ipmi_picmg_clk_get(void * intf, int clk_id,int clk_res,int mode)
+{
+ // int i;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char enabled;
+ unsigned char direction;
+
+ unsigned char msg_data[6];
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_AMC_GET_CLK_STATE_CMD;
+ req.msg.data = msg_data;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = clk_id;
+
+ if(clk_res == -1 || PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ req.msg.data_len = 2; /* for amc only channel */
+ }else{
+ req.msg.data_len = 3; /* for carrier channel and device */
+ msg_data[2] = clk_res;
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ {
+ enabled = (rsp[1]&0x8)!=0;
+ direction = (rsp[1]&0x4)!=0;
+
+ if
+ (
+ mode == PICMG_EKEY_MODE_QUERY
+ ||
+ mode == PICMG_EKEY_MODE_PRINT_ALL
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_DISABLED
+ &&
+ enabled == 0
+ )
+ ||
+ (
+ mode == PICMG_EKEY_MODE_PRINT_ENABLED
+ &&
+ enabled == 1
+ )
+ ) {
+ if( PicmgCardType != PICMG_CARD_TYPE_AMC ) {
+ printf("CLK resource id : %3d [ %s ]\n", clk_res ,
+ oemval2str( ((clk_res>>6)&0x03), (clk_res&0x0F),
+ picmg_clk_resource_vals));
+ } else {
+ printf("CLK resource id : N/A [ AMC Module ]\n");
+ clk_res = 0x40; /* Set */
+ }
+ printf("CLK id : %3d [ %s ]\n", clk_id,
+ oemval2str( ((clk_res>>6)&0x03), clk_id ,
+ picmg_clk_id_vals));
+
+
+ printf("CLK setting : 0x%02x\n", rsp[1]);
+ printf(" - state: %s\n", (enabled)?"enabled":"disabled");
+ printf(" - direction: %s\n", (direction)?"Source":"Receiver");
+ printf(" - PLL ctrl: 0x%x\n", rsp[1]&0x3);
+
+ if(enabled){
+ unsigned long freq = 0;
+ freq = ( rsp[5] << 0
+ | rsp[6] << 8
+ | rsp[7] << 16
+ | rsp[8] << 24 );
+ printf(" - Index: %3d\n", rsp[2]);
+ printf(" - Family: %3d [ %s ]\n", rsp[3],
+ val2str( rsp[3], picmg_clk_family_vals));
+ printf(" - AccLVL: %3d [ %s ]\n", rsp[4],
+ oemval2str(rsp[3],rsp[4],picmg_clk_accuracy_vals));
+ printf(" - Freq: %d\n", freq);
+ }
+ }
+ }
+ return 0;
+}
+
+
+int
+ipmi_picmg_clk_set(void * intf, int argc, char ** argv)
+{
+ // int i;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ unsigned char msg_data[11];
+ unsigned long freq=0;
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = IPMI_NETFN_PICMG;
+ req.msg.cmd = PICMG_AMC_SET_CLK_STATE_CMD;
+ req.msg.data = msg_data;
+
+ msg_data[0] = 0x00; /* PICMG identifier */
+ msg_data[1] = (uchar)strtoul(argv[0], NULL,0); /* clk id */
+ msg_data[2] = (uchar)strtoul(argv[1], NULL,0); /* clk index */
+ msg_data[3] = (uchar)strtoul(argv[2], NULL,0); /* setting */
+ msg_data[4] = (uchar)strtoul(argv[3], NULL,0); /* family */
+ msg_data[5] = (uchar)strtoul(argv[4], NULL,0); /* acc */
+
+ freq = strtoul(argv[5], NULL,0);
+ msg_data[6] = (uchar)((freq >> 0)& 0xFF); /* freq */
+ msg_data[7] = (uchar)((freq >> 8)& 0xFF); /* freq */
+ msg_data[8] = (uchar)((freq >>16)& 0xFF); /* freq */
+ msg_data[9] = (uchar)((freq >>24)& 0xFF); /* freq */
+
+ req.msg.data_len = 10;
+ if( PicmgCardType == PICMG_CARD_TYPE_ATCA )
+ {
+ if( argc > 7)
+ {
+ req.msg.data_len = 11;
+ msg_data[10] = (uchar)strtoul(argv[6], NULL,0); /* resource id */
+ }
+ else
+ {
+ printf("missing resource id for atca board\n");
+ return -1;
+ }
+ }
+
+#if 1
+printf("## ID: %d\n", msg_data[1]);
+printf("## index: %d\n", msg_data[2]);
+printf("## setting: 0x%02x\n", msg_data[3]);
+printf("## family: %d\n", msg_data[4]);
+printf("## acc: %d\n", msg_data[5]);
+printf("## freq: %d\n", freq );
+printf("## res: %d\n", msg_data[10]);
+#endif
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ if (rv < 0) printf("no response\n");
+ else printf("returned Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+
+#ifdef METACOMMAND
+int i_picmg(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rc = 0;
+ int showProperties = 0;
+ void *intf = NULL;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"m:i:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF)
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'i': /*specify a fru id*/
+ if (strncmp(optarg,"0x",2) == 0) g_fruid = htoi(&optarg[2]);
+ else g_fruid = htoi(optarg);
+ printf("Using FRU ID 0x%02x\n",g_fruid);
+ break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ ipmi_picmg_help();
+ return ERR_USAGE;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ /* Get PICMG properties is called to obtain version information */
+ if (argc !=0 && !strncmp(argv[0], "properties", 10)) {
+ showProperties =1;
+ }
+
+ if (argc == 0 || (!strncmp(argv[0], "help", 4))) {
+ ipmi_picmg_help();
+ return ERR_USAGE;
+ }
+
+ rc = ipmi_picmg_properties(intf,showProperties);
+ if (rc < 0) { /*cannot contact MC, so exit*/
+ goto do_exit;
+ }
+
+ /* address info command */
+ else if (!strncmp(argv[0], "addrinfo", 8)) {
+ rc = ipmi_picmg_getaddr(intf, argc-1, &argv[1]);
+ }
+ else if (!strncmp(argv[0], "busres", 6)) {
+ if (argc > 1) {
+ if (!strncmp(argv[1], "summary", 7)) {
+ ipmi_picmg_bused_resource(intf, PICMG_BUSED_RESOURCE_SUMMARY );
+ }
+ } else {
+ printf("usage: busres summary\n");
+ }
+ }
+ /* fru control command */
+ else if (!strncmp(argv[0], "frucontrol", 10)) {
+ if (argc > 2) {
+ rc = ipmi_picmg_fru_control(intf, argc-1, &(argv[1]));
+ }
+ else {
+ printf("usage: frucontrol <FRU-ID> <OPTION>\n");
+ printf(" OPTION:\n");
+ printf(" 0 - Cold Reset\n");
+ printf(" 1 - Warm Reset\n");
+ printf(" 2 - Graceful Reboot\n");
+ printf(" 3 - Issue Diagnostic Interrupt\n");
+ printf(" 4 - Quiesce [AMC only]\n");
+ printf(" 5-255 - Reserved\n");
+
+ rc = -1;
+ }
+
+ }
+
+ /* fru activation command */
+ else if (!strncmp(argv[0], "activate", 8)) {
+ if (argc > 1) {
+ rc = ipmi_picmg_fru_activation(intf, argc-1, &(argv[1]), PICMG_FRU_ACTIVATE);
+ }
+ else {
+ printf("specify the FRU to activate\n");
+ rc = -1;
+ }
+ }
+
+ /* fru deactivation command */
+ else if (!strncmp(argv[0], "deactivate", 10)) {
+ if (argc > 1) {
+ rc = ipmi_picmg_fru_activation(intf, argc-1, &(argv[1]), PICMG_FRU_DEACTIVATE);
+ }else {
+ printf("specify the FRU to deactivate\n");
+ rc = -1;
+ }
+ }
+
+ /* activation policy command */
+ else if (!strncmp(argv[0], "policy", 6)) {
+ if (argc > 1) {
+ if (!strncmp(argv[1], "get", 3)) {
+ if (argc > 2) {
+ rc = ipmi_picmg_fru_activation_policy_get(intf, argc-1, &(argv[2]));
+ } else {
+ printf("usage: get <fruid>\n");
+ }
+ } else if (!strncmp(argv[1], "set", 3)) {
+ if (argc > 4) {
+ rc = ipmi_picmg_fru_activation_policy_set(intf, argc-1, &(argv[2]));
+ } else {
+ printf("usage: set <fruid> <lockmask> <lock>\n");
+ printf(" lockmask: [1] affect the deactivation locked bit\n");
+ printf(" [0] affect the activation locked bit\n");
+ printf(" lock: [1] set/clear deactivation locked\n");
+ printf(" [0] set/clear locked \n");
+ }
+ }
+ else {
+ printf("specify fru\n");
+ rc = -1;
+ }
+ } else {
+ printf("wrong parameters\n");
+ rc = -1;
+ }
+ }
+
+ /* portstate command */
+ else if (!strncmp(argv[0], "portstate", 9)) {
+
+ if (fdebug) printf("PICMG: portstate API");
+
+ if (argc > 1) {
+ if (!strncmp(argv[1], "get", 3)) {
+
+ int iface;
+ int channel;
+
+ if (fdebug) printf("PICMG: get");
+
+ if(!strncmp(argv[1], "getall", 6)) {
+ for(iface=0;iface<=PICMG_EKEY_MAX_INTERFACE;iface++) {
+ for(channel=1;channel<=PICMG_EKEY_MAX_CHANNEL;channel++) {
+ if(!(( iface == FRU_PICMGEXT_DESIGN_IF_FABRIC ) &&
+ ( channel > PICMG_EKEY_MAX_FABRIC_CHANNEL ) ))
+ {
+ rc = ipmi_picmg_portstate_get(intf,iface,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_ALL);
+ }
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getgranted", 10)) {
+ for(iface=0;iface<=PICMG_EKEY_MAX_INTERFACE;iface++) {
+ for(channel=1;channel<=PICMG_EKEY_MAX_CHANNEL;channel++) {
+ rc = ipmi_picmg_portstate_get(intf,iface,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_ENABLED);
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getdenied", 9)){
+ for(iface=0;iface<=PICMG_EKEY_MAX_INTERFACE;iface++) {
+ for(channel=1;channel<=PICMG_EKEY_MAX_CHANNEL;channel++) {
+ rc = ipmi_picmg_portstate_get(intf,iface,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_DISABLED);
+ }
+ }
+ }
+ else if (argc > 3){
+ iface = atob(argv[2]);
+ channel = atob(argv[3]);
+ if (fdebug) printf("PICMG: requesting interface %d",iface);
+ if (fdebug) printf("PICMG: requesting channel %d",channel);
+
+ rc = ipmi_picmg_portstate_get(intf,iface,(uchar)channel,
+ PICMG_EKEY_MODE_QUERY );
+ }
+ else {
+ printf("<intf> <chn>|getall|getgranted|getdenied\n");
+ }
+ }
+ else if (!strncmp(argv[1], "set", 3)) {
+ if (argc == 9) {
+ int interfc = strtoul(argv[2], NULL, 0);
+ int channel = strtoul(argv[3], NULL, 0);
+ int port = strtoul(argv[4], NULL, 0);
+ int type = strtoul(argv[5], NULL, 0);
+ int typeext = strtoul(argv[6], NULL, 0);
+ int group = strtoul(argv[7], NULL, 0);
+ int enable = strtoul(argv[8], NULL, 0);
+
+ if (fdebug) printf("PICMG: interface %d",interfc);
+ if (fdebug) printf("PICMG: channel %d",channel);
+ if (fdebug) printf("PICMG: port %d",port);
+ if (fdebug) printf("PICMG: type %d",type);
+ if (fdebug) printf("PICMG: typeext %d",typeext);
+ if (fdebug) printf("PICMG: group %d",group);
+ if (fdebug) printf("PICMG: enable %d",enable);
+
+ rc = ipmi_picmg_portstate_set(intf, interfc,
+ (uchar)channel, (uchar)port, type, typeext ,group ,enable);
+ }
+ else {
+ printf("<intf> <chn> <port> <type> <ext> <group> <1|0>\n");
+ rc = -1;
+ }
+ }
+ }
+ else {
+ printf("<set>|<getall>|<getgranted>|<getdenied>\n");
+ rc = -1;
+ }
+ }
+ /* amc portstate command */
+ else if (!strncmp(argv[0], "amcportstate", 12)) {
+
+ if (fdebug) printf("PICMG: amcportstate API");
+
+ if (argc > 1) {
+ if (!strncmp(argv[1], "get", 3)){
+ int channel;
+ int device;
+
+ if (fdebug) printf("PICMG: get");
+
+ if(!strncmp(argv[1], "getall", 6)){
+ int maxDevice = PICMG_EKEY_AMC_MAX_DEVICE;
+ if( PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ maxDevice = 0;
+ }
+ for(device=0;device<=maxDevice;device++){
+ for(channel=0;channel<=PICMG_EKEY_AMC_MAX_CHANNEL;channel++){
+ rc = ipmi_picmg_amc_portstate_get(intf,device,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_ALL);
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getgranted", 10)){
+ int maxDevice = PICMG_EKEY_AMC_MAX_DEVICE;
+ if( PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ maxDevice = 0;
+ }
+ for(device=0;device<=maxDevice;device++){
+ for(channel=0;channel<=PICMG_EKEY_AMC_MAX_CHANNEL;channel++){
+ rc = ipmi_picmg_amc_portstate_get(intf,(uchar)device,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_ENABLED);
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getdenied", 9)){
+ int maxDevice = PICMG_EKEY_AMC_MAX_DEVICE;
+ if( PicmgCardType != PICMG_CARD_TYPE_ATCA ){
+ maxDevice = 0;
+ }
+ for(device=0;device<=maxDevice;device++){
+ for(channel=0;channel<=PICMG_EKEY_AMC_MAX_CHANNEL;channel++){
+ rc = ipmi_picmg_amc_portstate_get(intf,(uchar)device,(uchar)channel,
+ PICMG_EKEY_MODE_PRINT_DISABLED);
+ }
+ }
+ }
+ else if (argc > 2){
+ channel = atoi(argv[2]);
+ if (argc > 3){
+ device = atoi(argv[3]);
+ }else{
+ device = -1;
+ }
+ if (fdebug) printf("PICMG: requesting device %d",device);
+ if (fdebug) printf("PICMG: requesting channel %d",channel);
+
+ rc = ipmi_picmg_amc_portstate_get(intf,(uchar)device,(uchar)channel,
+ PICMG_EKEY_MODE_QUERY );
+ }
+ else {
+ printf("<chn> <device>|getall|getgranted|getdenied\n");
+ }
+ }
+ else if (!strncmp(argv[1], "set", 3)) {
+ if (argc > 7) {
+ int channel = atoi(argv[2]);
+ int port = atoi(argv[3]);
+ int type = atoi(argv[4]);
+ int typeext = atoi(argv[5]);
+ int group = atoi(argv[6]);
+ int enable = atoi(argv[7]);
+ int device = -1;
+ if(argc > 8){
+ device = atoi(argv[8]);
+ }
+
+ if (fdebug) printf("PICMG: channel %d",channel);
+ if (fdebug) printf("PICMG: portflags %d",port);
+ if (fdebug) printf("PICMG: type %d",type);
+ if (fdebug) printf("PICMG: typeext %d",typeext);
+ if (fdebug) printf("PICMG: group %d",group);
+ if (fdebug) printf("PICMG: enable %d",enable);
+ if (fdebug) printf("PICMG: device %d",device);
+
+ rc = ipmi_picmg_amc_portstate_set(intf, (uchar)channel, (uchar)port, type,
+ typeext, group, enable, device);
+ }
+ else {
+ printf("<chn> <portflags> <type> <ext> <group> <1|0> [<device>]\n");
+ rc = -1;
+ }
+ }
+ }
+ else {
+ printf("<set>|<get>|<getall>|<getgranted>|<getdenied>\n");
+ rc = -1;
+ }
+ }
+ /* ATCA led commands */
+ else if (!strncmp(argv[0], "led", 3)) {
+ if (argc > 1) {
+ if (!strncmp(argv[1], "prop", 4)) {
+ if (argc > 2) {
+ rc = ipmi_picmg_get_led_properties(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("led prop <FRU-ID>\n");
+ }
+ }
+ else if (!strncmp(argv[1], "cap", 3)) {
+ if (argc > 3) {
+ rc = ipmi_picmg_get_led_capabilities(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("led cap <FRU-ID> <LED-ID>\n");
+ }
+ }
+ else if (!strncmp(argv[1], "get", 3)) {
+ if (argc > 3) {
+ rc = ipmi_picmg_get_led_state(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("led get <FRU-ID> <LED-ID>\n");
+ }
+ }
+ else if (!strncmp(argv[1], "set", 3)) {
+ if (argc > 6) {
+ rc = ipmi_picmg_set_led_state(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("led set <FRU-ID> <LED-ID> <function> <duration> <color>\n");
+ printf(" <FRU-ID>\n");
+ printf(" <LED-ID> 0: Blue LED\n");
+ printf(" 1: LED 1\n");
+ printf(" 2: LED 2\n");
+ printf(" 3: LED 3\n");
+ printf(" 0x04-0xFE: OEM defined\n");
+ printf(" 0xFF: All LEDs under management control\n");
+ printf(" <function> 0: LED OFF override\n");
+ printf(" 1 - 250: LED blinking override (off duration)\n");
+ printf(" 251: LED Lamp Test\n");
+ printf(" 252: LED restore to local control\n");
+ printf(" 255: LED ON override\n");
+ printf(" <duration> 1 - 127: LED Lamp Test / on duration\n");
+ printf(" <color> 0: reserved\n");
+ printf(" 1: BLUE\n");
+ printf(" 2: RED\n");
+ printf(" 3: GREEN\n");
+ printf(" 4: AMBER\n");
+ printf(" 5: ORANGE\n");
+ printf(" 6: WHITE\n");
+ printf(" 7: reserved\n");
+ printf(" 0xE: do not change\n");
+ printf(" 0xF: use default color\n");
+ }
+ }
+ else {
+ printf("prop | cap | get | set\n");
+ }
+ }
+ }
+ /* power commands */
+ else if (!strncmp(argv[0], "power", 5)) {
+ if (argc > 1) {
+ if (!strncmp(argv[1], "get", 3)) {
+ if (argc > 3) {
+ rc = ipmi_picmg_get_power_level(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("power get <FRU-ID> <type>\n");
+ printf(" <type> 0 : steady state powert draw levels\n");
+ printf(" 1 : desired steady state draw levels\n");
+ printf(" 2 : early power draw levels\n");
+ printf(" 3 : desired early levels\n");
+
+ rc = -1;
+ }
+ }
+ else if (!strncmp(argv[1], "set", 3)) {
+ if (argc > 4) {
+ rc = ipmi_picmg_set_power_level(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("power set <FRU-ID> <level> <present-desired>\n");
+ printf(" <level> 0 : Power Off\n");
+ printf(" 0x1-0x14 : Power level\n");
+ printf(" 0xFF : do not change\n");
+ printf("\n");
+ printf(" <present-desired> 0: do not change present levels\n");
+ printf(" 1: copy desired to present level\n");
+
+ rc = -1;
+ }
+ }
+ else {
+ printf("<set>|<get>\n");
+ rc = -1;
+ }
+ }
+ else {
+ printf("<set>|<get>\n");
+ rc = -1;
+ }
+ }/* clk commands*/
+ else if (!strncmp(argv[0], "clk", 3)) {
+ if (argc > 1) {
+ if (!strncmp(argv[1], "get", 3)) {
+ int clk_id;
+ int clk_res = -1;
+ int max_res = 15;
+
+ if( PicmgCardType == PICMG_CARD_TYPE_AMC ) {
+ max_res = 0;
+ }
+
+ if(!strncmp(argv[1], "getall", 6)) {
+ if(fdebug) printf("Getting all clock state\n");
+ for(clk_res=0;clk_res<=max_res;clk_res++) {
+ for(clk_id=0;clk_id<=15;clk_id++) {
+ rc = ipmi_picmg_clk_get(intf,clk_id,clk_res,
+ PICMG_EKEY_MODE_PRINT_ALL);
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getdenied", 6)) {
+ if( fdebug ) { printf("Getting disabled clocks\n") ;}
+ for(clk_res=0;clk_res<=max_res;clk_res++) {
+ for(clk_id=0;clk_id<=15;clk_id++) {
+ rc = ipmi_picmg_clk_get(intf,clk_id,clk_res,
+ PICMG_EKEY_MODE_PRINT_DISABLED);
+ }
+ }
+ }
+ else if(!strncmp(argv[1], "getgranted", 6)) {
+ if( fdebug ) { printf("Getting enabled clocks\n") ;}
+ for(clk_res=0;clk_res<=max_res;clk_res++) {
+ for(clk_id=0;clk_id<=15;clk_id++) {
+ rc = ipmi_picmg_clk_get(intf,clk_id,clk_res,
+ PICMG_EKEY_MODE_PRINT_ENABLED);
+ }
+ }
+ }
+ else if (argc > 2) {
+ clk_id = atoi(argv[2]);
+ if (argc > 3) {
+ clk_res = atoi(argv[3]);
+ }
+
+ rc = ipmi_picmg_clk_get(intf, clk_id, clk_res,
+ PICMG_EKEY_MODE_QUERY );
+ }
+ else {
+ printf("clk get ");
+ printf("<CLK-ID> [<DEV-ID>] |getall|getgranted|getdenied\n");
+ rc = -1;
+ }
+ }
+ else if (!strncmp(argv[1], "set", 3)) {
+ if (argc > 7) {
+ rc = ipmi_picmg_clk_set(intf, argc-1, &(argv[2]));
+ }
+ else {
+ printf("clk set <CLK-ID> <index> <setting> <family> <acc-lvl> <freq> [<DEV-ID>] \n");
+
+ rc = -1;
+ }
+ }
+ else {
+ printf("<set>|<get>|<getall>|<getgranted>|<getdenied>\n");
+ rc = -1;
+ }
+ }
+ else {
+ printf("<set>|<get>|<getall>|<getgranted>|<getdenied>\n");
+ rc = -1;
+ }
+ }
+
+ else if(showProperties == 0 ){
+
+ ipmi_picmg_help();
+ rc = ERR_USAGE;
+ }
+
+do_exit:
+ ipmi_close_();
+ return rc;
+} /*end i_picmg*/
+
+/* end ipicmg.c */
+
diff --git a/util/ipicmg.h b/util/ipicmg.h
new file mode 100644
index 0000000..59fce39
--- /dev/null
+++ b/util/ipicmg.h
@@ -0,0 +1,313 @@
+/*
+ (C) Kontron
+ */
+
+#ifndef _IPMI_PICMG_H_
+#define _IPMI_PICMG_H_
+
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+
+#define BMC_SA 0x20
+#define PUBLIC_BUS 0
+#define BMC_LUN 0
+
+/* PICMG version */
+#define PICMG_CPCI_MAJOR_VERSION 1
+#define PICMG_ATCA_MAJOR_VERSION 2
+#define PICMG_AMC_MAJOR_VERSION 4
+
+#define FRU_PICMGEXT_LINK_TYPE_BASE 0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET 0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND 0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR 0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE 0x05
+
+#ifndef HAVE_FRU_PICMG_EXT
+#define HAVE_FRU_PICMG_EXT
+#pragma pack(1)
+struct fru_picmgext_link_desc {
+#ifndef WORDS_BIGENDIAN
+ unsigned int desig_channel:6;
+ unsigned int desig_if:2;
+ unsigned int desig_port:4;
+ unsigned int type:8;
+ unsigned int ext:4;
+ unsigned int grouping:8;
+#else
+ unsigned int grouping:8;
+ unsigned int ext:4;
+ unsigned int type:8;
+ unsigned int desig_port:4;
+ unsigned int desig_if:2;
+ unsigned int desig_channel:6;
+#endif
+}; /* __attribute__ ((packed)); */
+struct fru_picmgext_amc_link_info {
+ unsigned char linkInfo[3];
+}; /* __attribute__ ((packed)); */
+#pragma pack()
+#endif
+
+#define OEM_PICMG 12634
+// IPMI_OEM_PICMG = 12634,
+
+#define FRU_PICMG_BACKPLANE_P2P 0x04
+#define FRU_PICMG_ADDRESS_TABLE 0x10
+#define FRU_PICMG_SHELF_POWER_DIST 0x11
+#define FRU_PICMG_SHELF_ACTIVATION 0x12
+#define FRU_PICMG_SHMC_IP_CONN 0x13
+#define FRU_PICMG_BOARD_P2P 0x14
+#define FRU_AMC_CURRENT 0x16
+#define FRU_AMC_ACTIVATION 0x17
+#define FRU_AMC_CARRIER_P2P 0x18
+#define FRU_AMC_P2P 0x19
+#define FRU_AMC_CARRIER_INFO 0x1a
+#define FRU_UTCA_FRU_INFO_TABLE 0x20
+#define FRU_UTCA_CARRIER_MNG_IP 0x21
+#define FRU_UTCA_CARRIER_INFO 0x22
+#define FRU_UTCA_CARRIER_LOCATION 0x23
+#define FRU_UTCA_SHMC_IP_LINK 0x24
+#define FRU_UTCA_POWER_POLICY 0x25
+#define FRU_UTCA_ACTIVATION 0x26
+#define FRU_UTCA_PM_CAPABILTY 0x27
+#define FRU_UTCA_FAN_GEOGRAPHY 0x28
+#define FRU_UTCA_CLOCK_MAPPING 0x29
+#define FRU_UTCA_MSG_BRIDGE_POLICY 0x2A
+#define FRU_UTCA_OEM_MODULE_DESC 0x2B
+#define FRU_PICMG_CLK_CARRIER_P2P 0x2C
+#define FRU_PICMG_CLK_CONFIG 0x2D
+
+#define FRU_PICMGEXT_LINK_TYPE_BASE 0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET 0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND 0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR 0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE 0x05
+#define FRU_PICMGEXT_LINK_TYPE_BASE 0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET 0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND 0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR 0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE 0x05
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED 0x00
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED1 0x01
+#define FRU_PICMGEXT_AMC_LINK_TYPE_PCI_EXPRESS 0x02
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING1 0x03
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING2 0x04
+#define FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET 0x05
+#define FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO 0x06
+#define FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE 0x07
+#define FRU_PICMGEXT_OEM_SWFW 0x03
+#define FRU_PICMGEXT_DESIGN_IF_BASE 0x00
+#define FRU_PICMGEXT_DESIGN_IF_FABRIC 0x01
+#define FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL 0x02
+#define FRU_PICMGEXT_DESIGN_IF_RESERVED 0x03
+
+
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE 0x02
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS1 0x03
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_PCIE_AS2 0x04
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET 0x05
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO 0x06
+ #define FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE 0x07
+
+ #define AMC_LINK_TYPE_EXT_PCIE_G1_NSSC 0x00
+ #define AMC_LINK_TYPE_EXT_PCIE_G1_SSC 0x01
+ #define AMC_LINK_TYPE_EXT_PCIE_G2_NSSC 0x02
+ #define AMC_LINK_TYPE_EXT_PCIE_G2_SSC 0x03
+ #define AMC_LINK_TYPE_EXT_ETH_1000_BX 0x00
+ #define AMC_LINK_TYPE_EXT_ETH_10G_XAUI 0x01
+ #define AMC_LINK_TYPE_EXT_STORAGE_FC 0x00
+ #define AMC_LINK_TYPE_EXT_STORAGE_SATA 0x01
+ #define AMC_LINK_TYPE_EXT_STORAGE_SAS 0x02
+
+#define IPMI_NETFN_PICMG 0x2C
+
+/* PICMG commands */
+#define PICMG_GET_PICMG_PROPERTIES_CMD 0x00
+#define PICMG_GET_ADDRESS_INFO_CMD 0x01
+#define PICMG_GET_SHELF_ADDRESS_INFO_CMD 0x02
+#define PICMG_SET_SHELF_ADDRESS_INFO_CMD 0x03
+#define PICMG_FRU_CONTROL_CMD 0x04
+#define PICMG_GET_FRU_LED_PROPERTIES_CMD 0x05
+#define PICMG_GET_LED_COLOR_CAPABILITIES_CMD 0x06
+#define PICMG_SET_FRU_LED_STATE_CMD 0x07
+#define PICMG_GET_FRU_LED_STATE_CMD 0x08
+#define PICMG_SET_IPMB_CMD 0x09
+#define PICMG_SET_FRU_POLICY_CMD 0x0A
+#define PICMG_GET_FRU_POLICY_CMD 0x0B
+#define PICMG_FRU_ACTIVATION_CMD 0x0C
+#define PICMG_GET_DEVICE_LOCATOR_RECORD_CMD 0x0D
+#define PICMG_SET_PORT_STATE_CMD 0x0E
+#define PICMG_GET_PORT_STATE_CMD 0x0F
+#define PICMG_COMPUTE_POWER_PROPERTIES_CMD 0x10
+#define PICMG_SET_POWER_LEVEL_CMD 0x11
+#define PICMG_GET_POWER_LEVEL_CMD 0x12
+#define PICMG_RENEGOTIATE_POWER_CMD 0x13
+#define PICMG_GET_FAN_SPEED_PROPERTIES_CMD 0x14
+#define PICMG_SET_FAN_LEVEL_CMD 0x15
+#define PICMG_GET_FAN_LEVEL_CMD 0x16
+#define PICMG_BUSED_RESOURCE_CMD 0x17
+
+/* AMC.0 commands */
+#define PICMG_AMC_SET_PORT_STATE_CMD 0x19
+#define PICMG_AMC_GET_PORT_STATE_CMD 0x1A
+/* AMC.0 R2.0 commands */
+#define PICMG_AMC_SET_CLK_STATE_CMD 0x2C
+#define PICMG_AMC_GET_CLK_STATE_CMD 0x2D
+
+/* Site Types */
+#define PICMG_ATCA_BOARD 0x00
+#define PICMG_POWER_ENTRY 0x01
+#define PICMG_SHELF_FRU 0x02
+#define PICMG_DEDICATED_SHMC 0x03
+#define PICMG_FAN_TRAY 0x04
+#define PICMG_FAN_FILTER_TRAY 0x05
+#define PICMG_ALARM 0x06
+#define PICMG_AMC 0x07
+#define PICMG_PMC 0x08
+#define PICMG_RTM 0x09
+
+#pragma pack(1)
+struct picmg_set_fru_activation_cmd {
+ unsigned char picmg_id; /* always 0*/
+ unsigned char fru_id; /* threshold setting mask */
+ unsigned char fru_state; /* fru activation/deactivation */
+}; // __attribute__ ((packed));
+#pragma pack()
+
+typedef enum picmg_busres_board_cmd_types {
+ PICMG_BUSRES_BOARD_CMD_QUERY =0,
+ PICMG_BUSRES_BOARD_CMD_RELEASE,
+ PICMG_BUSRES_BOARD_CMD_FORCE,
+ PICMG_BUSRES_BOARD_CMD_BUS_FREE
+} t_picmg_busres_board_cmd_types ;
+
+typedef enum picmg_busres_shmc_cmd_types {
+ PICMG_BUSRES_SHMC_CMD_REQUEST =0,
+ PICMG_BUSRES_SHMC_CMD_RELINQUISH,
+ PICMG_BUSRES_SHMC_CMD_NOTIFY
+} t_picmg_busres_shmc_cmd_types ;
+
+typedef enum picmg_busres_resource_id {
+ PICMG_BUSRES_METAL_TEST_BUS_1=0,
+ PICMG_BUSRES_METAL_TEST_BUS_2,
+ PICMG_BUSRES_SYNC_CLOCK_GROUP_1,
+ PICMG_BUSRES_SYNC_CLOCK_GROUP_2,
+ PICMG_BUSRES_SYNC_CLOCK_GROUP_3
+} t_picmg_busres_resource_id;
+
+/* the LED color capabilities */
+static const char* led_color_str[] = { //__attribute__((unused)) = {
+ "reserved",
+ "BLUE",
+ "RED",
+ "GREEN",
+ "AMBER",
+ "ORANGE",
+ "WHITE",
+ "reserved"
+};
+
+
+static const char* amc_link_type_str[] = { // __attribute__((unused)) = {
+ "RESERVED",
+ "RESERVED1",
+ "PCI EXPRESS",
+ "ADVANCED SWITCHING1",
+ "ADVANCED SWITCHING2",
+ "ETHERNET",
+ "RAPIDIO",
+ "STORAGE",
+};
+
+static const char* amc_link_type_ext_str[][16]= { // __attribute__((unused))
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED */
+ {
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_RESERVED1 */
+ {
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_PCI_EXPRESS */
+ {
+ "Gen 1 - NSSC",
+ "Gen 1 - SSC",
+ "Gen 2 - NSSC",
+ "Gen 2 - SSC",
+ "", "", "", "",
+ "", "", "", "",
+ "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING1 */
+ {
+ "Gen 1 - NSSC",
+ "Gen 1 - SSC",
+ "Gen 2 - NSSC",
+ "Gen 2 - SSC",
+ "", "", "", "",
+ "", "", "", "",
+ "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_ADVANCED_SWITCHING2 */
+ {
+ "Gen 1 - NSSC",
+ "Gen 1 - SSC",
+ "Gen 2 - NSSC",
+ "Gen 2 - SSC",
+ "", "", "", "",
+ "", "", "", "",
+ "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_ETHERNET */
+ {
+ "1000BASE-BX (SerDES Gigabit)",
+ "10GBASE-BX410 Gigabit XAUI",
+ "", "",
+ "", "", "", "",
+ "", "", "", "",
+ "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_RAPIDIO */
+ {
+ "1.25 Gbaud transmission rate",
+ "2.5 Gbaud transmission rate",
+ "3.125 Gbaud transmission rate",
+ "", "", "", "", "",
+ "", "", "", "", "", "", "", ""
+ },
+ /* FRU_PICMGEXT_AMC_LINK_TYPE_STORAGE */
+ {
+ "Fibre Channel",
+ "Serial ATA",
+ "Serial Attached SCSI",
+ "", "", "", "", "",
+ "", "", "", "", "", "", "", ""
+ }
+};
+
+struct sAmcPortState {
+#ifndef WORDS_BIGENDIAN
+ unsigned short lane0 : 1;
+ unsigned short lane1 : 1;
+ unsigned short lane2 : 1;
+ unsigned short lane3 : 1;
+ unsigned short type : 8;
+ unsigned short type_ext : 4;
+ unsigned char group_id : 8;
+#else
+ unsigned char group_id : 8;
+ unsigned short type_ext : 4;
+ unsigned short type : 8;
+ unsigned short lane3 : 1;
+ unsigned short lane2 : 1;
+ unsigned short lane1 : 1;
+ unsigned short lane0 : 1;
+#endif
+
+ unsigned char state;
+};
+
+
+#endif
diff --git a/util/ipmi_port.c b/util/ipmi_port.c
new file mode 100644
index 0000000..3dccf6a
--- /dev/null
+++ b/util/ipmi_port.c
@@ -0,0 +1,146 @@
+/*
+ * ipmi_port.c
+ * Allocate the RMCP port (623.) with a bind so that port manager
+ * does not try to reuse it. Only needed for Linux.
+ *
+ * Note that the Intel dpcproxy service also uses port 623 to listen
+ * for incoming telnet/SOL clients, so we should not start ipmi_port
+ * if dpcproxy is running.
+ *
+ * Changes:
+ * 05/18/07 Andy Cress - created
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <signal.h>
+#ifdef TEST
+#include "ipmicmd.h"
+#endif
+
+#define RMCP_PORT 623
+static char * progver = "1.4"; /* program version */
+static char *progname = "ipmi_port"; /* program name */
+static int sockfd = 0;
+static struct sockaddr_in _srcaddr;
+static int interval = 20; /* num sec to wait, was 60 */
+static char fdebug = 0;
+
+static int mkdaemon(int fchdir, int fclose);
+static int mkdaemon(int fchdir, int fclose)
+{
+ int fdlimit = sysconf(_SC_OPEN_MAX); /*fdlimit usu = 1024.*/
+ int fd = 0;
+ int i;
+
+ fdlimit = fileno(stderr);
+ switch (fork()) {
+ case 0: break;
+ case -1: return -1;
+ default: _exit(0); /* exit the original process */
+ }
+ if (setsid() < 0) return -1; /* shouldn't fail */
+ switch (fork()) {
+ case 0: break;
+ case -1: return -1;
+ default: _exit(0);
+ }
+ if (fchdir) i = chdir("/");
+ if (fclose) {
+ /* Close stdin,stdout,stderr and replace them with /dev/null */
+ for (fd = 0; fd < fdlimit; fd++) close(fd);
+ fd = open("/dev/null",O_RDWR);
+ i = dup(0);
+ i = dup(0);
+ }
+ return 0;
+}
+
+static int open_rmcp_port(int port);
+static int open_rmcp_port(int port)
+{
+ int rv;
+
+ /* Open a socket binding to the RMCP port */
+ rv = socket(AF_INET, SOCK_DGRAM, 0);
+ if (rv < 0) return (rv);
+ else sockfd = rv;
+
+ memset(&_srcaddr, 0, sizeof(_srcaddr));
+ _srcaddr.sin_family = AF_INET;
+ _srcaddr.sin_port = htons(port);
+ _srcaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ rv = bind(sockfd, (struct sockaddr *)&_srcaddr, sizeof(_srcaddr));
+ if (rv < 0) {
+ printf("bind(%d,%d) error, rv = %d\n",port,INADDR_ANY,rv);
+ close(sockfd);
+ return (rv);
+ }
+
+ return(rv);
+}
+
+static void iport_cleanup(int sig)
+{
+ if (sockfd != 0) close(sockfd);
+ exit(EXIT_SUCCESS);
+}
+
+/*int ipmi_port(int argc, char **argv) */
+int main(int argc, char **argv)
+{
+ int rv;
+ int c;
+ int background = 0;
+ struct sigaction sact;
+
+ while ((c = getopt(argc, argv, "bx?")) != EOF) {
+ switch (c) {
+ case 'x': fdebug = 1; break;
+ case 'b': background = 1; break;
+ default:
+ printf("Usage: %s [-xb] (-b means background)\n",progname);
+ exit(1);
+ }
+ }
+ if (!background)
+ printf("%s ver %s\n", progname,progver);
+
+ rv = open_rmcp_port(RMCP_PORT);
+ if (rv != 0) {
+ printf("open_rmcp_port(%d) failed, rv = %d\n",RMCP_PORT,rv);
+ exit(1);
+ } else if (!background)
+ printf("open_rmcp_port(%d) succeeded, sleeping\n",RMCP_PORT);
+
+ /* convert to a daemon if background */
+ if (background) {
+ rv = mkdaemon(1,1);
+ if (rv != 0) {
+ printf("%s: Cannot become daemon, rv = %d\n", progname,rv);
+ exit(1);
+ }
+ }
+
+ /* handle signals for cleanup */
+ sact.sa_handler = iport_cleanup;
+ sact.sa_flags = 0;
+ sigemptyset(&sact.sa_mask);
+ sigaction(SIGINT, &sact, NULL);
+ sigaction(SIGQUIT, &sact, NULL);
+ sigaction(SIGTERM, &sact, NULL);
+
+ if (rv == 0) while(1)
+ {
+ sleep(interval); /*wait 60 seconds*/
+ }
+ if (sockfd != 0) close(sockfd);
+ return(rv);
+}
+
+/*end ipmi_port.c */
diff --git a/util/ipmi_sample.c b/util/ipmi_sample.c
new file mode 100644
index 0000000..ddda7f3
--- /dev/null
+++ b/util/ipmi_sample.c
@@ -0,0 +1,312 @@
+/*
+ * ipmi_sample.c
+ *
+ * A sample IPMI utility, to which more commands can be added.
+ *
+ * 02/27/06 Andy Cress - created
+ * 02/25/11 Andy Cress - added get_chassis_status
+ */
+/*M*
+Copyright (c) 2007, Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron America, Inc. nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include "ipmicmd.h"
+#ifdef GET_SENSORS
+/* need to also include isensor.o, ievents.o when linking. */
+#include "isensor.h"
+#endif
+#ifdef GET_FRU
+#include "ifru.h"
+#endif
+
+/*
+ * Global variables
+ */
+static char * progname = "ipmi_sample";
+static char * progver = "1.2";
+static char fdebug = 0;
+static char fset_mc = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static char *mytag = NULL;
+static char *sdrfile = NULL;
+
+static int get_chassis_status(uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmdraw( CHASSIS_STATUS, NETFN_CHAS, g_sa,g_bus,g_lun,
+ idata,0, rdata,&rlen,&ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_chassis_status()*/
+
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+{
+ int ret = 0;
+ char c;
+ uchar devrec[16];
+ uchar chstatus[4];
+ char *s1;
+ int loops = 1;
+ int nsec = 10;
+ char *nodefile = NULL;
+ int done = 0;
+ FILE *fp = NULL;
+ char nod[40]; char usr[24]; char psw[24];
+ char drvtyp[10];
+ char biosstr[40];
+ int n;
+#ifdef GET_SENSORS
+ uchar *sdrlist;
+#endif
+
+ printf("%s ver %s\n", progname,progver);
+
+ while ((c = getopt( argc, argv,"i:l:m:f:s:t:xEF:N:P:R:T:U:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'f': nodefile = optarg; break; /* specific sensor tag */
+ case 'l': loops = atoi(optarg); break;
+ case 'i': nsec = atoi(optarg); break; /*interval in sec*/
+ case 's': sdrfile = optarg; break;
+ case 't': mytag = optarg; break; /* specific sensor tag */
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ if (c == 'F') strncpy(drvtyp,optarg,sizeof(drvtyp));
+ break;
+ default:
+ printf("Usage: %s [-filmstx -NUPREFTVY]\n", progname);
+ printf(" where -x show eXtra debug messages\n");
+ printf(" -f File use list of remote nodes from File\n");
+ printf(" -i 10 interval for each loop in seconds\n");
+ printf(" -l 10 loops sensor readings 10 times\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -s File loads SDRs from File\n");
+ printf(" -t tag search for 'tag' in SDRs\n");
+ print_lan_opt_usage();
+ exit(1);
+ }
+ /* Rather than parse_lan_options above, the set_lan_options function
+ * could be used if the program already knows the nodename, etc. */
+ ret = get_BiosVersion(biosstr);
+ if (ret == 0) printf("BIOS Version: %s\n",biosstr);
+
+ while(!done)
+ {
+ if (nodefile != NULL) {
+ /* This will loop for each node in the file if -f was used.
+ * The file should contain one line per node:
+ * node1 user1 password1
+ * node2 user2 password2
+ */
+ if (fp == NULL) {
+ fp = fopen(nodefile,"r");
+ if (fp == NULL) {
+ printf("Cannot open file %s\n",nodefile);
+ ret = ERR_FILE_OPEN;
+ goto do_exit;
+ }
+ if (fdebug) printf("opened file %s ok\n",nodefile);
+ }
+ n = fscanf(fp,"%s %s %s", nod, usr, psw);
+ if (fdebug) printf("fscanf returned %d \n",n);
+ if (n == EOF || n <= 0) {
+ fclose(fp);
+ done = 1;
+ goto do_exit;
+ }
+ printf("Using -N %s -U %s -P %s ...\n",nod,usr,psw);
+ if (n > 0) parse_lan_options('N',nod,0);
+ if (n > 1) parse_lan_options('U',usr,0);
+ if (n > 2) parse_lan_options('P',psw,0);
+ if (drvtyp != NULL) parse_lan_options('F',drvtyp,0);
+ }
+
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ printf("Cannot do ipmi_getdeviceid, ret = %d\n",ret);
+ goto do_exit;
+ } else { /*success*/
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+
+ ret = get_chassis_status(chstatus,4);
+ if (ret == 0) {
+ if (chstatus[0] & 0x01) s1 = "on";
+ else s1 = "off";
+ printf("Chassis Status = %02x (%s)\n",chstatus[0],s1);
+ }
+
+#ifdef GET_FRU
+ {
+ uchar *fru_data = NULL;
+ printf("Getting FRU ...\n");
+ ret = load_fru(0x20,0,0x07, &fru_data);
+ if (ret == 0)
+ ret = show_fru(0x20,0,0x07,fru_data);
+ if (fru_data != NULL)
+ free_fru(fru_data);
+ }
+#endif
+#ifdef GET_SENSORS
+ printf("Getting SDRs ...\n");
+ if (sdrfile != NULL) {
+ ret = get_sdr_file(sdrfile,&sdrlist);
+ } else {
+ ret = get_sdr_cache(&sdrlist);
+ }
+ printf("get_sdr_cache ret = %d\n",ret);
+ if (ret == 0) {
+ uchar sdrbuf[SDR_SZ];
+ uchar reading[4];
+ uchar snum = 0;
+ ushort id;
+ double val;
+ char *typestr;
+ char tag[17];
+ int j;
+
+ for (j = 0; j < loops; j++)
+ {
+ if (j > 0) {
+ printf("loop %d: wait %d seconds ...\n",j,nsec);
+ os_usleep(nsec,0); /*sleep 5 sec between loops*/
+ }
+ id = 0;
+ /* Get sensor readings for all full SDRs */
+ while(find_sdr_next(sdrbuf,sdrlist,id) == 0) {
+ id = sdrbuf[0] + (sdrbuf[1] << 8); /*this SDR id*/
+ if (sdrbuf[3] != 0x01) continue; /*only type 1 full SDRs*/
+ strncpy(tag,&sdrbuf[48],16);
+ tag[16] = 0;
+ snum = sdrbuf[7];
+ ret = GetSensorReading(snum, sdrbuf, reading);
+ if (ret == 0) {
+ val = RawToFloat(reading[0], sdrbuf);
+ typestr = get_unit_type( sdrbuf[20], sdrbuf[21], sdrbuf[22],0);
+ } else {
+ val = 0;
+ typestr = "na";
+ printf("%04x: get sensor %x reading ret = %d\n",id,snum,ret);
+ }
+ printf("%04x: sensor %x %s \treading = %.2f %s\n",
+ id,snum,tag,val,typestr);
+ memset(sdrbuf,0,SDR_SZ);
+ } /*end while*/
+ } /*end for(loops) */
+
+ /* Find a specific sensor by its tag and get a reading */
+ if (mytag != NULL) {
+ /* see option -t, mytag = "System"; or "System Temp" */
+ memset(sdrbuf,0,SDR_SZ);
+ ret = find_sdr_by_tag(sdrbuf, sdrlist, mytag, fdebug);
+ printf("find_sdr_by_tag(%s) ret = %d\n",mytag,ret);
+ strncpy(tag,&sdrbuf[48],16); /*assume full sdr tag offset*/
+ tag[16] = 0;
+ snum = sdrbuf[7];
+ ret = GetSensorReading(snum, sdrbuf, reading);
+ printf("get sensor %x reading ret = %d\n",snum,ret);
+ if (sdrbuf[3] == 0x01) { /*full SDR*/
+ if (ret == 0) {
+ val = RawToFloat(reading[0], sdrbuf);
+ typestr = get_unit_type(sdrbuf[20],sdrbuf[21],sdrbuf[22],0);
+ } else {
+ val = 0;
+ typestr = "na";
+ }
+ printf("sensor %x %s reading = %.2f %s\n",snum,tag,val,typestr);
+ } else printf("sensor %x type %x reading = %02x\n",
+ snum,sdrbuf[3],reading[2]);
+ }
+
+ free_sdr_cache(sdrlist);
+ } /*endif sdr_cache is valid*/
+#endif
+ ipmi_close_();
+ if (nodefile == NULL) done = 1;
+ } /*end while not done */
+
+do_exit:
+ show_outcome(progname,ret);
+ exit (ret);
+} /* end main()*/
+
+/* end ipmi_sample.c */
diff --git a/util/ipmi_sample.mak b/util/ipmi_sample.mak
new file mode 100644
index 0000000..41860c1
--- /dev/null
+++ b/util/ipmi_sample.mak
@@ -0,0 +1,57 @@
+# ipmi_sample.mak
+# This makefile will build the ipmiutil ipmi_sample application
+#
+LIBC_RT=libcmt.lib /NODEFAULTLIB:"msvcirt.lib"
+# LIBC_RT=msvcrt.lib /NODEFAULTLIB:"msvcirt.lib"
+
+MARCH=IX86
+# MARCH=X64
+# The ipmiutil directory
+SRC_D=%CD%
+LIB_D=%CD%
+INC=/I$(SRC_D)
+
+# Set your compiler options
+# CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CFLAGS_O=/W3 /Zi /MT /nologo
+CF_SAM=/DWIN32 $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /DHAVE_STRING_H
+CFLAGS_SAM=$(CFLAGS_O) $(CF_SAM)
+LFLAGS=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+LIBS_W=comsuppw.lib wbemuuid.lib
+LIBS_EX=advapi32.lib kernel32.lib wsock32.lib ws2_32.lib $(LIBS_W) $(LIBC_RT)
+LIBS_PEF=/LIBPATH:$(LIB_D) iphlpapi.lib
+CC=cl
+LINK=link
+RM=del
+
+HEADER = ipmicmd.h
+SAMP_LIB = ipmiutil.lib
+TARG1_EXE = ipmi_sample.exe
+TARG2_EXE = ipmi_sample_evt.exe
+
+###################################################################
+all: $(TARG1_EXE)
+
+clean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG1_EXE) 2>NUL
+
+ipmi_sample.obj: ipmi_sample.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+
+$(TARG1_EXE): $(SAMP_LIB) ipmi_sample.obj
+ $(LINK) $(LFLAGS) /OUT:$(TARG1_EXE) ipmi_sample.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample_evt.obj: ipmi_sample_evt.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample_evt.c
+
+isensor2.obj: isensor.c isensor.h $(HEADER)
+ $(CC) /c /Foisensor2.obj $(CFLAGS_SAM) isensor.c
+
+ievents2.obj: ievents.c ievents.h $(HEADER)
+ $(CC) /c /Foievents2.obj $(CFLAGS_SAM) /DSENSORS_OK ievents.c
+
+$(TARG2_EXE): $(SAMP_LIB) ipmi_sample_evt.obj ievents2.obj isensor2.obj
+ $(LINK) $(LFLAGS) /OUT:$(TARG2_EXE) ipmi_sample_evt.obj ievents2.obj isensor2.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+
diff --git a/util/ipmi_sample_evt.c b/util/ipmi_sample_evt.c
new file mode 100644
index 0000000..b51ba24
--- /dev/null
+++ b/util/ipmi_sample_evt.c
@@ -0,0 +1,445 @@
+/*
+ * ipmi_sample_evt.c
+ *
+ * A sample IPMI utility to get IPMI SEL events.
+ *
+ * 09/10/12 Andy Cress - created
+ */
+/*M*
+Copyright (c) 2012, Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron America, Inc. nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include "ipmicmd.h"
+
+extern int decode_sel_entry(uchar *evt, char *obuf, int sz); /*see ievents.c*/
+extern void set_sel_opts(int sensdesc, int canon, void *sdrs, char dbg, char u);
+extern char *get_sensor_type_desc(uchar stype); /*see ievents.c*/
+extern int get_sdr_cache(uchar **pret); /*see isensor.c*/
+extern void free_sdr_cache(uchar *pret); /*see isensor.c*/
+extern int write_syslog(char *msg); /*see isel.c*/
+
+/*
+ * Global variables
+ */
+static char * progname = "ipmi_sample_evt";
+static char * progver = "1.0";
+static char fdebug = 0;
+static char fset_mc = 0;
+static char fipmilan = 0;
+static char finit_ok = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static char *mytag = NULL;
+static char *sdrfile = NULL;
+static ushort sel_recid = 0;
+static uint sel_time = 0;
+static int wait_interval = 3; /* 3 seconds between calls */
+static uchar *sdrs = NULL;
+static int drvtype = 0; /* driver_type from ipmicmd.h: 3=MV_OpenIPMI */
+FILE *fdout = NULL;
+#define LAST_REC 0xFFFF
+#ifdef WIN32
+static char idxfile[80] = "c:\\ipmievt.idx";
+static char outfile[80] = "c:\\ipmievt.log";
+#else
+static char idxfile[80] = "/var/lib/ipmiutil/ipmievt.idx";
+static char outfile[80] = "/var/log/ipmievt.log";
+#endif
+
+/* These routines were copied from igetevent.c
+ * msgout, getevent_sel, syncevent_sel, show_event, ievt_cleanup
+ */
+static void ievt_cleanup(void);
+static void msgout(char *pattn, ...)
+{
+ va_list arglist;
+
+ if (fdout == NULL) return;
+ va_start( arglist, pattn );
+ vfprintf( fdout, pattn, arglist );
+ va_end( arglist );
+ fflush( fdout );
+}
+
+#if defined(WIN32) | defined(DOS)
+/* no daemon code */
+static void ievt_siginit(void) { return; }
+#else
+/* Linux daemon code */
+#include <signal.h>
+static void ievt_sighnd(int sig)
+{
+ ievt_cleanup();
+ exit(EXIT_SUCCESS);
+}
+
+static void ievt_siginit(void);
+static void ievt_siginit(void)
+{
+ struct sigaction sact;
+
+ /* handle signals for cleanup */
+ sact.sa_handler = ievt_sighnd;
+ sact.sa_flags = 0;
+ sigemptyset(&sact.sa_mask);
+ sigaction(SIGINT, &sact, NULL);
+ sigaction(SIGQUIT, &sact, NULL);
+ sigaction(SIGTERM, &sact, NULL);
+}
+#endif
+
+static int get_sel_entry(ushort recid, ushort *nextid, uchar *rec)
+{
+ uchar ibuf[6];
+ uchar rbuf[32];
+ int rlen;
+ ushort xid, id = 0;
+ uchar cc;
+ int rv;
+
+ ibuf[0] = 0;
+ ibuf[1] = 0;
+ ibuf[2] = (recid & 0x00ff);
+ ibuf[3] = (recid & 0xff00) >> 8;
+ ibuf[4] = 0;
+ ibuf[5] = 0xFF; /*get entire record*/
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmd(GET_SEL_ENTRY, ibuf, 6, rbuf, &rlen, &cc, fdebug);
+ if (rv == 0) {
+ if (cc != 0) rv = cc;
+ else { /*success*/
+ xid = rbuf[0] + (rbuf[1] << 8); /*next rec id*/
+ memcpy(rec,&rbuf[2],16);
+ *nextid = xid;
+ id = rbuf[2] + (rbuf[3] << 8); /*curr rec id*/
+ /* recid (requested) should match newid (received) */
+ if (fdebug) {
+ if ((recid != id) && (recid != LAST_REC) && (recid != 0)) {
+ /* the OpenIPMI driver does this sometimes */
+ msgout("get_sel MISMATCH: recid=%x newid=%x next=%x\n",
+ recid,id,xid);
+ dump_buf("get_sel cmd",ibuf,6,0);
+ dump_buf("get_sel rsp",rbuf,rlen,0);
+ }
+ }
+ }
+ }
+ if (fdebug) msgout("get_sel(%x) rv=%d cc=%x id=%x next=%x\n",
+ recid,rv,cc,id,*nextid);
+ return(rv);
+}
+
+static int getevent_sel(uchar *rdata, int *rlen, uchar *ccode)
+{
+ uchar rec[24];
+ int rv = 0;
+ ushort newid;
+ ushort nextid;
+ ushort recid;
+
+ /* get current last record */
+ recid = sel_recid;
+ rv = get_sel_entry(recid,&nextid,rec);
+ if (rv == 0xCB && recid == 0) { /* SEL is empty */
+ *ccode = (uchar)rv; /* save the real ccode */
+ rv = 0x80; /* this is ok, just keep waiting */
+ }
+ if (rv == 0) {
+ if (fdebug) msgout("sel ok, id=%x next=%x\n",recid,nextid);
+ if ((nextid == LAST_REC) || (recid == nextid)) {
+ *ccode = 0x80; /*nothing new*/
+ } else {
+ recid = nextid; /* else get new one */
+ rv = get_sel_entry(recid,&nextid,rec);
+ if (rv == 0) { /* new event */
+ newid = rec[0] + (rec[1] << 8);
+ if (drvtype == DRV_MV && recid != newid) {
+ /* handle MV driver bug, try to get next one. */
+ if (fdebug) msgout("%s bug, record mismatch\n",
+ show_driver_type(DRV_MV));
+ }
+ if (fdebug) msgout("recid=%x newid=%x next=%x\n",
+ recid,newid,nextid);
+ memcpy(rdata,rec,16);
+ *rlen = 16;
+ *ccode = 0;
+ sel_recid = recid; /*or newid*/
+ memcpy(&sel_time,&rec[2],4);
+ }
+ }
+ }
+ else { /* Error reading last recid saved */
+ if (fdebug) msgout("sel recid %x error, rv = %d\n",recid,rv);
+ /* We want to set sel_recid = 0 here for some errors. */
+ if (rv == 0xCB || rv == 0xCD) { /* empty, or wrong SDR id */
+ sel_recid = 0;
+ *ccode = (uchar)rv;
+ rv = 0x80; /* wait again */
+ }
+ }
+ return(rv);
+}
+
+static int startevent_sel(ushort *precid, uint *ptime)
+{
+ FILE *fd;
+ uchar rec[24];
+ uint t = 0;
+ ushort r = 0;
+ ushort r2 = 0;
+ int rv = -1;
+
+ fd = fopen(idxfile,"r");
+ if (fdebug) msgout("start: idxfile=%s fd=%p\n",idxfile,fd);
+ if (fd != NULL) {
+ // Read the file, get savtime & savid
+ rv = fscanf(fd,"%x %x",&t,&r);
+ fclose(fd);
+ if (r == LAST_REC) r = 0;
+ rv = 0; /*read it, success*/
+ } else { /* treat as first time */
+ r = LAST_REC;
+ rv = get_sel_entry(r,&r2,rec);
+ if (rv == 0) {
+ memcpy(&t,&rec[2],4);
+ r = rec[0] + (rec[1] << 8); /*use current rec id*/
+ } else r = 0;
+ rv = 1; /*first time*/
+ }
+ if (fdebug) msgout("start: recid=%x time=%x\n",r,t);
+ *ptime = t;
+ *precid = r;
+ return(rv);
+}
+
+static int syncevent_sel(ushort recid, uint itime)
+{
+ FILE *fd;
+ int rv;
+ // Rewrite the saved time & record id
+ if (fdebug) msgout("sync: recid=%x time=%x\n",recid,itime);
+ fd = fopen(idxfile,"w");
+ if (fd == NULL) {
+ msgout("syncevent: cannot open %s for writing\n",idxfile);
+ rv = -1;
+ } else {
+ fprintf(fd,"%x %x\n",itime,recid);
+ fclose(fd);
+ rv = 0;
+ }
+ return(rv);
+}
+
+static void ievt_cleanup(void)
+{
+ char obuf[48];
+ snprintf(obuf,sizeof(obuf),"%s exiting.\n",progname);
+ msgout(obuf);
+ write_syslog(obuf);
+ if (finit_ok) {
+ syncevent_sel(sel_recid,sel_time);
+ free_sdr_cache(sdrs);
+ }
+ ipmi_close_(); /*inert if not opened*/
+ exit(EXIT_SUCCESS);
+}
+
+void show_event(uchar *evt,char *obuf, int sz)
+{
+ int i;
+ char sysbuf[250];
+ /* obuf should be 132 chars or more */
+
+ msgout("event data: ");
+ for (i=0; i<16; i++) msgout("%02x ",evt[i]);
+ msgout("\n");
+
+ decode_sel_entry(evt,obuf,sz);
+ msgout(obuf); /*writes to outfile*/
+ /* write the message to syslog also. */
+ snprintf(sysbuf,sizeof(sysbuf),"%s: %s",progname,obuf);
+ write_syslog(sysbuf);
+}
+
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+{
+ int ret = 0;
+ char c;
+ uchar devrec[16];
+ uchar event[32]; /*usu 16 bytes */
+ char outbuf[160];
+ char *s1;
+ int rlen;
+ uchar ccode;
+ uchar sensor_type;
+
+ fdout = stderr;
+ printf("%s ver %s\n", progname,progver);
+
+ while ( (c = getopt( argc, argv,"m:s:t:xEF:N:P:R:T:U:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 's': sdrfile = optarg; break;
+ case 't': mytag = optarg; break; /* specific sensor tag */
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-msx -NUPREFTVY]\n", progname);
+ printf(" where -x show eXtra debug messages\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -s File loads SDRs from File\n");
+ printf(" -t tag search for 'tag' in SDRs\n");
+ print_lan_opt_usage();
+ exit(1);
+ }
+ /* Rather than parse_lan_options above, the set_lan_options function
+ * could be used if the program already knows the nodename, etc. */
+
+ fipmilan = is_remote();
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ printf("Cannot do ipmi_getdeviceid, ret = %d\n",ret);
+ goto do_exit;
+ } else { /*success*/
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+ drvtype = get_driver_type();
+
+ /* could make it a daemon here, if desired */
+ fdout = fopen(outfile,"a");
+ if (fdout == NULL) {
+ printf("%s: Cannot open %s\n", progname,outfile);
+ fdout = stderr;
+ } else {
+ sprintf(outbuf,"%s ver %s started\n", progname,progver);
+ msgout(outbuf);
+ }
+ sprintf(outbuf,"%s reading sensors ...\n",progname);
+ write_syslog(outbuf);
+ ret = get_sdr_cache(&sdrs);
+ if (fdebug) msgout("get_sdr_cache ret = %d\n",ret);
+ if (ret == 0) set_sel_opts(1,0, sdrs,fdebug,0);
+
+ if (fipmilan) {
+ char *node;
+ node = get_nodename();
+ strcat(idxfile,"-");
+ strcat(idxfile,node);
+ strcat(outfile,"-");
+ strcat(outfile,node);
+ }
+ ret = startevent_sel(&sel_recid,&sel_time);
+
+ ievt_siginit();
+ finit_ok = 1;
+ ret = 0; /*ignore any earlier errors, keep going*/
+
+ while (ret == 0)
+ { /*wait for bmc message events*/
+ if (fdebug)
+ msgout("%s: Polling every %d sec for a new event after id %x...\n",
+ progname, wait_interval, sel_recid);
+ rlen = sizeof(event);
+ ret = getevent_sel(event,&rlen,&ccode);
+ if (ret == 0) ret = ccode;
+ if (fdebug) msgout("getevent_sel ret = %d\n",ret);
+ if (ret == 0) { /* got an event successfully */
+ sensor_type = event[10];
+ msgout("got event id %04x, sensor_type = %02x\n",
+ sel_recid,sensor_type);
+ show_event(event,outbuf,sizeof(outbuf));
+ syncevent_sel(sel_recid,sel_time);
+ } else if (ret == 0x80) {
+ ret = 0; /*keep waiting*/
+ } else {
+ msgout("get_event error: ret = 0x%x\n",ret);
+ break;
+ }
+ os_usleep(wait_interval,0);
+ } /*end while loop*/
+
+do_exit:
+ ievt_cleanup();
+ show_outcome(progname,ret);
+ exit (ret);
+} /* end main()*/
+
+/* end ipmi_sample_evt.c */
diff --git a/util/ipmibmc.c b/util/ipmibmc.c
new file mode 100644
index 0000000..e895338
--- /dev/null
+++ b/util/ipmibmc.c
@@ -0,0 +1,231 @@
+/*M*
+// $Workfile: ipmibmc.c $
+// $Revision: 1.0 $
+// $Modtime: 12 Nov 2008 15:20:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the /dev/bmc interface from
+// the Solaris 10 IPMI driver.
+//
+// 11/12/08 ARC - created
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2008, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef SOLARIS
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stropts.h>
+#include <stddef.h>
+#include <stropts.h>
+#include <iso/stdlib_iso.h>
+
+#include "ipmicmd.h" /* for uchar, NCMDS */
+
+#define MAX_SEND_SIZE 34
+#define MAX_RECV_SIZE 33
+#define MIN_RQ_SIZE 2
+#define MIN_RS_SIZE 3
+#define MAX_BUF_SIZE 256
+#define MSG_BUF_SIZE 1024
+
+// #define IOCTL_IPMI_KCS_ACTION 0x01
+// #define IOCTL_IPMI_INTERFACE_METHOD 0x02
+#define BMC_MSG_REQ 1
+#define BMC_MSG_RSP 2
+#define BMC_MSG_ERR 3
+
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+static int ipmi_fd = -1;
+
+typedef struct bmc_rq {
+ uchar netfn;
+ uchar lun;
+ uchar cmd;
+ uchar dlen;
+ uchar data[MAX_SEND_SIZE];
+} bmc_rq_t;
+
+typedef struct bmc_rs {
+ uchar netfn;
+ uchar lun;
+ uchar cmd;
+ uchar ccode;
+ uchar dlen;
+ uchar data[MAX_RECV_SIZE];
+} bmc_rs_t;
+
+typedef struct bmc_ioctl_t {
+ bmc_rq_t req;
+ bmc_rs_t rsp;
+} bmc_ioctl_t;
+
+typedef struct bmc_msg {
+ uchar m_type; /* Message type (1=req, 2=resp, 3=error)*/
+ uint32 m_id; /* Message ID */
+ uchar reserved[32];
+ uchar msg[1]; /* Variable length message data */
+} bmc_msg_t;
+
+
+int ipmi_open_bmc(char fdebugcmd)
+{
+ int rc = -1;
+ char *pdev;
+
+ if (ipmi_fd != -1) return(0);
+ pdev = "/dev/bmc";
+ ipmi_fd = open(pdev, O_RDWR);
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) printf("ipmi_open_bmc: cannot open %s, errno=%d\n",pdev,errno);
+ return(rc);
+ }
+
+ /* dont bother to check for ioctl method, just use putmsg method */
+
+ rc = 0;
+ if (fdebugcmd) printf("ipmi_open_bmc: successfully opened bmc\n");
+ return(rc);
+}
+
+int ipmi_close_bmc(void)
+{
+ int rc = 0;
+ if (ipmi_fd != -1) {
+ close(ipmi_fd);
+ ipmi_fd = -1;
+ }
+ return(rc);
+}
+
+int ipmi_cmdraw_bmc( uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ int rv = -1;
+ static uint32 msg_seq = 0;
+ int flags = 0;
+ struct strbuf sendbuf;
+ struct strbuf recvbuf;
+ bmc_msg_t *msg;
+ bmc_rq_t *rq;
+ bmc_rs_t *rs;
+ int sz, i;
+
+ if (sdata > MAX_SEND_SIZE) i = sdata - MAX_SEND_SIZE;
+ else i = 0;
+ sz = (sizeof(bmc_msg_t) - 1) + sizeof(bmc_rq_t) + i;
+ msg = malloc(sz);
+ if (msg == NULL) return(rv);
+ rq = (bmc_rq_t *)&msg->msg[0];
+
+ msg->m_type = BMC_MSG_REQ;
+ msg->m_id = msg_seq++;
+ rq->netfn = netfn;
+ rq->lun = lun;
+ rq->cmd = cmd;
+ rq->dlen = sdata;
+ memcpy(rq->data, pdata, sdata);
+ sendbuf.len = sz;
+ sendbuf.buf = (uchar *)msg;
+ if (fdebugcmd) {
+ dump_buf("ipmi_cmdraw_bmc sendbuf",sendbuf.buf,sendbuf.len,0);
+ }
+
+ rv = putmsg(ipmi_fd, NULL, &sendbuf, 0);
+ if (rv < 0) {
+ perror("BMC putmsg: ");
+ free(msg);
+ return(rv);
+ }
+ free(msg);
+
+ recvbuf.buf = malloc(MSG_BUF_SIZE);
+ recvbuf.maxlen = MSG_BUF_SIZE;
+ rv = getmsg(ipmi_fd, NULL, &recvbuf, &flags);
+ if (rv < 0) {
+ perror("BMC getmsg: ");
+ free(recvbuf.buf);
+ return(rv);
+ }
+
+ msg = (bmc_msg_t *)recvbuf.buf;
+ if (fdebugcmd) {
+ dump_buf("ipmi_cmdraw_bmc recvbuf",recvbuf.buf,recvbuf.len,0);
+ }
+ switch (msg->m_type) {
+ case BMC_MSG_RSP:
+ rs = (bmc_rs_t *)&msg->msg[0];
+ *pcc = rs->ccode;
+ i = rs->dlen;
+ if (i < 0) i = 0;
+ *sresp = i;
+ if (*pcc == 0 && i > 0)
+ memcpy(presp,rs->data,i);
+ rv = 0;
+ break;
+ case BMC_MSG_ERR:
+ default:
+ rv = msg->msg[0];
+ printf("ipmi_cmdraw_bmc: %s\n", strerror(rv));
+ break;
+ }
+ free(recvbuf.buf);
+
+ return(rv);
+}
+
+int ipmi_cmd_bmc(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ printf("ipmi_cmd_bmc: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) cmd = cmd & CMDMASK; /* unmask it */
+ rc = ipmi_cmdraw_bmc(cmd, ipmi_cmds[i].netfn, ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return(rc);
+}
+#endif
+/* end of ipmibmc.c */
diff --git a/util/ipmicmd.c b/util/ipmicmd.c
new file mode 100644
index 0000000..dd2268b
--- /dev/null
+++ b/util/ipmicmd.c
@@ -0,0 +1,1429 @@
+/*M*
+// PVCS:
+// $Workfile: ipmicmd.c $
+// $Revision: 1.12 $
+// $Modtime: 23 Feb 2005 11:24:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// Define the ipmi_cmd routine and supporting logic to execute IPMI
+// commands via one of the supported IPMI drivers:
+// /dev/ipmi0 /dev/ipmi/0 = MontaVista OpenIPMI driver
+// /dev/imb = Intel IMB ipmidrvr (comes with ISM)
+// /dev/ipmikcs /dev/ipmi/kcs = valinux driver by San Mehat
+// libfreeipmi.so = GNU FreeIPMI user-space library
+// ldipmidaemon = LanDesk IPMI daemon (user-space process)
+//
+// 08/05/02 ARC - created
+// 08/15/02 ARC - added decode_cc
+// 10/24/02 ARC - made cmd param ushort to be more unique
+// 01/29/03 ARC - added MontaVista OpenIPMI driver support
+// 07/25/03 ARC - added serial-over-lan commands
+// 07/30/03 ARC - added GetThresholds, fix for ipmi_cmd_raw,
+// changed some error messages
+// 09/04/03 ARC - added debug messages for fDriverTyp first time
+// 05/05/04 ARC - leave _mv device open, rely on each app calling ipmi_close,
+// helps performance.
+// 08/10/04 ARC - fix typo in ipmi_cmd_raw/mv: cmd->icmd (thanks Kevin Gao)
+// 08/26/04 ARC - fix out-of-bounds error in decode_cc
+// 10/27/04 ARC - added gnu FreeIPMI library support
+// 11/11/04 ARC - added fdebug to ipmi_getdeviceid & ipmi_open_gnu
+// 02/23/05 ARC - added routines for LanDesk, fDriverTyp=5
+// 07/15/05 ARC - test for ldipmi first, since it hangs KCS if another
+// driver tries to coexist.
+// 07/06/06 ARC - better separate driver implementations, cleaner now
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2002-2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <io.h>
+#include <fcntl.h>
+#elif defined(EFI)
+// defined (EFI32) || defined (EFI64) || defined(EFIX64)
+#include <bmc.h>
+#include <libdbg.h>
+#else
+/* Linux, Solaris, BSD */
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#ifndef DOS
+#include <sys/ioctl.h>
+#include <termios.h>
+#endif
+#include <stdarg.h>
+#include <errno.h>
+#endif
+
+#include "ipmicmd.h" /* has NCMDS, ipmi_cmd_t */
+
+ipmi_cmd_t ipmi_cmds[NCMDS] = { /*if add here, also change NCMDS in ipmicmd.h*/
+ {/*empty,temp*/ 0, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 20},
+ {GET_SEL_INFO, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 0, 14},
+ {GET_SEL_ALLOCATION_INFO,BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 0, 9},
+ {GET_SEL_ENTRY, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 6, 18},
+ {RESERVE_SEL, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 0, 2},
+ {CLEAR_SEL, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 6, 1},
+ {GET_SEL_TIME, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 6, 4},
+ {GET_LAN_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 4, 19},
+ {SET_LAN_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 21, 0},
+ {GET_LAN_STATS, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 2, 18},
+ {GET_SER_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 4, 19},
+ {SET_SER_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 21, 0},
+ {SET_SER_MUX, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 2, 0},
+ {GET_PEF_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 3, 22},
+ {SET_PEF_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 22, 0},
+// {SET_PEF_ENABLE, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 4, 0}, /*old*/
+ {GET_DEVSDR_INFO, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 0, 6},
+ {GET_DEVICE_SDR, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 6, 18},
+ {RESERVE_DEVSDR_REP,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 0, 2},
+ {GET_SENSOR_READING,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 1, 4},
+ {GET_SENSOR_READING_FACTORS,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 2, 7},
+ {GET_SENSOR_TYPE, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 1, 2},
+ {GET_SENSOR_THRESHOLD,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 1, 7},
+ {SET_SENSOR_THRESHOLD,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 8, 0},
+ {GET_SENSOR_HYSTERESIS,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 2, 2},
+ {SET_SENSOR_HYSTERESIS,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 4, 0},
+ {GET_SDR, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 6, 18},/*full=63*/
+ {GET_SDR_REPINFO, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 0, 14},
+ {RESERVE_SDR_REP, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 0, 2},
+ {GET_FRU_INV_AREA, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 1, 3},
+ {READ_FRU_DATA, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN, 4, 18},
+ {WRITE_FRU_DATA, BMC_SA, PUBLIC_BUS, NETFN_STOR, BMC_LUN,20 /*3+N(17)*/, 1},
+ {GET_DEVICE_ID, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 15},
+ {SET_USER_ACCESS, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 4, 0},
+ {GET_USER_ACCESS, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 2, 4},
+ {GET_USER_NAME, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 1, 16},
+ {SET_USER_NAME, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 17, 0},
+ {SET_USER_PASSWORD,BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 18, 0},
+ {MASTER_WRITE_READ,BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 4 /*or 3*/, 1},
+ {GET_SYSTEM_GUID, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 16},
+ {WATCHDOG_GET, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 8},
+ {WATCHDOG_SET, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 6, 0},
+ {WATCHDOG_RESET, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 0},
+ {CHASSIS_STATUS, BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 0, 2},
+ {CHASSIS_CTL, BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 1, 0},
+ {CHASSIS_IDENTIFY, BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 1, 0},
+ {GET_POWERON_HOURS,BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 0, 0},
+ {SET_BOOT_OPTIONS, BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 19, 0},
+ {GET_BOOT_OPTIONS, BMC_SA, PUBLIC_BUS, NETFN_CHAS, BMC_LUN, 3, 18},
+ {ACTIVATE_SOL1, BMC_SA, PUBLIC_BUS, NETFN_SOL, BMC_LUN, 0, 0},
+ {SET_SOL_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_SOL, BMC_LUN, 3, 0},
+ {GET_SOL_CONFIG, BMC_SA, PUBLIC_BUS, NETFN_SOL, BMC_LUN, 4, 2},
+ {ACTIVATE_SOL2, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 0, 0},
+ {SET_SOL_CONFIG2, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 3, 0},
+ {GET_SOL_CONFIG2, BMC_SA, PUBLIC_BUS, NETFN_TRANS, BMC_LUN, 4, 2},
+ {GET_SEVT_ENABLE, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 1, 5},
+ {SET_SEVT_ENABLE, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 6, 0},
+ {REARM_SENSOR, BMC_SA, PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 6, 0},
+ {READ_EVENT_MSGBUF,BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 0, 16},
+ {GET_EVENT_RECEIVER,BMC_SA,PUBLIC_BUS, NETFN_SEVT, BMC_LUN, 0, 2},
+ {GET_CHANNEL_INFO, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 1, 9},
+ {SET_CHANNEL_ACC, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 3, 0},
+ {GET_CHANNEL_ACC, BMC_SA, PUBLIC_BUS, NETFN_APP, BMC_LUN, 2, 1} };
+
+/* Subroutine definitions for each driver */
+#ifdef EFI
+int ipmi_open_efi(char fdebug);
+int ipmi_cmdraw_efi( uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+#else
+
+#include "ipmilan2.h" /*includes ipmilan.h also*/
+#ifdef WIN32
+extern int ipmi_cmdraw_ia( uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_ia(char fdebug);
+extern int ipmi_close_ia(void);
+extern int ipmi_cmdraw_ms(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_ms(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_ms(char fdebug);
+extern int ipmi_close_ms(void);
+#elif defined(SOLARIS)
+extern int ipmi_cmdraw_bmc(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_bmc(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_bmc(char fdebug);
+extern int ipmi_close_bmc(void);
+extern int ipmi_cmdraw_lipmi(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_lipmi(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_lipmi(char fdebug);
+extern int ipmi_close_lipmi(void);
+#elif defined(LINUX)
+extern int ipmi_cmdraw_ia( uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_ia(char fdebug);
+extern int ipmi_close_ia(void);
+extern int ipmi_cmdraw_mv(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_mv(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_mv(char fdebug);
+extern int ipmi_close_mv(void);
+extern int ipmi_open_ld(char fdebug);
+extern int ipmi_close_ld(void);
+extern int ipmi_cmdraw_ld(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_ld(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_direct(char fdebug);
+extern int ipmi_close_direct(void);
+extern int ipmi_cmdraw_direct( uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_direct(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_set_max_kcs_loops(int ms);
+#elif defined(DOS)
+extern int ipmi_open_direct(char fdebug);
+extern int ipmi_close_direct(void);
+extern int ipmi_cmdraw_direct( uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_direct(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_set_max_kcs_loops(int ms);
+#else
+/* BSD */
+extern int ipmi_open_direct(char fdebug);
+extern int ipmi_close_direct(void);
+extern int ipmi_cmdraw_direct( uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_direct(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_set_max_kcs_loops(int ms);
+extern int ipmi_cmdraw_mv(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_cmd_mv(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+extern int ipmi_open_mv(char fdebug);
+extern int ipmi_close_mv(void);
+#endif
+extern int fd_wait(int fd, int nsec, int usec);
+#endif
+
+/* Global Data */
+int fDriverTyp = DRV_UNKNOWN; /* 1=IMB driver, 2=VA driver, 3=MV open driver */
+ /* 4= GNU FreeIPMI, 5= LanDesk, 6= builtin IPMI LAN */
+ /* 7= direct KCS, 8= direct SMB, 9= IPMI LAN v2.0 */
+int fipmi_lan = 0;
+int fjustpass = 0;
+FILE *fperr = NULL;
+FILE *fpdbg = NULL;
+FILE *fplog = NULL;
+char log_name[60] = {'\0'}; /*log_name global*/
+char *gnode = "localhost"; /* used for IPMI LAN, specified with option -N */
+char *guser = NULL;
+char *gpswd = NULL;
+char gnodename[SZGNODE] = {0}; /*the node name returned after a connection */
+int gcipher_suite = 3; /*used in ipmilanplus.c*/
+int gshutdown = 0;
+int fauth_type_set = 0;
+int gauth_type = IPMI_SESSION_AUTHTYPE_MD5; /*if 0, use any: MD5, MD2, etc.*/
+int gpriv_level = IPMI_PRIV_LEVEL_USER; /*or IPMI_PRIV_LEVEL_ADMIN */
+int gaddr_len = 0;
+uchar gaddr[128]; /* sizeof(struct sockaddr_storage) = 128 */
+ /* struct sockaddr_in/_in6 gaddr; _in6=28, _in=16 bytes */
+uchar my_devid[20] = {0,0,0,0,0,0,0,0}; /*saved devid, only needs 16 bytes*/
+char fdebug = 0;
+
+typedef struct {
+ uchar adrtype;
+ uchar sa;
+ uchar bus;
+ uchar lun;
+ uchar capab;
+} mc_info;
+mc_info bmc = { ADDR_SMI, BMC_SA, PUBLIC_BUS, BMC_LUN, 0x8F }; /*BMC via SMI*/
+mc_info mc2 = { ADDR_IPMB, BMC_SA, PUBLIC_BUS, BMC_LUN, 0x4F }; /*IPMB target*/
+mc_info mymc = { ADDR_IPMB, BMC_SA, PUBLIC_BUS, BMC_LUN, 0x4F }; /*IPMB */
+static char bcomma = ',';
+static mc_info *mc = &bmc;
+#ifdef WIN32
+static char msg_no_drv[] = { /*no Windows driver*/
+ "Cannot open an IPMI driver: imbdrv.sys or ipmidrv.sys\n"};
+#elif defined(SOLARIS)
+static char msg_no_drv[] = { /*no Solaris driver*/
+ "Cannot open an IPMI driver: /dev/bmc or /dev/lipmi\n"};
+#elif defined(LINUX)
+static char msg_no_drv[] = { /*no Linux driver*/
+ "Cannot open an IPMI driver: /dev/imb, /dev/ipmi0, "
+ "/dev/ipmi/0, \n\t "
+/* "/dev/ipmikcs, /dev/ipmi/kcs, " *no longer support valinux */
+#ifdef LINK_LANDESK
+ "ldipmi, "
+#endif
+ "or direct driverless.\n" };
+
+#elif defined(DOS)
+static char msg_no_drv[] = { /*no DOS IPMI driver*/
+ "Cannot open an IPMI direct KCS interface.\n"};
+#else
+static char msg_no_drv[] = { /*no BSD IPMI driver*/
+ "Cannot open an IPMI driver: /dev/ipmi0 or direct.\n"};
+#endif
+
+/* From IPMI v1.5/v2.0 spec, Table 5-2 Completion Codes */
+#define NUMCC 32
+struct {
+ uchar code;
+ char *mesg;
+ } cc_mesg[NUMCC] = {
+/* Note: completion codes 0x80-0x9f may vary depending on the command.
+ * 0x80 = Invalid Session Handle or Empty Buffer or Unsupported Feature
+ */
+{0x00, "Command completed successfully"},
+{0x80, "Invalid Session Handle or Empty Buffer"},
+{0x81, "Lost Arbitration"},
+{0x82, "Bus Error"},
+{0x83, "NAK on Write - busy"},
+{0x84, "Truncated Read"},
+{0x85, "Invalid session ID in request"}, /*for ActivateSession*/
+{0x86, "Requested privilege level exceeds limit"}, /*for ActivateSession*/
+{0xC0, "Node Busy"},
+{0xC1, "Invalid Command"},
+{0xC2, "Command invalid for given LUN"},
+{0xC3, "Timeout while processing command"},
+{0xC4, "Out of space"},
+{0xC5, "Reservation ID cancelled or invalid"},
+{0xC6, "Request data truncated"},
+{0xC7, "Request data length invalid"},
+{0xC8, "Request data field length limit exceeded"},
+{0xC9, "Parameter out of range"},
+{0xCA, "Cannot return requested number of data bytes"},
+{0xCB, "Requested sensor, data, or record not present"},
+{0xCC, "Invalid data field in request"},
+{0xCD, "Command illegal for this sensor/record type"},
+{0xCE, "Command response could not be provided"},
+{0xCF, "Cannot execute duplicated request"},
+{0xD0, "SDR Repository in update mode, no response"},
+{0xD1, "Device in firmware update mode, no response"},
+{0xD2, "BMC initialization in progress, no response"},
+{0xD3, "Destination unavailable"},
+{0xD4, "Cannot execute command. Insufficient privilege level"},
+{0xD5, "Cannot execute command. Request parameters not supported"},
+{0xD6, "Cannot execute command. Subfunction unavailable"},
+{0xFF, "Unspecified error"}
+};
+
+char * decode_cc(ushort icmd, int cc)
+{
+ static char other_msg[25];
+ char *pmsg;
+ int i;
+ for (i = 0; i < NUMCC; i++) {
+ if (cc == cc_mesg[i].code) break;
+ }
+ if (i == NUMCC) { /* if not found, show other_msg */
+ sprintf(other_msg,"Other error 0x%02x",cc);
+ pmsg = other_msg;
+ } else {
+ if ((icmd == READ_EVENT_MSGBUF) && (cc == 0x80))
+ pmsg = "no data available (queue/buffer empty)";
+ else pmsg = cc_mesg[i].mesg;
+ }
+ return(pmsg);
+}
+
+char *decode_rv(int rv)
+{
+ char *msg;
+ static char msgbuf[80];
+ if (rv == 0x6F) msg = "License not supported"; /*for Dell*/
+ else if (rv > 0) msg = decode_cc((ushort)0,rv);
+ else switch(rv) {
+ case 0: msg = "completed successfully"; break;
+ case -1: msg = "error -1"; break;
+ case LAN_ERR_SEND_FAIL: msg = "send to BMC failed"; break;
+ case LAN_ERR_RECV_FAIL: msg = "receive from BMC failed"; break;
+ case LAN_ERR_CONNECT: msg = "cannot connect to BMC"; break;
+ case LAN_ERR_ABORT: msg = "abort signal caught"; break;
+ case LAN_ERR_TIMEOUT: msg = "timeout occurred"; break;
+ case LAN_ERR_BADLENGTH: msg = "length greater than max"; break;
+ case LAN_ERR_INVPARAM: msg = "invalid lan parameter"; break;
+ case LAN_ERR_NOTSUPPORT: msg = "request not supported"; break;
+ case LAN_ERR_TOO_SHORT: msg = "receive too short"; break;
+ case LAN_ERR_HOSTNAME: msg = "error resolving hostname"; break;
+ case LAN_ERR_PING: msg = "error during ping"; break;
+ case LAN_ERR_V1: msg = "BMC only supports lan v1"; break;
+ case LAN_ERR_V2: msg = "BMC only supports lan v2"; break;
+ case LAN_ERR_OTHER: msg = "other error"; break;
+ case ERR_NO_DRV: msg = "cannot open IPMI driver"; break;
+ case ERR_BAD_PARAM: msg = "invalid parameter"; break;
+ case ERR_NOT_ALLOWED: msg = "access not allowed"; break;
+ case ERR_USAGE: msg = "usage or help requested"; break;
+ case LAN_ERR_DROPPED: msg = "session dropped by BMC"; break;
+ case ERR_FILE_OPEN: msg = "cannot open file"; break;
+ case ERR_NOT_FOUND: msg = "item not found"; break;
+ case ERR_BMC_MSG: msg = "error getting msg from BMC"; break;
+ /* ipmidir.h: ERGETTINGIPMIMESSAGE -504 */
+ case ERR_BAD_FORMAT: msg = "bad format"; break;
+ case ERR_BAD_LENGTH: msg = "length less than min"; break;
+ default:
+ sprintf(msgbuf,"error %d",rv);
+ msg = msgbuf;
+ break;
+ }
+ return(msg);
+}
+
+int get_cmd_rslen(uchar cmd, uchar netfn)
+{ /* used by ipmicmd_gnu */
+ int rslen = 0;
+ int i;
+ ushort cmdkey;
+ cmdkey = cmd | (netfn << 8);
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmdkey) {
+ rslen = ipmi_cmds[i].rslen;
+ break;
+ }
+ }
+ return(rslen);
+} /*end get_cmd_rslen()*/
+
+static int ndrivers = NDRIVERS;
+static struct {
+ int idx;
+ char *tag;
+ } drv_types[NDRIVERS] = {
+ { DRV_IMB, "imb" },
+ { DRV_MV, "open" },
+ { DRV_LD, "landesk" },
+ { DRV_LAN2, "lan2" },
+ { DRV_LAN2I,"lan2i" },
+ { DRV_LAN, "lan" },
+ { DRV_KCS, "kcs" },
+ { DRV_SMB, "smb" },
+ { DRV_MS, "ms" },
+ { DRV_BMC, "sun_bmc" },
+ { DRV_LIPMI,"sun_lipmi" },
+ { DRV_SMC, "supermicro" },
+ { DRV_IBM, "ibm" },
+ { DRV_HP, "hp" }, /*++++*/
+#ifdef EFI
+ { DRV_EFI, "efi" }
+#else
+ { 0, "" } /*DRV_UNKNOWN*/
+#endif
+};
+ // { DRV_VA, "va" },
+ // { DRV_GNU, "free" },
+
+char *show_driver_type(int idx)
+{
+ int i;
+ char *tag;
+ for (i = 0; i < ndrivers; i++)
+ {
+ if (drv_types[i].idx == idx) {
+ tag = drv_types[i].tag;
+ break;
+ }
+ }
+ if (i >= ndrivers) { /*not found*/
+ tag = "unknown";
+ }
+ return(tag);
+}
+
+int get_driver_type(void)
+{
+ return(fDriverTyp);
+}
+
+void set_iana(int iana)
+{
+ my_devid[6] = (iana & 0x0000ff);
+ my_devid[7] = ((iana & 0x00ff00) >> 8);
+ my_devid[8] = ((iana & 0xff0000) >> 16);
+}
+
+void set_mfgid(uchar *devid, int len)
+{
+ if (devid == NULL) return;
+ if (len > sizeof(my_devid)) len = sizeof(my_devid);
+ memcpy(my_devid,devid,len);
+}
+
+void get_mfgid(int *pvend, int *pprod)
+{
+ if (pvend != NULL)
+ *pvend = my_devid[6] + (my_devid[7] << 8) + (my_devid[8] << 16);
+ if (pprod != NULL)
+ *pprod = my_devid[9] + (my_devid[10] << 8);
+}
+
+int set_driver_type(char *tag)
+{
+ int rv = 0;
+ int i;
+ /* else if (str_icmp(tag,"lan2") == 0) * leave vendor id as is. */
+ for (i = 0; i < ndrivers; i++)
+ {
+ if (str_icmp(drv_types[i].tag, tag) == 0) {
+ fDriverTyp = drv_types[i].idx;
+ if (fDriverTyp == DRV_LAN2I) { /*LAN2 Intel*/
+ set_iana(VENDOR_INTEL); /*VENDOR_INTEL = 0x000157*/
+ } else if (fDriverTyp == DRV_SMC) { /*supermicro*/
+ set_iana(VENDOR_SUPERMICRO); /*VENDOR_SUPERMICRO = 0x002A7C*/
+ fDriverTyp = DRV_LAN;
+ }
+ if (fDriverTyp == DRV_IBM) { /*LAN IBM*/
+ set_iana(VENDOR_IBM);
+ fDriverTyp = DRV_LAN;
+ }
+ if (fDriverTyp == DRV_HP) { /*LAN2 HP ++++*/
+ set_iana(VENDOR_HP);
+ fDriverTyp = DRV_LAN2;
+ gauth_type = IPMI_SESSION_AUTHTYPE_NONE; /*HP default*/
+ }
+ break;
+ }
+ }
+ if (i >= ndrivers) { /*not found*/
+ fDriverTyp = DRV_UNKNOWN; /*not set yet, so detect*/
+ rv = 1;
+ // if (fdebugcmd)
+ {
+ printf("Invalid -F argument (%s), valid driver types are:\n",tag);
+ for (i = 0; i < ndrivers; i++)
+ printf("\t%s\n",drv_types[i].tag);
+ }
+ }
+ return(rv);
+}
+
+/*
+ * use_devsdrs
+ * detect whether to use SDR repository or Device SDRs from
+ * the saved GetDeviceID response.
+ * ipmi_getdeviceid saves it into my_devid.
+ */
+int use_devsdrs(int picmg)
+{
+ int fdev, vend, prod;
+ /* set Device SDRs flag as specified in the GetDeviceID */
+ if ((my_devid[1] & 0x80) == 0x80) fdev = 1;
+ else fdev = 0;
+ if (picmg) return(fdev);
+ /* check for vendor/products that can report the flag wrong */
+ vend = my_devid[6] + (my_devid[7] << 8) + (my_devid[8] << 16);
+ prod = my_devid[9] + (my_devid[10] << 8);
+ switch(vend) {
+ case VENDOR_INTEL:
+ if ((prod != 0x800) && (prod != 0x808) && (prod != 0x841))
+ fdev = 0;
+ break;
+ case VENDOR_NSC: fdev = 0; break;
+ case VENDOR_NEC: fdev = 0; break;
+ case VENDOR_DELL: fdev = 0; break;
+ case VENDOR_HP: fdev = 0; break;
+ case VENDOR_SUN: fdev = 0; break;
+ default: break;
+ }
+ return(fdev);
+}
+
+/* get_lan_channel returns the next lan channel starting with chfirst. */
+int get_lan_channel(uchar chfirst, uchar *chan)
+{
+ int ret, j;
+ uchar iData[4];
+ uchar rData[9];
+ int rlen;
+ uchar cc;
+ int found = 0;
+
+ for (j = chfirst; j < 12; j++)
+ {
+ rlen = sizeof(rData);
+ iData[0] = (uchar)j; /*channel #*/
+ memset(rData,0,9); /*initialize recv data*/
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug);
+ if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */
+ continue;
+ if (ret != 0) {
+ if (fdebug) printf("get_chan_info rc = %x\n",ret);
+ break;
+ }
+ /* rData[1] == channel medium type */
+ if (rData[1] == 4) { /* medium type 4 = 802.3 LAN type*/
+ if (fdebug) printf("chan[%d] = lan\n",j);
+ found = 1;
+ *chan = (uchar)j;
+ break;
+ }
+ }
+ if (found == 0) ret = -1;
+ return(ret);
+}
+
+int nodeislocal(char *nodename)
+{
+ if (nodename == NULL) return 1;
+ if (nodename[0] == 0) return 1;
+ if (strcmp(nodename,"localhost") == 0) return 1;
+ return 0;
+}
+
+int set_max_kcs_loops(int ms)
+{
+ int rv = 0;
+#if defined(LINUX)
+ rv = ipmi_set_max_kcs_loops(ms);
+#elif defined(BSD)
+ rv = ipmi_set_max_kcs_loops(ms);
+#elif defined(DOS)
+ rv = ipmi_set_max_kcs_loops(ms);
+#endif
+ return(rv);
+}
+
+/*
+ * ipmi_open
+ * This is called by ipmi_cmd and ipmicmd_raw if a session has not
+ * yet been opened (fDriverTyp == DRV_UNKNOWN).
+ * The order to try these drivers could be customized for specific
+ * environments by modifying this routine.
+ *
+ * ipmi_cmd[raw] would call a specific open routine if set_driver_type().
+ */
+int ipmi_open(char fdebugcmd)
+{
+ int rc = 0;
+ fperr = stderr;
+ fpdbg = stdout;
+
+ fdebug = fdebugcmd;
+#ifdef EFI
+ rc = ipmi_open_efi(fdebugcmd);
+#else
+ if (!nodeislocal(gnode)) { fipmi_lan = 1; }
+ if (fdebugcmd) printf("ipmi_open: driver type = %s\n",
+ show_driver_type(fDriverTyp));
+ /* first time, so try each */
+ if (fipmi_lan) {
+ /* Try IPMI LAN 1.5 first */
+ rc = ipmi_open_lan(gnode,guser,gpswd,fdebugcmd);
+ fDriverTyp = DRV_LAN;
+ if (rc == LAN_ERR_V2) {
+ /* Use IPMI LAN 2.0 if BMC said it only supports LAN2 */
+ /* This is a violation of IPMI 2.0 Spec section 13.4,
+ * but some HP firmware behaves this way, so handle it. */
+ rc = ipmi_open_lan2(gnode,guser,gpswd,fdebugcmd);
+ fDriverTyp = DRV_LAN2;
+ }
+ } else { /* local, not lan */
+#ifdef WIN32
+ rc = ipmi_open_ia(fdebugcmd);
+ if (rc == ACCESS_OK)
+ fDriverTyp = DRV_IMB;
+ else if ((rc = ipmi_open_ms(fdebugcmd)) == ACCESS_OK)
+ fDriverTyp = DRV_MS;
+ else rc = ERR_NO_DRV;
+#elif defined(SOLARIS)
+ rc = ipmi_open_bmc(fdebugcmd);
+ if (rc == ACCESS_OK)
+ fDriverTyp = DRV_BMC;
+ else if ((rc = ipmi_open_lipmi(fdebugcmd)) == ACCESS_OK)
+ fDriverTyp = DRV_LIPMI;
+ else rc = ERR_NO_DRV;
+#elif defined(LINUX)
+ if ((rc = ipmi_open_ld(fdebugcmd)) == ACCESS_OK) {
+ fDriverTyp = DRV_LD;
+ ipmi_close_ld();
+ } else if ((rc = ipmi_open_mv(fdebugcmd)) == ACCESS_OK) {
+ fDriverTyp = DRV_MV;
+ /* ipmi_close_mv(); * leave it open until explicit close */
+ } else if ((rc = ipmi_open_ia(fdebugcmd)) == ACCESS_OK) {
+ fDriverTyp = DRV_IMB;
+ } else if ((rc = ipmi_open_direct(fdebugcmd)) == ACCESS_OK) {
+ /* set to either DRV_KCS or DRV_SMB */
+ } else rc = ERR_NO_DRV;
+#elif defined(DOS)
+ rc = ipmi_open_direct(fdebugcmd);
+ /* sets fDriverTyp to either DRV_KCS or DRV_SMB */
+ if (rc != ACCESS_OK) rc = ERR_NO_DRV;
+#else
+ /* BSD or MACOS */
+ if ((rc = ipmi_open_mv(fdebugcmd)) == ACCESS_OK) {
+ /* FreeBSD "kldload ipmi" has /dev/ipmi0 */
+ fDriverTyp = DRV_MV;
+ /* ipmi_close_mv(); * leave it open until explicit close */
+ } else if ((rc = ipmi_open_direct(fdebugcmd)) == ACCESS_OK) {
+ /* sets fDriverTyp to either DRV_KCS or DRV_SMB */
+ } else rc = ERR_NO_DRV;
+#endif
+
+ } /*endelse local, not lan*/
+#endif
+ if (fdebugcmd) printf("ipmi_open rc = %d type = %s\n",rc,
+ show_driver_type(fDriverTyp));
+ return (rc);
+}
+
+int ipmi_close_(void)
+{
+ int rc = 0;
+#ifndef EFI
+ switch (fDriverTyp)
+ {
+#ifdef WIN32
+ case DRV_IMB: rc = ipmi_close_ia(); break;
+ case DRV_MS: rc = ipmi_close_ms(); break;
+#elif defined(SOLARIS)
+ case DRV_BMC: rc = ipmi_close_bmc(); break;
+ case DRV_LIPMI: rc = ipmi_close_lipmi(); break;
+#elif defined(LINUX)
+ case DRV_IMB: rc = ipmi_close_ia(); break;
+ case DRV_MV: rc = ipmi_close_mv(); break;
+ case DRV_LD: rc = ipmi_close_ld(); break;
+ case DRV_SMB:
+ case DRV_KCS: rc = ipmi_close_direct(); break;
+#elif defined(DOS)
+ case DRV_SMB:
+ case DRV_KCS: rc = ipmi_close_direct(); break;
+#else
+ /* BSD or MACOS */
+ case DRV_MV: rc = ipmi_close_mv(); break;
+ case DRV_SMB:
+ case DRV_KCS: rc = ipmi_close_direct(); break;
+#endif
+ case DRV_LAN: rc = ipmi_close_lan(gnode); break;
+ case DRV_LAN2I:
+ case DRV_LAN2: rc = ipmi_close_lan2(gnode); break;
+ default: break;
+ } /*end switch*/
+#endif
+ fDriverTyp = DRV_UNKNOWN;
+ return (rc);
+}
+
+/* don't worry about conflict with other ipmi libs any longer */
+int ipmi_close(void) { return(ipmi_close_()); }
+
+#if defined(EFI)
+int ipmi_open_efi(int fdebugcmd)
+{
+ int rc = 0;
+ static bool BmcLibInitialized = false;
+
+ if (BmcLibInitialized == false ) {
+ rc = BmcLibInitialize();
+ if (rc == 0) {
+ BmcLibInitialized = true;
+ fDriverTyp = DRV_EFI;
+ }
+ }
+ return rc;
+}
+
+#define TIMEOUT_EFI (1000*1000) /*see ipmi_timeout_ia*/
+int ipmi_cmdraw_efi(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ BMC_MESSAGE ReqMsg;
+ BMC_MESSAGE RespMsg;
+ int status = 0;
+ uchar * pc;
+ int sz, i;
+
+ ReqMsg.DevAdd = sa;
+ ReqMsg.NetFn = netfn;
+ ReqMsg.LUN = lun;
+ ReqMsg.Cmd = cmd;
+ ReqMsg.Len = sdata;
+ for( sz=0; (sz<sdata && sz< IPMI_REQBUF_SIZE); sz++ )
+ ReqMsg.Data[sz] = pdata[sz];
+ sz = *sresp; /* note that sresp must be pre-set */
+ memset(presp, 0, sz);
+ for ( i =0 ; i < BMC_MAX_RETRIES; i++)
+ {
+ *sresp = sz; /* retries may need to re-init *sresp */
+ if((status =ProcessTimedMessage(&ReqMsg, &RespMsg,TIMEOUT_EFI)) == 0) {
+ *sresp = RespMsg.Len;
+ for( sz=0 ; sz<RespMsg.Len && sz<IPMI_RSPBUF_SIZE ; sz++ )
+ presp[sz] = RespMsg.Data[sz];
+ *pcc = RespMsg.CompCode;
+ break;
+ }
+ if (fdebugcmd) // only gets here if error
+ fprintf(fpdbg,"ipmi_cmd_efi: ProcessTimedMessage error status=%x\n",
+ (uint)status);
+ }
+ return(status);
+}
+#endif
+
+/*
+ * ipmi_cmdraw()
+ *
+ * This routine can be used to invoke IPMI commands that are not
+ * already pre-defined in the ipmi_cmds array.
+ * It invokes whichever driver-specific routine is needed (ia, mv, etc.).
+ * Parameters:
+ * uchar cmd (input): IPMI Command
+ * uchar netfn (input): IPMI NetFunction
+ * uchar sa (input): IPMI Slave Address of the MC
+ * uchar bus (input): BUS of the MC
+ * uchar lun (input): IPMI LUN
+ * uchar *pdata (input): pointer to ipmi data
+ * int sdata (input): size of ipmi data
+ * uchar *presp (output): pointer to response data buffer
+ * int *sresp (input/output): on input, size of response buffer,
+ * on output, length of response data
+ * uchar *cc (output): completion code
+ * char fdebugcmd(input): flag =1 if debug output desired
+ */
+int ipmi_cmdraw(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc = 0;
+ ushort icmd;
+
+ fperr = stderr;
+ fpdbg = stdout;
+
+ if (sdata > 255) return(LAN_ERR_BADLENGTH);
+ if (fDriverTyp == DRV_UNKNOWN) { /*first time, so find which one */
+ rc = ipmi_open(fdebugcmd);
+ if (fdebugcmd)
+ fprintf(fpdbg,"Driver type %s, open rc = %d\n",
+ show_driver_type(fDriverTyp),rc);
+ if (rc == ERR_NO_DRV && !fipmi_lan) fprintf(fperr, "%s", msg_no_drv);
+ else if (rc != 0) fprintf(fperr,"ipmi_open error = %d\n", rc);
+ if (rc != 0) return(rc);
+ } /*endif first time*/
+
+ icmd = (cmd & 0x00ff) | (netfn << 8);
+ *pcc = 0;
+ /* Check for the size of the response buffer being zero. */
+ /* This may be valid for some commands, but print a debug warning. */
+ if (fdebugcmd && (*sresp == 0)) printf("ipmi_cmdraw: warning, sresp==0\n");
+
+#ifdef EFI
+ rc = ipmi_cmdraw_efi(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+#else
+ switch (fDriverTyp)
+ {
+#ifdef WIN32
+ case DRV_IMB:
+ rc = ipmi_cmdraw_ia(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_MS:
+ rc = ipmi_cmdraw_ms(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+#elif defined(SOLARIS)
+ case DRV_BMC:
+ rc = ipmi_cmdraw_bmc(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_LIPMI:
+ rc = ipmi_cmdraw_lipmi(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+#elif defined(LINUX)
+ case DRV_IMB:
+ rc = ipmi_cmdraw_ia(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_MV:
+ rc = ipmi_cmdraw_mv(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_LD:
+ rc = ipmi_cmdraw_ld( cmd, netfn, lun, sa, bus,
+ pdata,sdata, presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_SMB:
+ case DRV_KCS:
+ rc = ipmi_cmdraw_direct(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+#elif defined(DOS)
+ case DRV_SMB:
+ case DRV_KCS:
+ rc = ipmi_cmdraw_direct(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+#else
+ /* BSD or MACOS */
+ case DRV_MV:
+ rc = ipmi_cmdraw_mv(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_SMB:
+ case DRV_KCS:
+ rc = ipmi_cmdraw_direct(cmd, netfn, lun, sa, bus, pdata,sdata,
+ presp,sresp, pcc, fdebugcmd);
+ break;
+#endif
+ case DRV_LAN:
+ rc = ipmi_cmdraw_lan(gnode, cmd, netfn, lun, sa, bus,
+ pdata,sdata, presp,sresp, pcc, fdebugcmd);
+ break;
+ case DRV_LAN2I:
+ case DRV_LAN2:
+ rc = ipmi_cmdraw_lan2(gnode, cmd, netfn, lun, sa, bus,
+ pdata,sdata, presp,sresp, pcc, fdebugcmd);
+ break;
+ default: /* no ipmi driver */
+ rc = ERR_NO_DRV;
+ break;
+ } /*end switch*/
+#endif
+
+ if ((rc >= 0) && (*pcc != 0) && fdebugcmd) {
+ fprintf(fpdbg,"ccode %x: %s\n",*pcc,decode_cc(icmd,(int)*pcc));
+ }
+ /* clear the temp cmd (OLD) */
+ // ipmi_cmds[0].cmdtyp = 0;
+ // ipmi_cmds[0].sa = BMC_SA;
+
+ return(rc);
+}
+
+/*
+ * ipmi_cmd_mc()
+ * This uses the mc pointer to route commands via either the SMI or
+ * IPMB method to the designated mc.
+ * See also ipmi_set_mc and ipmi_restore_mc.
+ */
+int ipmi_cmd_mc(ushort icmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ uchar cmd, netfn;
+ int rv;
+
+ cmd = icmd & CMDMASK;
+ netfn = (icmd & 0xFF00) >> 8;
+ if (sdata > 255) return(LAN_ERR_BADLENGTH);
+ if ((fDriverTyp != DRV_MV) && (mc->adrtype == ADDR_IPMB) && !fipmi_lan) {
+ rv = ipmi_cmd_ipmb(cmd, netfn, mc->sa, mc->bus, mc->lun,
+ pdata, sdata, presp, sresp, pcc, fdebugcmd);
+ } else { /* use ADDR_SMI */
+ rv = ipmi_cmdraw(cmd, netfn, mc->sa, mc->bus, mc->lun,
+ pdata, sdata, presp, sresp, pcc, fdebugcmd);
+ }
+ return(rv);
+}
+
+int ipmi_cmdraw_mc(uchar cmd, uchar netfn,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rv;
+ if (sdata > 255) return(LAN_ERR_BADLENGTH);
+ if ((fDriverTyp != DRV_MV) && (mc->adrtype == ADDR_IPMB) && !fipmi_lan) {
+ rv = ipmi_cmd_ipmb(cmd, netfn, mc->sa, mc->bus, mc->lun,
+ pdata, sdata, presp, sresp, pcc, fdebugcmd);
+ } else { /* use ADDR_SMI */
+ rv = ipmi_cmdraw(cmd, netfn, mc->sa, mc->bus, mc->lun,
+ pdata, sdata, presp, sresp, pcc, fdebugcmd);
+ }
+ return(rv);
+}
+
+/*
+ * ipmi_cmd()
+ *
+ * This is the externally exposed subroutine for commands that
+ * are defined in the ipmi_cmds array above.
+ * It calls the ipmi_cmdraw routine for further processing.
+ */
+int ipmi_cmd(ushort icmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+ uchar bcmd;
+ uchar netfn, sa, bus, lun;
+
+ fperr = stderr;
+ fpdbg = stdout;
+ if (sdata > 255) return(LAN_ERR_BADLENGTH);
+ if (fDriverTyp == DRV_UNKNOWN) { /*first time, so find which one */
+ rc = ipmi_open(fdebugcmd);
+ if (fdebugcmd)
+ fprintf(fpdbg,"Driver type %s, open rc = %d\n",
+ show_driver_type(fDriverTyp),rc);
+ if (rc != 0) {
+ if (rc == ERR_NO_DRV && !fipmi_lan) fprintf(fperr, "%s", msg_no_drv);
+ else fprintf(fperr,"ipmi_open error = %d\n", rc);
+ return(rc);
+ }
+ } /*endif first time*/
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == icmd) break;
+ }
+ if (i >= NCMDS) {
+ fprintf(fperr, "ipmi_cmd: Unknown command %x\n",icmd);
+ return(-1);
+ }
+ bcmd = icmd & CMDMASK; /* unmask it */
+ netfn = ipmi_cmds[i].netfn;
+ lun = ipmi_cmds[i].lun;
+ sa = ipmi_cmds[i].sa;
+ bus = ipmi_cmds[i].bus;
+
+ rc = ipmi_cmdraw(bcmd, netfn, sa, bus, lun,
+ pdata,sdata, presp,sresp, pcc, fdebugcmd);
+ return(rc);
+}
+
+/* MOVED ipmi_cmd_ipmb() to ipmilan.c */
+
+int ipmi_getpicmg(uchar *presp, int sresp, char fdebug)
+{
+ uchar idata[2];
+ int rc; uchar cc;
+
+ /* check that sresp is big enough */
+ if (sresp < 4) return(-3);
+ idata[0] = PICMG_ID;
+ rc = ipmi_cmdraw(PICMG_GET_PROPERTIES, NETFN_PICMG,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, 1, presp,&sresp, &cc, fdebug);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ return(ACCESS_OK); /* success */
+}
+
+int ipmi_getdeviceid(uchar *presp, int sresp, char fdebug)
+{
+ int rc, i; uchar cc;
+ /* check that sresp is big enough (default is 15 bytes for Langley)*/
+ if (sresp < 15) return(ERR_BAD_LENGTH);
+ rc = ipmi_cmd_mc(GET_DEVICE_ID, NULL, 0, presp,&sresp, &cc, fdebug);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ i = sresp;
+ if (i > sizeof(my_devid)) i = sizeof(my_devid);
+ memcpy(my_devid,presp,i); /* save device id for later use */
+ return(ACCESS_OK); /* success */
+}
+
+void get_devid_ver(uchar *bmaj, uchar *bmin, uchar *iver)
+{
+ if (bmaj != NULL) *bmaj = my_devid[2];
+ if (bmin != NULL) *bmin = my_devid[3];
+ if (iver != NULL) *iver = my_devid[4];
+}
+
+void show_devid(uchar b1, uchar b2, uchar i1, uchar i2)
+{
+ /* b1 = devid[2]; b2 = devid[3]; i2|i1 = devid[4]; */
+ printf("-- BMC version %x.%02x%c IPMI version %d.%d \n",b1,b2,bcomma,i1,i2);
+}
+
+void ipmi_set_mc(uchar bus, uchar sa, uchar lun, uchar atype)
+{
+ mc = &mc2;
+ mc->bus = bus;
+ mc->sa = sa;
+ mc->lun = lun;
+ mc->adrtype = atype; /* ADDR_SMI or ADDR_IPMB */
+ if (fdebug) printf("ipmi_set_mc(%02x,%02x,%02x,%02x)\n",bus,sa,lun,atype);
+ return;
+}
+
+void ipmi_restore_mc(void)
+{
+ mc = &bmc;
+ return;
+}
+
+void ipmi_get_mc(uchar *bus, uchar *sa, uchar *lun, uchar *type)
+{
+ /* mc = &bmc or &mc2; */
+ if (bus != NULL) *bus = mc->bus;
+ if (sa != NULL) *sa = mc->sa;
+ if (lun != NULL) *lun = mc->lun;
+ if (type != NULL) *type = mc->adrtype; /* ADDR_SMI or ADDR_IPMB */
+ return;
+}
+
+void ipmi_set_mymc(uchar bus, uchar sa, uchar lun, uchar type)
+{
+ mymc.bus = bus;
+ mymc.sa = sa;
+ mymc.lun = lun;
+ mymc.adrtype = type; /* ADDR_SMI or ADDR_IPMB */
+ return;
+}
+
+void ipmi_get_mymc(uchar *bus, uchar *sa, uchar *lun, uchar *type)
+{
+ if (bus != NULL) *bus = mymc.bus;
+ if (sa != NULL) *sa = mymc.sa;
+ if (lun != NULL) *lun = mymc.lun;
+ if (type != NULL) *type = mymc.adrtype; /* ADDR_SMI or ADDR_IPMB */
+ return;
+}
+
+int ipmi_sendrecv(struct ipmi_rq * req, uchar *rsp, int *rsp_len)
+{ /* compatible with intf->sendrecv() */
+ int rv;
+ uchar ccode;
+ int rlen;
+
+ rlen = IPMI_RSPBUF_SIZE;
+ *rsp_len = 0;
+ rv = ipmi_cmdraw_mc(req->msg.cmd, req->msg.netfn,
+ req->msg.data, (uchar)req->msg.data_len,
+ rsp, &rlen, &ccode, fdebug);
+ if (rv == 0 && ccode != 0) rv = ccode;
+ if (rv == 0) { /*success*/
+ *rsp_len = rlen;
+ }
+ return (rv);
+}
+
+#ifdef WIN32
+static HANDLE con_in = INVALID_HANDLE_VALUE;
+static DWORD cmodein;
+static DWORD cmodeold;
+
+void tty_setraw(int mode)
+{
+ // system("@echo off");
+ con_in = GetStdHandle(STD_INPUT_HANDLE);
+ GetConsoleMode(con_in, &cmodein);
+ cmodeold = cmodein;
+ if (mode == 2) {
+ cmodein &= ~(ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT |
+ ENABLE_ECHO_INPUT);
+ } else { /* (mode==1) just suppress ECHO */
+ cmodein &= ~ENABLE_ECHO_INPUT;
+ }
+ SetConsoleMode(con_in, cmodein);
+}
+void tty_setnormal(int mode)
+{
+ // system("echo on");
+ if (mode == 1)
+ cmodein |= ENABLE_ECHO_INPUT;
+ else
+ cmodein = cmodeold;
+ SetConsoleMode(con_in, cmodein);
+}
+int tty_getattr(int *lflag, int *oflag, int *iflag)
+{
+ *lflag = (int)cmodein;
+ *oflag = 0;
+ *iflag = 0;
+ return(0);
+}
+#elif defined(DOS)
+void tty_setraw(int mode)
+{ return; }
+void tty_setnormal(int mode)
+{ return; }
+int tty_getattr(int *lflag, int *oflag, int *iflag)
+{ return(-1); }
+#else
+ /*LINUX, SOLARIS, BSD*/
+// #include <curses.h>
+static struct termios mytty;
+static struct termios ttyold;
+static ulong tty_oldflags;
+int tty_getattr(int *lflag, int *oflag, int *iflag)
+{
+ int rv;
+ static struct termios outtty;
+ rv = tcgetattr(STDOUT_FILENO, &outtty);
+ if (rv == 0) {
+ *lflag = outtty.c_lflag;
+ *oflag = outtty.c_oflag;
+ *iflag = outtty.c_iflag;
+ }
+ return(rv);
+}
+
+void tty_setraw(int mode)
+{
+ int i;
+ // system("stty -echo");
+ i = tcgetattr(STDIN_FILENO, &mytty);
+ if (i == 0) {
+ tty_oldflags = mytty.c_lflag;
+ ttyold = mytty;
+#ifdef SOLARIS
+ mytty.c_iflag |= IGNPAR;
+ mytty.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
+ mytty.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL);
+ mytty.c_lflag &= ~IEXTEN;
+ /* mytty.c_oflag &= ~OPOST; // this causes NL but no CR on output */
+ mytty.c_cc[VMIN] = 1;
+ mytty.c_cc[VTIME] = 0;
+ i = tcsetattr(STDIN_FILENO, TCSADRAIN, &mytty);
+#else
+ if (mode == 2) { /*raw mode*/
+ mytty.c_lflag &= ~(ICANON | ISIG | ECHO);
+ // mytty.c_oflag &= ~ONLCR; /* do not map NL to CR-NL on output */
+ } else /* (mode==1) just suppress ECHO */
+ mytty.c_lflag &= ~ECHO;
+ i = tcsetattr(STDIN_FILENO, TCSANOW, &mytty);
+#endif
+ }
+}
+void tty_setnormal(int mode)
+{
+ // system("stty echo");
+ if (mode == 1)
+ mytty.c_lflag |= ECHO;
+ else { /*(mode==2)*/
+ mytty.c_lflag = tty_oldflags;
+ mytty = ttyold;
+ }
+ tcsetattr(STDIN_FILENO, TCSANOW, &mytty);
+#ifdef SOLARIS
+ tcsetattr(fileno(stdin), TCSADRAIN, &mytty);
+#endif
+}
+#endif
+
+static char *my_getline(char *prompt, char fwipe)
+{
+ /* getline is the same format as readline, but much simpler, and portable. */
+ static char linebuf[128];
+ int c, i;
+
+ if (prompt != NULL) printf("%s\n",prompt);
+ if (fwipe) tty_setraw(1);
+ for (i = 0; i < (sizeof(linebuf)-1); i++)
+ {
+ c = getc(stdin);
+ if (c == EOF) break;
+ if (c == '\n') break;
+ if ((c < 0x20) || (c > 0x7F)) break; /*out of bounds for ASCII */
+ linebuf[i] = c & 0xff;
+ }
+ linebuf[i] = 0;
+ if (fwipe) {
+ for (c = 0; c < i; c++) putc('*',stdout);
+ putc('\n',stdout);
+ tty_setnormal(1);
+ }
+ if (i == 0) return NULL;
+ return(linebuf);
+}
+
+static char *getline_wipe(char *prompt)
+{
+ return(my_getline(prompt,1));
+}
+
+void set_debug(void)
+{
+ fdebug = 1;
+}
+
+char is_remote(void)
+{
+ return((char)fipmi_lan);
+}
+
+int get_lan_options(char *node, char *user, char *pswd, int *auth, int *priv,
+ int *cipher, void *addr, int *addr_len)
+{
+ if (fipmi_lan == 0) return(-1);
+ if (node != NULL) strcpy(node,gnode);
+ if (user != NULL) strcpy(user,guser);
+ if (pswd != NULL) strcpy(pswd,gpswd);
+ if (auth != NULL) *auth = gauth_type;
+ if (priv != NULL) *priv = gpriv_level;
+ if (cipher != NULL) *cipher = gcipher_suite;
+ if (addr != NULL && gaddr_len != 0) memcpy(addr,gaddr,gaddr_len);
+ if (addr_len != NULL) *addr_len = gaddr_len;
+ return(0);
+}
+
+int set_lan_options(char *node, char *user, char *pswd, int auth, int priv,
+ int cipher, void *addr, int addr_len)
+{
+ int rv = 0;
+ if (node != NULL) { gnode = strdup_(node); fipmi_lan = 1; }
+ if (user != NULL) guser = strdup_(user);
+ if (pswd != NULL) gpswd = strdup_(pswd);
+ if (auth > 0 && auth <= 5) gauth_type = auth;
+ else rv = ERR_BAD_PARAM;
+ if (priv > 0 && priv <= 5) gpriv_level = priv;
+ else rv = ERR_BAD_PARAM;
+ if (cipher >= 0 && cipher <= 17) gcipher_suite = cipher;
+ else rv = ERR_BAD_PARAM;
+ if ((addr != NULL) && (addr_len > 15) && (addr_len <= sizeof(gaddr))) {
+ memcpy(gaddr,addr,addr_len);
+ gaddr_len = addr_len;
+ }
+ ipmi_flush_lan(gnode);
+ return(rv);
+}
+
+void parse_lan_options(int c, char *popt, char fdebugcmd)
+{
+#if defined(EFI) | defined(DOS)
+ return;
+#else
+ int i;
+ size_t len;
+ static int fset_dtype = 0;
+ uchar sa;
+
+ switch(c)
+ {
+ case 'F': /* force driver type */
+ i = set_driver_type(popt);
+ if (i == 0) fset_dtype = 1;
+ break;
+ case 'T': /* auth type */
+ i = atoi(popt);
+ if (i >= 0 && i <= 5) gauth_type = i;
+ fauth_type_set = 1;
+ break;
+ case 'V': /* priv level */
+ i = atoi(popt);
+ if (i > 0 && i <= 5) gpriv_level = i;
+ break;
+ case 'J':
+ i = atoi(popt);
+ if (i >= 0 && i <= 17) gcipher_suite = i;
+ else printf("-J cipher suite %d > 17, defaults to %d\n",
+ i,gcipher_suite);
+ if (fset_dtype == 0) i = set_driver_type("lan2");
+ break;
+ case 'N': gnode = popt; /* nodename */
+ fipmi_lan = 1;
+ break;
+ case 'U':
+ guser = strdup_(popt); /*remote username */
+ if (!guser) perror("strdup_");
+ else { /* Hide username from 'ps' */
+ memset(popt, ' ', strlen(popt));
+ }
+ break;
+ case 'R':
+ case 'P':
+ gpswd = strdup_(popt); /*remote password */
+ if (!gpswd) perror("strdup_");
+ else { /* Hide password from 'ps' */
+ len = strlen(popt);
+ memset(popt, ' ', len);
+ if (len > PSW_MAX) gpswd[PSW_MAX] = '\0';
+ }
+ break;
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ gpswd = getenv("IPMI_PASSWORD");
+ if (gpswd == NULL) perror("getenv(IPMI_PASSWORD)");
+ else {
+ if (strlen(gpswd) > PSW_MAX) gpswd[PSW_MAX] = '\0';
+ if (fdebugcmd) printf("using IPMI_PASSWORD\n");
+ }
+ break;
+ case 'Y': /* prompt for remote password */
+ gpswd = getline_wipe("Enter IPMI LAN Password: ");
+ if (gpswd != NULL) {
+ if (strlen(gpswd) > PSW_MAX) gpswd[PSW_MAX] = '\0';
+ }
+ break;
+ case 'Z': /* set local MC address */
+ sa = htoi(&popt[0]); /*device slave address*/
+ ipmi_set_mymc(mc->bus, sa, mc->lun, ADDR_IPMB);
+ break;
+ default:
+ if (fdebugcmd) printf("unrecognized option %c\n",c);
+ break;
+ }
+ ipmi_flush_lan(gnode);
+#endif
+} /*end parse_lan_options*/
+
+void print_lan_opt_usage(void)
+{
+#if defined(EFI) | defined(DOS)
+ return;
+#else
+ printf(" -N node Nodename or IP address of target system\n");
+ printf(" -U user Username for remote node\n");
+ printf(" -P/-R pswd Remote Password\n");
+ printf(" -E use password from Environment IPMI_PASSWORD\n");
+ printf(" -F force driver type (e.g. imb, lan2)\n");
+ printf(" -J 0 use lanplus cipher suite 0: 0 thru 14, 3=default\n");
+ printf(" -T 1 use auth Type: 1=MD2, 2=MD5(default), 4=Pswd\n");
+ printf(" -V 2 use priVilege level: 2=user(default), 4=admin\n");
+ printf(" -Y prompt for remote password\n");
+ printf(" -Z set slave address of local MC\n");
+#endif
+} /*end parse_lan_options*/
+
+char *get_nodename(void)
+{
+ return(gnode);
+}
+
+extern int lasterr; /*defined in ipmilan.c */
+extern void show_LastError(char *tag, int err);
+
+void show_outcome(char *prog, int ret)
+{
+ if (prog == NULL) prog = "";
+ if (ret == -1 && lasterr != 0) show_LastError(prog,lasterr);
+ printf("%s%c %s\n",prog,bcomma,decode_rv(ret));
+}
+
+/* end ipmicmd.c */
diff --git a/util/ipmicmd.h b/util/ipmicmd.h
new file mode 100644
index 0000000..b65e949
--- /dev/null
+++ b/util/ipmicmd.h
@@ -0,0 +1,543 @@
+/*M*
+// PVCS:
+// $Workfile: ipmicmd.h $
+// $Revision: 1.0 $
+// $Modtime: 22 Jul 2002 08:51:14 $
+// $Author: arcress $
+//
+// 10/24/02 arcress - made cmd param ushort to be more unique
+//
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2002, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of the copyright holder nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#define uchar unsigned char
+#define uint32 unsigned int
+#define uint64 unsigned long
+// #ifdef __USE_MISC
+/* Can use compatibility names for C types. (from sys/types.h) */
+// typedef unsigned long int ulong;
+// typedef unsigned short int ushort;
+// typedef unsigned int uint;
+// #else
+#ifndef ushort
+#define ushort unsigned short
+#define ulong unsigned long
+#define uint unsigned int
+#endif
+
+#ifdef WIN32
+#define snprintf _snprintf
+#define SockType SOCKET
+#define SockInvalid INVALID_SOCKET
+#else
+#define SockType int
+#define SockInvalid -1
+#endif
+
+// Other IPMI values
+#define PUBLIC_BUS 0
+#define PRIVATE_BUS 0x03
+#define BMC_SA 0x20
+#define BMC_LUN 0
+#define SMS_LUN 2
+#define HSC_SA 0xC0
+#define ME_SA 0x2C
+#define ME_BUS 0x06
+
+#define ADDR_SMI 1
+#define ADDR_IPMB 2
+
+#define ACCESS_OK 0
+#define IPMI_REQBUF_SIZE 255
+#define IPMI_RSPBUF_SIZE 250 // was 80, then 1024, see MAX_BUFFER_SIZE
+#define IPMI_LANBUF_SIZE 200 // see RS_LEN_MAX for IPMI LAN
+
+// IPMI NetFn types, see Table 5-1
+#define NETFN_CHAS 0x00 // chassis
+#define NETFN_BRIDGE 0x02 // bridge
+#define NETFN_SEVT 0x04 // sensor/event
+#define NETFN_APP 0x06 // application
+#define NETFN_FW 0x08 // firmware
+#define NETFN_STOR 0x0a // storage
+#define NETFN_TRANS 0x0c // transport
+#define NETFN_SOL 0x34 // serial-over-lan (in IPMI 2.0, use TRANS)
+#define NETFN_PICMG 0x2c // for ATCA PICMG systems
+
+#ifndef IMBAPI_H__
+// special IMB defines, duplicates if imb_api.h
+#define MAX_BUFFER_SIZE 255
+#define MAX_SDR_SIZE 128
+#define GET_DEVICE_ID (0x01 | (NETFN_APP << 8))
+#define WRITE_READ_I2C (0x52 | (NETFN_APP << 8)) /*=MASTER_WRITE_READ*/
+#endif
+
+#define PSW_MAX 20 /* IPMI Passwords max = 16 or 20 bytes*/
+/* IPMI Commands, see Table 38-8, combined CMD and NETFN in unsigned short */
+#define CMDMASK 0xff /* mask to leave only the command part */
+#define WATCHDOG_RESET (0x22 | (NETFN_APP << 8))
+#define WATCHDOG_SET (0x24 | (NETFN_APP << 8))
+#define WATCHDOG_GET (0x25 | (NETFN_APP << 8))
+#define GET_SYSTEM_GUID (0x37 | (NETFN_APP << 8))
+#define SET_CHANNEL_ACC (0x40 | (NETFN_APP << 8))
+#define GET_CHANNEL_ACC (0x41 | (NETFN_APP << 8))
+#define GET_CHANNEL_INFO (0x42 | (NETFN_APP << 8))
+#define SET_USER_ACCESS (0x43 | (NETFN_APP << 8))
+#define GET_USER_ACCESS (0x44 | (NETFN_APP << 8))
+#define SET_USER_NAME (0x45 | (NETFN_APP << 8))
+#define GET_USER_NAME (0x46 | (NETFN_APP << 8))
+#define SET_USER_PASSWORD (0x47 | (NETFN_APP << 8))
+#define MASTER_WRITE_READ (0x52 | (NETFN_APP << 8))
+// #define SET_PEF_ENABLE 0xA1 /* NETFN_APP (old) */
+#define CHASSIS_STATUS 0x01 /* NETFN_CHAS (=00) */
+#define CHASSIS_CTL 0x02 /* NETFN_CHAS (=00) */
+#define CHASSIS_IDENTIFY 0x04 /* NETFN_CHAS (=00) */
+#define SET_BOOT_OPTIONS 0x08 /* NETFN_CHAS (=00) */
+#define GET_BOOT_OPTIONS 0x09 /* NETFN_CHAS (=00) */
+#define GET_POWERON_HOURS 0x0F /* NETFN_CHAS (=00) */
+#define GET_PEF_CONFIG (0x13 | (NETFN_SEVT << 8))
+#define SET_PEF_CONFIG (0x12 | (NETFN_SEVT << 8))
+#define GET_DEVSDR_INFO (0x20 | (NETFN_SEVT << 8))
+#define GET_DEVICE_SDR (0x21 | (NETFN_SEVT << 8))
+#define RESERVE_DEVSDR_REP (0x22 | (NETFN_SEVT << 8))
+#define SET_SEVT_ENABLE (0x28 | (NETFN_SEVT << 8))
+#define GET_SEVT_ENABLE (0x29 | (NETFN_SEVT << 8))
+#define REARM_SENSOR (0x2A | (NETFN_SEVT << 8))
+#define GET_FRU_INV_AREA (0x10 | (NETFN_STOR << 8))
+#define READ_FRU_DATA (0x11 | (NETFN_STOR << 8))
+#define WRITE_FRU_DATA (0x12 | (NETFN_STOR << 8))
+
+#define GET_SENSOR_READING_FACTORS (0x23 | (NETFN_SEVT << 8))
+#define SET_SENSOR_HYSTERESIS (0x24 | (NETFN_SEVT << 8))
+#define GET_SENSOR_HYSTERESIS (0x25 | (NETFN_SEVT << 8))
+#define SET_SENSOR_THRESHOLD (0x26 | (NETFN_SEVT << 8))
+#define GET_SENSOR_THRESHOLD (0x27 | (NETFN_SEVT << 8))
+#define GET_SENSOR_EVT_ENABLE (0x29 | (NETFN_SEVT << 8))
+#define REARM_SENSOR_EVENTS (0x2A | (NETFN_SEVT << 8))
+#define GET_SENSOR_EVT_STATUS (0x2B | (NETFN_SEVT << 8))
+#define GET_SENSOR_READING (0x2D | (NETFN_SEVT << 8))
+#define GET_SENSOR_TYPE (0x2F | (NETFN_SEVT << 8))
+
+#define SET_LAN_CONFIG (0x01 | (NETFN_TRANS << 8))
+#define GET_LAN_CONFIG (0x02 | (NETFN_TRANS << 8))
+#define GET_LAN_STATS (0x04 | (NETFN_TRANS << 8))
+#define SET_SER_CONFIG (0x10 | (NETFN_TRANS << 8))
+#define GET_SER_CONFIG (0x11 | (NETFN_TRANS << 8))
+#define SET_SER_MUX (0x12 | (NETFN_TRANS << 8))
+#define GET_SEL_INFO (0x40 | (NETFN_STOR << 8))
+#define GET_SEL_ALLOCATION_INFO (0x41 | (NETFN_STOR << 8))
+#define RESERVE_SEL (0x42 | (NETFN_STOR << 8))
+#define GET_SEL_ENTRY (0x43 | (NETFN_STOR << 8))
+#define CLEAR_SEL (0x47 | (NETFN_STOR << 8))
+#define GET_SEL_TIME (0x48 | (NETFN_STOR << 8))
+#define GET_SDR_REPINFO (0x20 | (NETFN_STOR << 8))
+#define RESERVE_SDR_REP (0x22 | (NETFN_STOR << 8))
+#define GET_SDR (0x23 | (NETFN_STOR << 8))
+#define ACTIVATE_SOL1 (0x01 | (NETFN_SOL << 8))
+#define SET_SOL_CONFIG (0x03 | (NETFN_SOL << 8))
+#define GET_SOL_CONFIG (0x04 | (NETFN_SOL << 8))
+#define ACTIVATE_SOL2 (0x20 | (NETFN_TRANS << 8))
+#define SET_SOL_CONFIG2 (0x21 | (NETFN_TRANS << 8))
+#define GET_SOL_CONFIG2 (0x22 | (NETFN_TRANS << 8))
+#define READ_EVENT_MSGBUF (0x35 | (NETFN_APP << 8))
+#define GET_EVENT_RECEIVER (0x01 | (NETFN_SEVT << 8))
+#define SMS_OS_REQUEST 0x10 /*(0x10 | (NETFN_APP << 8)) */
+#define CMD_GET_SESSION_INFO 0x3D /* NETFN_APP */
+#define CMD_SET_SYSTEM_INFO 0x58 /* NETFN_APP */
+#define CMD_GET_SYSTEM_INFO 0x59 /* NETFN_APP */
+/*
+ Other commands used for IPMI LAN:
+ GET_CHAN_AUTH (0x38 | (NETFN_APP << 8))
+ GET_SESS_CHAL (0x39 | (NETFN_APP << 8))
+ ACT_SESSION (0x3A | (NETFN_APP << 8))
+ SET_SESS_PRIV (0x3B | (NETFN_APP << 8))
+ CLOSE_SESSION (0x3C | (NETFN_APP << 8))
+ */
+
+#define IPMB_CLEAR_MSGF 0x30
+#define IPMB_GET_MESSAGE 0x33
+#define IPMB_SEND_MESSAGE 0x34
+
+#define PICMG_SLAVE_BUS 0x40
+/* commands under NETFN_PICMG */
+#define PICMG_GET_PROPERTIES 0x00
+#define PICMG_GET_LED_PROPERTIES 0x05
+#define PICMG_SET_LED_STATE 0x07
+#define PICMG_GET_LED_STATE 0x08
+#define PICMG_ID 0x00
+
+/* structure used by ipmi_cmd(), not used by ipmi_cmdraw */
+#define NCMDS 62
+typedef struct {
+ ushort cmdtyp;
+ uchar sa;
+ uchar bus;
+ uchar netfn;
+ uchar lun;
+ uchar len; /*length of request data (FYI, but not used here) */
+ uchar rslen; /*length of response data expected (not including ccode) */
+} ipmi_cmd_t;
+
+struct valstr {
+ ushort val;
+ const char * str;
+};
+
+struct oemvalstr {
+ uint oem;
+ ushort val;
+ const char * str;
+};
+
+/* IPMI driver types returned by get_driver_type() */
+#define NDRIVERS 15
+#define DRV_UNKNOWN 0
+#define DRV_IMB 1
+#define DRV_VA 2
+#define DRV_MV 3
+#define DRV_GNU 4
+#define DRV_LD 5 /*LANDesk*/
+#define DRV_LAN 6 /*IPMI LAN 1.5*/
+#define DRV_KCS 7 /*direct KCS*/
+#define DRV_SMB 8 /*direct SMBus/SSIF*/
+#define DRV_LAN2 9 /*LANplus, IPMI LAN 2.0*/
+#define DRV_MS 10 /*Microsoft ipmidrv.sys*/
+#define DRV_BMC 11 /*Solaris 10 bmc */
+#define DRV_SMC 12 /*SuperMicro Computer LAN mode*/
+#define DRV_LIPMI 13 /*Solaris 8/9 lipmi */
+#define DRV_LAN2I 14 /*LANplus with Intel OEM */
+#define DRV_EFI 15 /*Intel EFI, ipmi.efi*/
+#define DRV_IBM 16 /*LAN with IBM OEM mode*/
+#define DRV_HP 17 /*LANplus with HP OEM mode*/
+
+/* Event severity codes, used in ievents.c and oem*.c */
+#define SEV_INFO 0
+#define SEV_MIN 1
+#define SEV_MAJ 2
+#define SEV_CRIT 3
+
+/* Errors returned by ipmiutil functions, lan, etc, see decode_rv() */
+#define ERR_BAD_LENGTH -24 /*length < MIN */
+#define ERR_BAD_FORMAT -23 /*bad format*/
+#define ERR_USAGE -22 /*usage/help requested*/
+#define ERR_NOT_FOUND -21 /*requested item not found*/
+#define ERR_FILE_OPEN -20 /*cannot open file*/
+#define LAN_ERR_DROPPED -19 /*Remote BMC dropped the connection*/
+#define ERR_NOT_ALLOWED -18 /*access not allowed*/
+#define ERR_BAD_PARAM -17 /*invalid parameter*/
+#define ERR_NO_DRV -16 /*cannot open IPMI driver*/
+#define LAN_ERR_V2 -15 /*BMC only supports IPMI 2.0*/
+#define LAN_ERR_V1 -14 /*BMC only supports IPMI 1.x*/
+#define LAN_ERR_OTHER -13
+#define LAN_ERR_PING -12 /*error with ping*/
+#define LAN_ERR_HOSTNAME -11 /*error resolving hostname*/
+#define LAN_ERR_TOO_SHORT -10 /*recv data too short */
+#define LAN_ERR_NOTSUPPORT -9 /*slave address != 0x20, not supported now */
+#define LAN_ERR_INVPARAM -8 /*null pointers, etc. */
+#define LAN_ERR_BADLENGTH -7 /*length > MAX */
+#define LAN_ERR_TIMEOUT -6 /*timeout signal(SIGALRM) recvd */
+#define LAN_ERR_ABORT -5 /*abort signal(SIGINT) recvd */
+#define LAN_ERR_CONNECT -4 /*problem connecting to BMC*/
+#define LAN_ERR_RECV_FAIL -3 /*receive failed, usually no response*/
+#define LAN_ERR_SEND_FAIL -2 /*send failed */
+#define ERR_BMC_MSG -504 /*error getting message from BMC*/
+ /* see ipmidir.h: ERGETTINGIPMIMESSAGE -504 */
+
+/* values used to request AUTHTYPE */
+#define IPMI_SESSION_AUTHTYPE_NONE 0x00
+#define IPMI_SESSION_AUTHTYPE_MD2 0x01
+#define IPMI_SESSION_AUTHTYPE_MD5 0x02
+#define IPMI_SESSION_AUTHTYPE_PASSWORD 0x04
+#define IPMI_SESSION_AUTHTYPE_OEM 0x05
+#define AUTHTYPE_INIT 0xFF /*initial value, not set*/
+/* mask values used for AUTHTYPE support */
+#define IPMI_MASK_AUTHTYPE_NONE 0x01
+#define IPMI_MASK_AUTHTYPE_MD2 0x02
+#define IPMI_MASK_AUTHTYPE_MD5 0x04
+#define IPMI_MASK_AUTHTYPE_PASSWORD 0x10
+#define IPMI_MASK_AUTHTYPE_OEM 0x20
+
+#define IPMI_PRIV_LEVEL_OEM 0x05
+#define IPMI_PRIV_LEVEL_ADMIN 0x04
+#define IPMI_PRIV_LEVEL_OPERATOR 0x03
+#define IPMI_PRIV_LEVEL_USER 0x02
+#define IPMI_PRIV_LEVEL_CALLBACK 0x01
+
+#define VENDOR_INTEL 0x000157 /*=343.*/
+#define VENDOR_KONTRON 0x003A98 /*=15000*/
+#define VENDOR_NSC 0x000322
+#define VENDOR_LMC 0x000878
+#define VENDOR_TYAN 0x0019FD
+#define VENDOR_NEC 0x000077
+#define VENDOR_SUPERMICRO 0x002A7C /*=10876.*/
+#define VENDOR_PEPPERCON 0x0028C5 /*used in SuperMicro AOC-SIMSO*/
+#define VENDOR_FUJITSU 0x002880 /*Fujitsu-Siemens*/
+#define VENDOR_MICROSOFT 0x000137 /* 311. */
+#define VENDOR_SUN 0x00002A
+#define VENDOR_DELL 0x0002A2
+#define VENDOR_HP 0x00000B
+#define VENDOR_IBM 0x000002
+#define VENDOR_SUPERMICROX 0x00B980 /*=47488. used for Winbond/SuperMicro */
+#define VENDOR_MAGNUM 5593 /* Magnum Technologies, also SuperMicro */
+#define VENDOR_QUANTA 7244
+#define VENDOR_XYRATEX 1993
+#define VENDOR_NEWISYS 9237
+#define VENDOR_CISCO 5771 /*=0x168B*/
+
+#define PRODUCT_QUANTA_S99Q 21401
+#define PRODUCT_QUANTA_QSSC_S4R 64 /*0x0040*/
+
+#define URNLOOPS 1000 /* default is 300 ms, Urbanna needs 1000 ms */
+#define LOG_MSG_LENGTH 1024 /*max len of log message*/
+#define SZGNODE 80 /* max len of a nodename */
+
+#define BDELIM '|' /*delimeter for canonical output*/
+#define BCOMMA ',' /*delimeter for CSV output*/
+#define BCOLON ':' /*delimeter some output with colons*/
+#define BCOMMENT '#' /*delimeter '#' used for comments */
+
+#ifndef LOG_WARN
+#define LOG_EMERG 0 // system is unusable
+#define LOG_ALERT 1 // action must be taken immediately
+#define LOG_CRIT 2 // critical conditions
+#define LOG_ERR 3 // error conditions
+#define LOG_WARN 4 // warning conditions
+#define LOG_NOTICE 5 // normal but significant condition
+#define LOG_INFO 6 // informational
+#define LOG_DEBUG 7 // debug-level messages
+#endif
+
+#ifndef _IPMI_RQ_
+#define _IPMI_RQ_ 1
+/* structure used in ipmi_sendrecv, maps to ipmitool syntax. */
+struct ipmi_rq {
+ struct {
+ uchar netfn:6;
+ uchar lun:2;
+ uchar cmd;
+ uchar target_cmd;
+ ushort data_len;
+ uchar *data;
+ } msg;
+};
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* ------------------------ SUBROUTINES ------------------------- */
+
+/*
+ * ipmi_cmd
+ * ushort cmd (input): (netfn << 8) + command
+ * uchar *pdata (input): pointer to ipmi data
+ * int sdata (input): size of ipmi data
+ * uchar *presp (output): pointer to response data buffer
+ * int *sresp (input/output): on input, size of response buffer,
+ * on output, length of response data
+ * uchar *cc (output): completion code
+ * char fdebugcmd(input): flag =1 if debug output desired
+ * returns 0 if successful, <0 if error
+ */
+int ipmi_cmd(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+/*
+ * ipmi_cmdraw
+ * uchar cmd (input): IPMI Command
+ * uchar netfn (input): IPMI NetFunction
+ * uchar sa (input): IPMI Slave Address of the MC
+ * uchar bus (input): BUS of the MC
+ * uchar lun (input): IPMI LUN
+ * uchar *pdata (input): pointer to ipmi data
+ * int sdata (input): size of ipmi data
+ * uchar *presp (output): pointer to response data buffer
+ * int *sresp (input/output): on input, size of response buffer,
+ * on output, length of response data
+ * uchar *cc (output): completion code
+ * char fdebugcmd(input): flag =1 if debug output desired
+ * returns 0 if successful, <0 if error
+ */
+int ipmi_cmdraw(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+/*
+ * ipmi_close_
+ * Called to close an IPMI session.
+ * returns 0 if successful, <0 if error
+ */
+int ipmi_close_(void);
+int ipmi_close(void); /*ditto*/
+/*-----------------------------------------------------------------*
+ * These externals are conditionally compiled in ipmicmd.c
+ ipmi_cmdraw_ia() Intel IMB driver, /dev/imb
+ ipmi_cmdraw_mv() MontaVista OpenIPMI driver
+ ipmi_cmdraw_va() VALinux driver
+ ipmi_cmdraw_ld() LANDesk driver
+ ipmi_cmdraw_direct() Direct/Driverless KCS or SSIF
+ ipmi_cmdraw_lan() IPMI LAN
+ ipmi_cmdraw_lan2() IPMI LANplus (RMCP+ in IPMI 2.0)
+ *-----------------------------------------------------------------*/
+
+/*
+ * parse_lan_options
+ * Parse the IPMI LAN options from the command-line getopt.
+ * int c (input): command-line option from getopt, one of:
+ case 'F': force driver type
+ case 'T': auth type
+ case 'V': priv level
+ case 'J': cipher suite
+ case 'N': nodename
+ case 'U': username
+ case 'R': remote password
+ case 'P': remote password
+ case 'E': get password from IPMI_PASSWORD environment var
+ case 'Y': prompt for remote password
+ case 'Z': set local MC address
+ * char *optarg (input): command-line argument from getopt
+ * char fdebug (input): show debug messages if =1, default=0
+ */
+void parse_lan_options(int c, char *optarg, char fdebug);
+/*
+ * set_lan_options
+ * Use this routine to set the lan options 'gnode','guser','gpswd', etc.
+ * This would only be required before opening a new session.
+ * char *node (input): IP address or nodename of remote node's IPMI LAN
+ * char *user (input): IPMI LAN username
+ * char *pswd (input): IPMI LAN password
+ * int auth (input): IPMI LAN authentication type (1 - 5)
+ * IPMI_SESSION_AUTHTYPE_NONE 0x00
+ * IPMI_SESSION_AUTHTYPE_MD2 0x01
+ * IPMI_SESSION_AUTHTYPE_MD5 0x02
+ * IPMI_SESSION_AUTHTYPE_PASSWORD 0x04
+ * IPMI_SESSION_AUTHTYPE_OEM 0x05
+ * int priv (input): IPMI LAN privilege level (1 - 5)
+ * IPMI_PRIV_LEVEL_CALLBACK 0x01
+ * IPMI_PRIV_LEVEL_USER 0x02
+ * IPMI_PRIV_LEVEL_OPERATOR 0x03
+ * IPMI_PRIV_LEVEL_ADMIN 0x04
+ * IPMI_PRIV_LEVEL_OEM 0x05
+ * int cipher (input): IPMI LAN cipher suite (0 thru 17, default is 3)
+ * See table 22-19 in the IPMIv2 spec.
+ * void *addr (input): Socket Address to use (SOCKADDR_T *) if not NULL
+ * This is only used in itsol.c because it has an
+ * existing socket open. Default is NULL for this.
+ * int addr_len (input): length of Address buffer (128 if ipv6, 16 if ipv4)
+ * returns 0 if successful, <0 if error
+ */
+int set_lan_options(char *node, char *user, char *pswd, int auth, int priv,
+ int cipher, void *addr, int addr_len);
+int get_lan_options(char *node, char *user, char *pswd, int *auth, int *priv,
+ int *cipher, void *addr, int *addr_len);
+void print_lan_opt_usage(void);
+int ipmi_getdeviceid(uchar *presp, int sresp, char fdebugcmd);
+/* int ipmi_open(void); * embedded in ipmi_cmd() */
+int ipmi_getpicmg(uchar *presp, int sresp, char fdebug);
+char *show_driver_type(int idx);
+int set_driver_type(char *tag);
+int get_driver_type(void);
+int nodeislocal(char *nodename);
+/* These *_mc routines are used to manage changing the mc.
+ * The local mc (mymc) may be changed via -Z, and
+ * the remote mc (mc) may be changed with -m. */
+void ipmi_set_mc(uchar bus, uchar sa, uchar lun, uchar type);
+void ipmi_get_mc(uchar *bus, uchar *sa, uchar *lun, uchar *type);
+void ipmi_restore_mc(void);
+void ipmi_set_mymc(uchar bus, uchar sa, uchar lun, uchar type);
+void ipmi_get_mymc(uchar *bus, uchar *sa, uchar *lun, uchar *type);
+/* ipmi_cmdraw_mc and ipmi_cmd_mc are used in cases where the mc may
+ * have been changed via ipmi_set_mc. */
+int ipmi_cmdraw_mc(uchar cmd, uchar netfn,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+int ipmi_cmd_mc(ushort icmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+/* ipmi_sendrecv is a wrapper for ipmi_cmdraw which maps to ipmitool syntax */
+int ipmi_sendrecv(struct ipmi_rq * req, uchar *rsp, int *rsp_len);
+
+/* other common subroutines */
+char * decode_rv(int rv); /*ipmicmd.c*/
+char * decode_cc(ushort icmd, int cc);
+void dump_buf(char *tag,uchar *pbuf,int sz, char fshowascii);
+int get_lan_channel(uchar chstart, uchar *chan);
+void show_fru_picmg(uchar *pdata, int dlen); /* ifru_picmg.c*/
+/* show_outcome outputs the meaning of the return code. */
+void show_outcome(char *prog, int ret);
+/* these log routines are primarily for the isol debug log */
+FILE *open_log(char *mname);
+void close_log(void);
+void flush_log(void);
+void print_log( char *pattn, ... );
+void dump_log(FILE *fp,char *tag,uchar *pbuf,int sz, char fshowascii);
+void logmsg( char *pname, char *pattn, ... );
+
+#ifdef WIN32
+/* Implement the Linux strncasecmp for Windows. */
+int strncasecmp(const char *s1, const char *s2, int n);
+#endif
+const char *val2str(ushort val, const struct valstr *vs); /*ipmilanplus.c*/
+const char * oemval2str(ushort oem, uchar val, const struct oemvalstr *vs);
+void set_debug(void); /*used only by oem_sun.c*/
+void set_iana(int iana); /*ipmicmd.c*/
+void set_mfgid(uchar *devid, int len);
+void get_mfgid(int *pvend, int *pprod);
+void get_devid_ver(uchar *bmaj, uchar *bmin, uchar *iver);
+
+char *get_nodename(void);
+char is_remote(void);
+void show_devid(uchar b1, uchar b2, uchar i1, uchar i2);
+int set_max_kcs_loops(int ms); /* ipmicmd.c, calls ipmidir.c if ok */
+
+/* These common subroutines are in subs.c */
+int str_icmp(char *s1, char *s2); /*used internally in ipmicmd.c*/
+char * strdup_(const char *instr); /*wrapper for strdup, supports WIN32*/
+int strlen_(const char *s);
+uchar htoi(char *inhex);
+void os_usleep(int s, int u);
+char *get_iana_str(int mfg); /*subs.c*/
+int get_errno(void); /*subs.c*/
+const char * buf2str(uchar * buf, int len); /*subs.c*/
+int str2uchar(char *str_in, uchar *uchr_out);
+uchar atob(char *str_in); /* calls str2uchar*/
+void atoip(uchar *array,char *instr);
+int get_system_info(uchar parm, char *pbuf, int *szbuf); /*subs.c*/
+int set_system_info(uchar parm, uchar *pbuf, int szbuf); /*subs.c*/
+int ipmi_reserved_user(int vend, int userid); /*subs.c*/
+
+/* from mem_if.c */
+int get_BiosVersion(char *str);
+
+/* see isensor.h for SDR cache routines */
+/* see ievents.h for sensor_type_desc, sel_opts, decode_sel routines */
+
+#ifdef __cplusplus
+}
+#endif
+/* end ipmicmd.h */
diff --git a/util/ipmidir.c b/util/ipmidir.c
new file mode 100644
index 0000000..4865bc0
--- /dev/null
+++ b/util/ipmidir.c
@@ -0,0 +1,1513 @@
+/************************************************
+ *
+ * ipmidir.c
+ *
+ * Supports direct raw KCS and SMBus user-space I/Os.
+ * Use this if no other IPMI driver is present.
+ * This interface would not be sufficient if more
+ * than one application is using IPMI at a time.
+ * This code is currently included for Linux, not for
+ * Windows. Windows requires imbdrv.sys or ipmidrv.sys.
+ *
+ * 08/21/06 Andy Cress - added as a new module
+ * 09/22/06 Andy Cress - improved SMBus base address detection
+ * 09/27/06 Andy Cress - fixed passing slave addrs other than BMC (0x20)
+ * 01/16/08 Andy Cress - more DBG messages
+ *
+ ************************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#if defined(STUB_IO)
+/* May stub out direct io. For instance, PPC does not support <sys/io.h> */
+#define UCHAR unsigned char
+#define UINT16 unsigned short
+int ipmi_open_direct(int fdebugcmd)
+{ return(-1); }
+int ipmi_close_direct(void)
+{ return(-1); }
+int ipmi_cmdraw_direct(UCHAR cmd, UCHAR netfn, UCHAR lun, UCHAR sa, UCHAR bus,
+ UCHAR *pdata, int sdata, UCHAR *presp,
+ int *sresp, UCHAR *pcc, char fdebugcmd)
+{ return(-1); }
+int ipmi_cmd_direct(UINT16 icmd, UCHAR *pdata, int sdata, UCHAR *presp,
+ int *sresp, UCHAR *pcc, char fdebugcmd)
+{ return(-1); }
+int ipmi_set_max_kcs_loops(int ms)
+{ return(0); }
+
+#elif defined(LINUX) || defined(BSD) || defined(DOS) || defined(MACOS)
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h> // for ProcessSendMessage timeout
+#include <string.h>
+#include <errno.h>
+#ifdef DOS
+#include <dos.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "imb_api.h"
+#include "ipmicmd.h"
+#include "ipmidir.h"
+/* No special includes for 64-bit are needed. */
+
+#if defined(LINUX)
+#include <sys/io.h>
+#elif defined(BSD) || defined(MACOS)
+// #include <machine/cpufunc.h>
+int iofd = -1;
+
+static __inline uchar
+inbc(ushort port)
+{
+ uchar data;
+/* from Linux sys/io.h:
+ * __asm__ __volatile__ ("inb %w1,%0":"=a" (data):"Nd" (port));
+ * from BSD machine/cpufunc.h:
+ * __asm __volatile("inb %1,%0" : "=a" (data) : "id" ((ushort)(port)));
+ */
+ __asm __volatile("inb %1,%0" : "=a" (data) : "d" (port));
+ return (data);
+}
+static __inline void
+outbc(ushort port, uchar data)
+{
+/* from Linux sys/io.h:
+ * __asm__ __volatile__ ("outb %b0,%w1": :"a" (data), "Nd" (port));
+ * from BSD machine/cpufunc.h:
+ * __asm __volatile("outb %0,%1" : : "a" (data), "id" ((ushort)(port)));
+ */
+ __asm __volatile("outb %0,%1" : : "a" (data), "d" (port));
+}
+static __inline uint
+inl(ushort port)
+{
+ uint data;
+
+ __asm __volatile("inl %%dx,%0" : "=a" (data) : "d" (port));
+ return (data);
+}
+static __inline void
+outl(ushort port, uint data)
+{
+ __asm __volatile("outl %0,%%dx" : : "a" (data), "d" (port));
+}
+#endif
+/* Linux & BSD define usleep() in unistd.h, but DOS has delay() instead. */
+#if defined(DOS)
+void usleep(ulong usec) /*missing from DOS*/
+{
+ delay(usec);
+}
+#endif
+
+
+/* DBGP() is enabled with -x, DBGP2 is enabled if LINUX_DEBUG & -x */
+#define DBGP(fmt, args...) if (fdebugdir) fprintf(stdout,fmt, ##args)
+#if defined(DOS)
+#define DBGP2() ; /*no extra debug output*/
+#elif defined(LINUX_DEBUG)
+#define DBGP2(fmt, args...) if (fdebugdir) fprintf(stderr,fmt, ##args)
+#else
+#define DBGP2(fmt, args...) ; /*no extra debug output*/
+#endif
+
+#ifdef ALONE
+static int fjustpass = 0;
+#else
+// DRV_KCS, DRV_SMB types defined in ipmicmd.h
+// extern int fDriverTyp; // use set_driver_type() instead
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+extern int fjustpass;
+#endif
+
+/*****************************************************************************/
+/*
+ * GLOBAL DATA
+ */
+/* KCS base addr: use 0xca2 for ia32, 0x8a2 for ia64
+ * some use 0xca8/0xcac w register spacing
+ */
+#if defined(__ia64__)
+/* gcc defines __ia64__, or Makefile.am defines __IA64__ */
+static UINT16 kcsBaseAddress = 0x8a2; /* for Itanium2 KCS */
+static UINT8 kcs_inc = 1; /*register spacing*/
+#else
+static UINT16 kcsBaseAddress = 0xca2; /* for ia32 KCS */
+static UINT8 kcs_inc = 1; /*register spacing*/
+#endif
+/*
+ * SMBus/SSIF: see dmidecode for I2C Slave Address & Base Addr.
+ * Slave Addr is constant for all Intel SSIF platforms (=0x84).
+ * 0x0540 base <= PCI ID 24D38086 at 00:1f.3 is JR (ICH5)
+ * 0x0400 base <= PCI ID 25A48086 at 00:1f.3 is TP (Hance_Rapids)
+ */
+UINT8 mBMCADDR = 0x84; /* SMBus I2C slave address = (0x42 << 1) */
+UINT16 mBMC_baseAddr = 0x540; /* usu. 0x0540 (JR), or 0x0400 if TP */
+UINT16 BMC_base = 0; /* resulting BMC base address (KCS or SMBus)*/
+
+static char lock_dir_file[] = "/var/tmp/ipmiutil_dir_lock";
+
+/* SSIF/SMBus defines */
+#define STATUS_REQ 0x60
+#define WR_START 0x61
+#define WR_END 0x62
+#define READ_BYTE 0x68
+#define COMMAND_REG (kcsBaseAddress+kcs_inc)
+#define STATUS_REG (kcsBaseAddress+kcs_inc)
+#define DATA_IN_REG (kcsBaseAddress)
+#define DATA_OUT_REG (kcsBaseAddress)
+
+#if defined(DOS)
+extern unsigned inp(unsigned _port);
+extern unsigned outp(unsigned _port, unsigned _value);
+#pragma intrinsic(inp, outp)
+#define _INB(addr) inp((addr))
+#define _OUTB(data, addr) outp((addr),(data))
+#define _IOPL(data) 0
+#define ReadPortUchar( addr, valp ) (*valp) = inp((addr))
+#define WritePortUchar( addr, val ) outp((addr),(val))
+#define WritePortUlong( addr, val ) ( outp((addr),(val)) )
+#define ReadPortUlong( addr, valp ) (*(valp) = inp((addr)) )
+#elif defined(BSD) || defined(MACOS)
+#define _INB(addr) inbc((addr))
+#define _OUTB(data, addr) outbc((addr),(data))
+#define _IOPL(data) 0
+#define ReadPortUchar( addr, valp ) (*valp) = inbc((addr))
+#define WritePortUchar( addr, val ) outbc((addr),(val))
+#define WritePortUlong( addr, val ) ( outl((addr),(val)) )
+#define ReadPortUlong( addr, valp ) (*(valp) = inl((addr)) )
+#else
+#define _INB(addr) inb((addr))
+#define _OUTB(data, addr) outb((data),(addr))
+#define _IOPL(data) iopl((data))
+#define ReadPortUchar( addr, valp ) (*valp) = inb((addr))
+#define WritePortUchar( addr, val ) outb((val),(addr))
+#define WritePortUlong( addr, val ) ( outl((val), (addr)) )
+#define ReadPortUlong( addr, valp ) (*(valp) = inl((addr)) )
+#endif
+/* Static data for Driver type, BMC type, etc. */
+static int g_DriverType = DRV_KCS;
+static UINT16 g_ipmiVersion = IPMI_VERSION_UNKNOWN;
+static UINT16 g_bmcType = BMC_UNKNOWN;
+struct SMBCharStruct SMBChar;
+static int fdebugdir = 0;
+static char fDetectedIF = 0;
+
+/*****************************************************************************/
+/* Subroutine prototypes */
+
+#ifdef ALONE
+int set_driver_type(char * typ) { return; }
+int get_IpmiStruct(UCHAR *iftype, UCHAR *ver, UCHAR *sa, int *base, UCHAR *inc) { return(-1); }
+#else
+/* extern int set_driver_type(char * typ); in ipmicmd.h */
+extern char fsm_debug; /*in mem_if.c*/
+extern int get_IpmiStruct(UCHAR *iftype, UCHAR *ver, UCHAR *sa, int *base, UCHAR *inc);
+#endif
+int SendTimedImbpRequest_kcs( IMBPREQUESTDATA *requestData,
+ unsigned int timeout, UINT8 *resp_data,
+ int *respDataLen, UINT8 *compCode);
+int SendTimedImbpRequest_ssif( IMBPREQUESTDATA *requestData,
+ unsigned int timeout, UINT8 *resp_data,
+ int *respDataLen, UINT8 *compCode);
+int ImbInit_dir(void);
+static int SendmBmcRequest(
+ unsigned char* request, UINT32 reqLength,
+ unsigned char* response, UINT32* respLength,
+ UINT32 ipmiOldFlag);
+static int ReadResponse( unsigned char* resp, struct SMBCharStruct* smbChar);
+static int SendRequest( unsigned char* req, int length,
+ struct SMBCharStruct* smbChar );
+static int GetDeviceId(UINT16 *bmcType, UINT16 *ipmiVersion);
+static int send_raw_kcs(UINT8 *rqData, int rqLen, UINT8 *rsData, int *rsLen );
+static int ProcessTimedMessage(BMC_MESSAGE *p_reqMsg, BMC_MESSAGE *p_respMsg, const UINT32 timeout);
+static int wait_for_SMS_flag(void);
+
+/*****************************************************************************/
+/* Subroutines */
+
+static int ProcessMessage(BMC_MESSAGE *p_reqMsg, BMC_MESSAGE *p_respMsg)
+{
+ int status = STATUS_OK;
+ UINT32 timeout = 1000 * GETMSGTIMEOUT; // value is in milliseconds
+ status = ProcessTimedMessage(p_reqMsg, p_respMsg, timeout);
+ return status;
+}
+
+static char *BmcDesc(unsigned char drvtype)
+{ /* return BMC Driver type description string */
+ char *msg;
+ switch(drvtype) {
+ case DRV_KCS: msg = "KCS"; break; /*BMC Sahalee KCS*/
+ case DRV_SMB: msg = "SMBus"; break; /*mBMC SMBus (SSIF)*/
+ default: msg = "";
+ }
+ return(msg);
+}
+
+int get_ipmi_if(void)
+{
+ /* Only care about Linux since ipmidir is not used for Windows. */
+ char *if_file = "/var/lib/ipmiutil/ipmi_if.txt";
+ char *if_file2 = "/usr/share/ipmiutil/ipmi_if.txt";
+ FILE *fp;
+ char line[80];
+ char *p;
+ char *r;
+ int rv = ERR_NO_DRV;
+ int i, j;
+ ulong mybase = 0;
+ int myinc = 1;
+ // uchar *rgbase;
+
+ fp = fopen(if_file,"r");
+ if (fp == NULL) fp = fopen(if_file2,"r");
+ if (fp == NULL) { /*error opening ipmi_if file*/
+ return -1;
+ } else { /*read the data from the ipmi_if file*/
+ while ( (p = fgets(line,sizeof(line),fp)) != NULL)
+ {
+ if (strstr(line,"Interface type:") != NULL) {
+ if (strstr(line,"KCS") != NULL) {
+ g_DriverType = DRV_KCS;
+ } else {
+ g_DriverType = DRV_SMB;
+ }
+ } else if (strstr(line,"Base Address:") != NULL) {
+ r = strchr(line,':');
+ i = strspn(++r," \t"); /* skip leading spaces */
+ r += i;
+ j = strcspn(r," \t\r\n"); /* end at next whitespace */
+ r[j] = 0; /*stringify*/
+ /* convert the "0x0000000000000401" string to an int */
+ if (strncmp(r,"0x",2) == 0) { r += 2; j -= 2; }
+ DBGP2("base addr 0x: %s, mybase=%x j=%d\n",r,mybase,j);
+ mybase = strtol(r, NULL, 16); /*hex string is base 16*/
+ DBGP2("base addr 0x: %s, mybase=%x \n",r,mybase);
+ } else if (strstr(line,"Register Spacing:") != NULL) {
+ r = strchr(line,':');
+ i = strspn(++r," \t"); /* skip leading spaces */
+ r += i;
+ j = strcspn(r," \t"); /* end at next whitespace */
+ r[j] = 0; /*stringify*/
+ myinc = atoi(r);
+ }
+ }
+ fclose(fp);
+ DBGP("ipmi_if: Driver = %d (%s), Base = 0x%04lx, Spacing = %d\n",
+ g_DriverType,BmcDesc(g_DriverType),mybase,myinc);
+ if (g_DriverType == DRV_SMB) {
+ if (mybase & 0x0001) mybase -= 1; /* 0x0401 -> 0x0400 */
+ if (mybase != 0 && (mybase & 0x0F) == 0) { /* valid base address */
+ mBMC_baseAddr = mybase;
+ BMC_base = mBMC_baseAddr;
+ rv = 0;
+ }
+ } else { /*KCS*/
+ if (mybase != 0) { /* valid base address */
+ kcsBaseAddress = (mybase & 0x0000ffff);
+ BMC_base = kcsBaseAddress;
+ if (myinc > 1) kcs_inc = myinc;
+ rv = 0;
+ }
+ }
+ DBGP2("ipmi_if: BMC_base = 0x%04x, kcs_inc = %d, ret = %d\n",
+ BMC_base, kcs_inc,rv);
+ }
+ return(rv);
+}
+
+static int set_lock_dir(void)
+{
+ int rv = 0;
+ FILE *fp;
+ fp = fopen(lock_dir_file,"w");
+ if (fp == NULL) rv = -1;
+ else {
+ fclose(fp);
+ rv = 0;
+ }
+ return(rv);
+}
+
+static int clear_lock_dir(void)
+{
+ int rv = 0;
+ rv = remove(lock_dir_file); /*same as unlink() */
+ if (fdebugdir) printf("clear_lock rv = %d\n",rv);
+ return(rv);
+}
+
+static int check_lock_dir(void)
+{
+ int rv = 0;
+#ifdef LOCK_OK
+ FILE *fp;
+ fp = fopen(lock_dir_file,"r");
+ if (fp == NULL) rv = 0;
+ else {
+ fclose(fp);
+ rv = -1; /*error, lock file exists*/
+ }
+#endif
+ return(rv);
+}
+
+int ipmi_open_direct(int fdebugcmd)
+{
+ int status = 0;
+ //char *dmsg = "";
+ int i;
+
+ DBGP2("open_direct(%d) called\n",fdebugcmd);
+ if (fdebugcmd) {
+ fdebugdir = fdebugcmd;
+#if defined(LINUX_DEBUG) && !defined(ALONE)
+ fsm_debug = fdebugcmd;
+#endif
+ }
+
+ /* Read ipmi_if config file data, if present. */
+ status = get_ipmi_if();
+ if (status == -1) {
+ uchar iftype, iver, sa, inc;
+ int mybase;
+ /* Read SMBIOS to get IPMI struct */
+ status = get_IpmiStruct(&iftype,&iver,&sa,&mybase,&inc);
+ if (status == 0) {
+ if (iftype == 0x04) {
+ g_DriverType = DRV_SMB;
+ mBMC_baseAddr = mybase;
+ } else { /*0x01==KCS*/
+ g_DriverType = DRV_KCS;
+ if (sa == 0x20 && mybase != 0) { /*valid*/
+ kcsBaseAddress = mybase;
+ kcs_inc = inc;
+ }
+ }
+ BMC_base = mybase;
+ DBGP("smbios: Driver=%d(%s), sa=%02x, Base=0x%04x, Spacing=%d\n",
+ g_DriverType,BmcDesc(g_DriverType),sa,mybase,inc);
+ }
+ }
+
+#ifndef DOS
+ /* superuser/root priv is required for direct I/Os */
+ i = geteuid(); /*direct is Linux only anyway*/
+ if (i > 1) {
+ fprintf(stdout,"Not superuser (%d)\n", i);
+ return ERR_NO_DRV;
+ }
+#endif
+ /* check lock for driverless interface */
+ i = check_lock_dir();
+ if (i != 0) {
+ fprintf(stdout,"open_direct interface locked, %s in use\n",
+ lock_dir_file);
+ return ERR_NO_DRV;
+ }
+
+ /* Find the SMBIOS IPMI driver type, data */
+ status = ImbInit_dir();
+ DBGP2("open_direct Init status = %d\n",status);
+ DBGP2("open_direct base=%x spacing=%d\n",BMC_base,kcs_inc);
+ if (status == 0) {
+ fDetectedIF = 1; /*Successfully detected interface */
+ /* Send a command to the IPMI interface */
+ if (!fjustpass)
+ status = GetDeviceId(&g_bmcType,&g_ipmiVersion);
+ if (status == 0) {
+ char *typ;
+ if (g_DriverType == DRV_SMB) typ = "smb";
+ else typ = "kcs";
+ set_driver_type(typ);
+ }
+ }
+ DBGP("open_direct: status=%d, %s drv, ipmi=%d\n",
+ status,BmcDesc(g_DriverType),g_ipmiVersion);
+
+ /* set lock for driverless interface */
+ i = set_lock_dir();
+ return status;
+}
+
+int ipmi_close_direct(void)
+{
+ int status = 0;
+#if defined(BSD) || defined(MACOS)
+ close(iofd);
+ iofd = -1;
+#endif
+ /* clear lock for driverless interface */
+ status = clear_lock_dir();
+ return status;
+}
+
+int ipmi_cmdraw_direct(UCHAR cmd, UCHAR netfn, UCHAR lun, UCHAR sa, UCHAR bus,
+ UCHAR *pdata, int sdata, UCHAR *presp,
+ int *sresp, UCHAR *pcc, char fdebugcmd)
+{
+ BMC_MESSAGE sendMsg;
+ BMC_MESSAGE respMsg;
+ int status;
+ int len = 0;
+
+ if (g_bmcType == BMC_UNKNOWN) {
+ /* User-specified a driver type, but need open */
+ status = ipmi_open_direct(fdebugcmd);
+ }
+ fdebugdir = fdebugcmd;
+ if (sdata > IPMI_REQBUF_SIZE) return(LAN_ERR_BADLENGTH);
+ if (fjustpass) {
+ status = send_raw_kcs(pdata, sdata, presp, sresp);
+ *pcc = 0;
+ return(status);
+ }
+ sendMsg.Bus = bus;
+ sendMsg.DevAdd = sa;
+ sendMsg.NetFn = netfn;
+ sendMsg.LUN = lun;
+ sendMsg.Cmd = cmd;
+ sendMsg.Len = sdata;
+ if (sdata > 0) memcpy(sendMsg.Data,pdata,sdata);
+
+ status = ProcessMessage(&sendMsg, &respMsg);
+ if (status == STATUS_OK) {
+ *pcc = respMsg.CompCode;
+ if (respMsg.Len > 0) {
+ len = respMsg.Len;
+ if (len > *sresp) len = *sresp;
+ } else len = 0;
+ if (len > 0)
+ memcpy(presp,respMsg.Data,len);
+ *sresp = len;
+ }
+ return(status);
+}
+
+#ifndef ALONE
+int ipmi_cmd_direct(UINT16 icmd, UCHAR *pdata, int sdata, UCHAR *presp,
+ int *sresp, UCHAR *pcc, char fdebugcmd)
+{
+ UINT8 cmd, netfn, sa, lun, bus;
+ int status;
+ int i;
+
+ fdebugdir = fdebugcmd;
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == icmd) {
+ cmd = (icmd & 0x00ff);
+ sa = ipmi_cmds[i].sa;
+ bus = ipmi_cmds[i].bus;
+ netfn = ipmi_cmds[i].netfn;
+ lun = ipmi_cmds[i].lun;
+ break;
+ }
+ }
+ if (i >= NCMDS) {
+ DBGP("ipmidir: icmd %04x not found, defaults used\n",icmd);
+ cmd = (icmd & 0xFF);
+ netfn = (icmd & 0xFF00) >> 8;
+ sa = BMC_ADDR;
+ lun = BMC_LUN;
+ bus = 0;
+ }
+ status = ipmi_cmdraw_direct(cmd, netfn, lun, sa, bus, pdata, sdata,
+ presp, sresp, pcc, fdebugcmd);
+ return(status);
+}
+#endif
+
+static UINT8
+CalculateChecksum(UINT8* p_buff, int length)
+{
+ UINT8 sum = 0;
+ int i;
+ for (i = 0; i < length; i++) sum+= p_buff[i];
+ return (~sum) + 1;
+}
+
+static int
+GetDeviceId(UINT16 *bmcType, UINT16 *ipmiVersion)
+{
+ int status = STATUS_OK;
+ UINT16 thisBmcType = BMC_UNKNOWN;
+ BMC_MESSAGE sendMsg;
+ BMC_MESSAGE respMsg;
+
+ DBGP2("open_direct: detecting interface, bmc: %X ver: %X drv=%s\n",
+ g_bmcType, g_ipmiVersion, BmcDesc(g_DriverType));
+
+ // if the BMC type has not yet been detected - detect it
+ if( g_bmcType == BMC_UNKNOWN )
+ {
+ // Try sending the GetDeviceId command to the default interface
+ sendMsg.DevAdd = BMC_ADDR;
+ sendMsg.NetFn = NETFN_APP;
+ sendMsg.LUN = BMC_LUN;
+ sendMsg.Cmd = CMD_GET_DEVICE_ID;
+ sendMsg.Len = 0;
+ DBGP2("open_direct: Try Get_Device_ID with %s driver\n",
+ BmcDesc(g_DriverType));
+ status = ProcessMessage(&sendMsg, &respMsg);
+ if (status == STATUS_OK) {
+ if (g_DriverType == DRV_KCS) thisBmcType = BMC_SAHALEE;
+ else thisBmcType = BMC_MBMC_87431M;
+ } else { /*error, switch interfaces*/
+ DBGP("open_direct: ProcessMessage(%s) error = %d\n",
+ BmcDesc(g_DriverType),status);
+ if (!fDetectedIF) {
+ /* if not yet detected, try other IF type */
+ if (g_DriverType == DRV_KCS) {
+ DBGP2("open_direct: Not KCS, try SSIF/SMBus\n");
+ g_DriverType = DRV_SMB;
+ } else {
+ DBGP2("open_direct: Not SSIF, try KCS\n");
+ g_DriverType = DRV_KCS;
+ }
+ }
+ } /*end-else error*/
+
+ // If error, try again with the other interface
+ if (thisBmcType == BMC_UNKNOWN)
+ {
+ // send the command via KCS/SMBus to get the IPMI version.
+ status = ProcessMessage(&sendMsg, &respMsg);
+ if (status == STATUS_OK) {
+ if (g_DriverType == DRV_KCS) thisBmcType = BMC_SAHALEE;
+ else thisBmcType = BMC_MBMC_87431M;
+ } else {
+ // If sending message fails
+ status = ER_NO_BMC_IF;
+ }
+ }
+ g_bmcType = thisBmcType;
+
+ // if we contacted the BMC, decode its version
+ if( status == STATUS_OK )
+ {
+ if( g_bmcType == BMC_MBMC_87431M )
+ {
+ // Decode the miniBMC productID
+ }
+ if( respMsg.Data[4] == 0x51 )
+ g_ipmiVersion = (UINT16)IPMI_VERSION_1_5;
+ else if( respMsg.Data[4] == 0x02 )
+ g_ipmiVersion = IPMI_VERSION_2_0;
+ }
+ } /* endif unknown BMC */
+
+ // set the version info and leave
+ *ipmiVersion = g_ipmiVersion;
+ *bmcType = g_bmcType;
+
+ DBGP2("open_direct: AFTER bmc: %X ver: %X\n",
+ g_bmcType, g_ipmiVersion);
+ return status;
+}
+
+//*****************************************************************************
+#if defined (WIN64)
+ // Do Nothing for WIN64 as we are not using these functions here
+#else
+static int ProcessSendMessage(BMC_MESSAGE *p_reqMsg, BMC_MESSAGE *p_respMsg, const UINT8 bus, const UINT8 slave, const UINT32 timeout)
+{
+ int status = STATUS_OK;
+ BMC_MESSAGE sendReq;
+ static UINT8 sendSeq = 1;
+ static UINT8 incTestCount=0;
+ BMC_MESSAGE reqMsg,respMsg;
+ int retryCount;
+ UINT32 i;
+ UINT nRetryCount = 0;
+ int testCount;
+
+ // Windows will be using Async Imb request interface to poll for
+ // messages in the BMC SMS message queue
+
+ // format the send message packet
+ sendReq.Cmd = SENDMESSAGE_CMD;
+ sendReq.DevAdd = BMC_ADDR;
+ sendReq.LUN = 0;
+ sendReq.NetFn = NETFN_APP;
+
+ sendReq.Data[0] = bus;
+ sendReq.Data[1] = slave;
+ // NetFn is the upper 6 bits of the data byte, the LUN is the lower two
+ sendReq.Data[2] = ((p_reqMsg->NetFn << 2) | (p_reqMsg->LUN & 0x03));
+ sendReq.Data[3] = CalculateChecksum(&sendReq.Data[1], 2);
+ sendReq.Data[4] = BMC_ADDR;
+ // NetFn is the upper 6 bits of the data byte, the LUN is the lower two
+ sendReq.Data[5] = ((sendSeq << 2) | (SMS_MSG_LUN & 0x03));
+ // sequence number = 1 << 2 and BMC message response lun = 0x02
+ sendReq.Data[6] = p_reqMsg->Cmd;
+
+ // loop to copy the command data to the send message data format
+ i = 0;
+ for(i=0; i < p_reqMsg->Len; i++)
+ sendReq.Data[7+i] = p_reqMsg->Data[i];
+
+ // create a checksum
+ sendReq.Data[7+i] = CalculateChecksum(&sendReq.Data[4], p_reqMsg->Len + 3); // send data length plus the values from index 3 - 6
+
+ // send length plus 0 - 7 and checksum byte
+ sendReq.Len = p_reqMsg->Len + 8;
+ /*
+ * Send the message with retries
+ * For get Device ID & Read FRU data, retry less, in case
+ * HSC/LCP is not present,
+ */
+ if (p_reqMsg->NetFn != 0x08 )
+ retryCount = BMC_MAX_RETRIES+2;
+ else
+ retryCount = BMC_MAX_RETRIES+20;
+ do
+ { // send the message
+ if( (status = ProcessMessage(&sendReq, p_respMsg)) == STATUS_OK )
+ {
+ // some error, maybe because the controller was not ready yet.
+ if( p_respMsg->CompCode == 0x83 ) {
+ // Sleep for 1 second and try again
+ sleep(1);
+ incTestCount = 1; // true
+ continue; // try again
+ }
+ else if( p_respMsg->CompCode == 0x82 ) {
+ DBGP("ProcessSendMessage(sa=%02x,%02x,%02x) "
+ "ccode=82 bus error\n",
+ slave,p_reqMsg->NetFn,p_reqMsg->Cmd);
+ status = ERGETTINGIPMIMESSAGE;
+ break; // exit with error
+ }
+ else if( p_respMsg->CompCode != 0x00 )
+ continue; //break; // exit with error
+
+ status = wait_for_SMS_flag(); /* new, added */
+ if (status == -1)
+ DBGP("wait_for_SMS_flag timeout\n");
+
+ // Only for windows we use Imb Asyn interface for polling
+ // For Unix we issue GetMessage command
+ // issue a getmessage command
+ reqMsg.DevAdd = BMC_ADDR;
+ reqMsg.NetFn = NETFN_APP;
+ reqMsg.LUN = BMC_LUN;
+ reqMsg.Cmd = GETMESSAGE_CMD;
+ reqMsg.Len = 0;
+
+ nRetryCount = 0;
+ testCount = 100; /* For HSC */
+ if (slave == 0x22 || incTestCount == 1) // true
+ testCount=1000; /*added for LCP */
+ do
+ {
+ /* Loop here for the response with the correct
+ * sequence number. */
+ if( (status = ProcessMessage( &reqMsg, &respMsg )) != 0 ) {
+ DBGP("Breaking after Getmsg, Status is %d\n",status);
+ break;
+ }
+ if( slave == 0x22 && p_reqMsg->Cmd == 0x04 ) {
+ /* give debug if LCP ever gets here. */
+ DBGP("LCP get: cnt[%d,%d] seq[%02x,%02x] cc=%02x status=%u\n",
+ testCount,retryCount, sendSeq,
+ ((respMsg.Data[4] & 0xFC)>>2),
+ respMsg.CompCode,status) ;
+ return STATUS_OK;
+ }
+ if (respMsg.CompCode != 0) {
+ DBGP2("get, cnt[test=%d] slave=%02x, cc==%02x\n",
+ testCount,slave,respMsg.CompCode);
+ /* Used to wait 1 ms via usleep(1000), but not needed. */
+ // usleep(1000);
+ }
+ } while(((respMsg.CompCode == 0x83 ||(respMsg.CompCode == 0x80))
+ && --testCount > (int) 0) || (respMsg.CompCode == 0x0
+ && ((respMsg.Data[4] & 0xFC) >> 2) != sendSeq) );
+
+ DBGP("get cnt[test=%d,retry=%d] seq[Send=0x%02x Recv=0x%02x] "
+ "CompCode=0x%x status=%u\n", testCount,retryCount,
+ sendSeq,((respMsg.Data[4] & 0xFC)>>2),
+ respMsg.CompCode,status);
+
+ if( (respMsg.CompCode == 0x00) && (status == STATUS_OK) &&
+ ((respMsg.Data[4] & 0xFC) >> 2 == sendSeq) )
+ {
+ // format the GetMessage response
+ (*p_respMsg) = (*p_reqMsg);
+ // The first data byte is the channel number the message
+ // was sent on
+ p_respMsg->DevAdd = respMsg.Data[3];
+ p_respMsg->NetFn = respMsg.Data[1] >> 2;
+ p_respMsg->LUN = respMsg.Data[4] & 0x03;
+ p_respMsg->Cmd = respMsg.Data[5];
+ p_respMsg->CompCode = respMsg.Data[6]; // comp code
+ p_respMsg->Len = respMsg.Len - 8;
+ // the last data byte is the checksum
+ if ( p_respMsg->CompCode == 0xCC) {
+ DBGP2(" Cmd=%d Len=%d ccode=CC ",
+ p_respMsg->Cmd, p_respMsg->Len);
+ }
+ for(i=0; i < p_respMsg->Len; i++)
+ p_respMsg->Data[i] = respMsg.Data[7+i];
+ break;
+ }
+ }
+ // this will retry the read the number of times in retryCount
+ } while( --retryCount > 0 );
+
+ if( retryCount <= 0 ) status = ERGETTINGIPMIMESSAGE;
+
+ /* Increment the sequence number
+ * sequence number can't be greater 63 (6bit number),
+ * so wrap the counter if it is */
+ ++sendSeq;
+ if( sendSeq >= 64 ) sendSeq = 1;
+ return status;
+}
+
+#endif /* All other than WIN64 */
+
+/* #define MAX_KCS_LOOP 30000 *was 7000*/
+/* Set a failsafe MAX KCS Loops to prevent infinite loop on status reg */
+/* max was 7000, but need longer for ClearSEL cmd */
+static int max_kcs_loop = 30000; /*means 300ms*/
+static int max_sms_loop = 500; /*means 500ms*/
+static int peak_loops = 0;
+int ipmi_set_max_kcs_loops(int ms)
+{
+ max_kcs_loop = ms * 100; /*300 ms * 100 = 30000 loops*/
+ max_sms_loop = ms;
+ return 0;
+}
+
+static int wait_for_SMS_flag(void)
+{
+ int i = 0;
+ while((_INB(STATUS_REG) & 0x04) == 0)
+ {
+ usleep(2 * 1000); /*sleep for 2 msec*/
+ i += 2;
+ if ( i > max_sms_loop ) return -1;
+ }
+ return 0;
+}
+
+static int wait_for_IBF_clear(void)
+ {
+ int i = 0;
+ while ((_INB(STATUS_REG) & 0x02) == 0x02) {
+ if (i > 0 && (i % 100) == 0) usleep(1000); /*sleep for 1 msec*/
+ if (i > max_kcs_loop) {
+ DBGP("wait_for_IBF_clear: max loop %d\n",i);
+ return -1;
+ // break;
+ }
+ i++;
+ }
+ if (i > peak_loops) peak_loops = i;
+ return 0;
+ }
+
+static int wait_for_OBF_set(void)
+ {
+ int i = 0;
+ while ((_INB(STATUS_REG) & 0x01) == 0x00) {
+ if (i > 0 && (i % 100) == 0) usleep(1000); /*sleep for 1 msec*/
+ if (i > max_kcs_loop) {
+ DBGP("wait_for_OBF_set: max loop %d\n",i);
+ return -1;
+ // break;
+ }
+ i++;
+ }
+ if (i > peak_loops) peak_loops = i;
+ return 0;
+ }
+
+static inline int get_write_state(void)
+ {
+ if ((_INB(STATUS_REG) >> 6) != 0x02)
+ return -1;
+ return 0;
+ }
+
+static inline int get_read_state(void)
+ {
+ if ((_INB(STATUS_REG) >> 6) != 0x01)
+ return -1;
+ return 0;
+ }
+
+static inline int get_idle_state(void)
+ {
+ if ((_INB(STATUS_REG) >> 6) != 0x00)
+ return -1;
+ return 0;
+ }
+
+UINT8 dummy2;
+static inline void clear_OBF(void)
+{
+ dummy2 = _INB(DATA_IN_REG);
+}
+
+static int
+send_raw_kcs (UINT8 *rqData, int rqLen, UINT8 *rsData, int *rsLen )
+{
+ int length;
+ unsigned char dummy;
+ unsigned char rx_data[64];
+ int rxbuf_len;
+ int rv;
+
+ if (fdebugdir) {
+ int cnt;
+ DBGP("send_raw_kcs: ");
+ for ( cnt=0; cnt < rqLen ; cnt++)
+ DBGP(" %02x",rqData[cnt]);
+ DBGP("\n");
+ }
+ wait_for_IBF_clear();
+ clear_OBF();
+ _OUTB(WR_START,COMMAND_REG);
+ rv = wait_for_IBF_clear();
+ if (get_write_state() != 0) return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+ if (rv != 0) return LAN_ERR_SEND_FAIL;
+
+ for(length = 0;length < rqLen-1;length++)
+ {
+ _OUTB(rqData[length],DATA_OUT_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+ }
+
+ _OUTB(WR_END,COMMAND_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+ _OUTB(rqData[length],DATA_OUT_REG);
+
+ /* write phase complete, start read phase */
+ rxbuf_len = *rsLen;
+ *rsLen = 0;
+ while(*rsLen <= IPMI_RSPBUF_SIZE)
+ {
+ wait_for_IBF_clear();
+ if (get_read_state() != 0)
+ {
+ if (get_idle_state() != 0) {
+ DBGP2("not idle in rx_data (%02x)\n",_INB(STATUS_REG));
+ // clear_lock_dir();
+ return LAN_ERR_RECV_FAIL;
+ } else {
+ rv = wait_for_OBF_set();
+ if (rv != 0) return LAN_ERR_RECV_FAIL;
+ dummy = _INB(DATA_IN_REG);
+ /* done, copy the data */
+ for (length=0;length < *rsLen;length++)
+ rsData[length] = rx_data[length];
+ return ACCESS_OK;
+ }
+ } else {
+ rv = wait_for_OBF_set();
+ if (rv != 0) return LAN_ERR_RECV_FAIL;
+ rx_data[*rsLen] = _INB(DATA_IN_REG);
+ DBGP2("rx_data[%d] is 0x%x\n",*rsLen,rx_data[*rsLen]);
+ _OUTB(READ_BYTE,DATA_IN_REG);
+ (*rsLen)++;
+ }
+ if (*rsLen > rxbuf_len) {
+ DBGP("ipmidir: rx buffer overrun, size = %d\n",rxbuf_len);
+ break; /*stop if user buffer max*/
+ }
+ } /*end while*/
+ return ACCESS_OK;
+}
+
+/*
+ * SendTimedImbpRequest_kcs - write bytes to KCS interface, read response
+ * The bytes are written in this order:
+ * 1 netfn
+ * 2 cmdType
+ * 3-N data, if any
+ */
+int
+SendTimedImbpRequest_kcs (IMBPREQUESTDATA *requestData,
+ unsigned int timeout, UINT8 *resp_data, int *respDataLen,
+ unsigned char *compCode)
+{ /*SendTimedImb for KCS*/
+ int length;
+ unsigned char dummy;
+ unsigned char rx_data[64];
+ int rxbuf_len, rv;
+
+ if (fdebugdir) {
+ int cnt;
+ DBGP("Send Netfn=%02x Cmd=%02x, raw: %02x %02x %02x %02x",
+ requestData->netFn, requestData->cmdType,
+ requestData->busType, requestData->rsSa,
+ (requestData->netFn<<2), requestData->cmdType);
+ for ( cnt=0; cnt < requestData->dataLength ; cnt++)
+ DBGP(" %02x",requestData->data[cnt]);
+ DBGP("\n");
+ }
+
+ rv = wait_for_IBF_clear();
+ clear_OBF();
+ if (rv != 0) return LAN_ERR_SEND_FAIL;
+ _OUTB(WR_START,COMMAND_REG);
+ rv = wait_for_IBF_clear();
+ if (get_write_state() != 0) return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+ if (rv != 0) return LAN_ERR_SEND_FAIL;
+
+ _OUTB((requestData->netFn << 2),DATA_OUT_REG);
+ rv = wait_for_IBF_clear();
+ if (get_write_state() != 0) return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+
+ if (requestData->dataLength == 0)
+ {
+ _OUTB(WR_END,COMMAND_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+
+ _OUTB(requestData->cmdType,DATA_OUT_REG);
+ }
+ else
+ {
+
+ _OUTB(requestData->cmdType,DATA_OUT_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+
+ for(length = 0;length < requestData->dataLength-1;length++)
+ {
+ _OUTB(requestData->data[length],DATA_OUT_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+ }
+
+ _OUTB(WR_END,COMMAND_REG);
+ wait_for_IBF_clear();
+ if (get_write_state() != 0)
+ return LAN_ERR_SEND_FAIL;
+ clear_OBF();
+
+ _OUTB(requestData->data[length],DATA_OUT_REG);
+ }
+
+/********************************** WRITE PHASE OVER ***********************/
+
+#ifdef TEST_ERROR
+ if (fdebugdir == 5) { /*introduce an error test case*/
+ printf("Aborting after KCS write, before read\n");
+ return(rv);
+ }
+#endif
+// length = 0;
+// usleep(100000);
+/********************************** READ PHASE START ***********************/
+ rxbuf_len = *respDataLen;
+ *respDataLen = 0;
+
+ while(*respDataLen <= IPMI_RSPBUF_SIZE)
+ {
+ wait_for_IBF_clear();
+ if (get_read_state() != 0)
+ {
+ if (get_idle_state() != 0) {
+ DBGP2("not idle in rx_data (%02x)\n",_INB(STATUS_REG));
+ // clear_lock_dir();
+ return LAN_ERR_RECV_FAIL;
+ } else {
+ rv = wait_for_OBF_set();
+ if (rv != 0) { return LAN_ERR_RECV_FAIL; }
+ dummy = _INB(DATA_IN_REG);
+ /* done, copy the data, if valid */
+ if (*respDataLen < 3) { /* data not valid, no cc */
+ (*respDataLen) = 0;
+ *compCode = 0xCA; /*cannot return #bytes*/
+ // clear_lock_dir();
+ return LAN_ERR_TIMEOUT;
+ } else { /*valid*/
+ requestData->netFn = rx_data[0];
+ requestData->cmdType = rx_data[1];
+ *compCode = rx_data[2];
+ (*respDataLen) -= 3;
+ for (length=0;length < *respDataLen;length++)
+ resp_data[length] = rx_data[length+3];
+ }
+ DBGP2("ipmidir: peak_loops = %d\n",peak_loops);
+ return ACCESS_OK;
+ }
+ } else {
+ rv = wait_for_OBF_set();
+ if (rv != 0) { return LAN_ERR_RECV_FAIL; }
+ rx_data[*respDataLen] = _INB(DATA_IN_REG);
+ DBGP2("rx_data[%d] is 0x%x\n",*respDataLen,rx_data[*respDataLen]);
+ _OUTB(READ_BYTE,DATA_IN_REG);
+ (*respDataLen)++;
+ }
+ if (*respDataLen > rxbuf_len) {
+ DBGP("ipmidir: rx buffer overrun, size = %d\n",rxbuf_len);
+ break; /*stop if user buffer max*/
+ }
+ } /*end while*/
+ return ACCESS_OK;
+} /* end SendTimedImbpRequest_kcs */
+
+
+static int ProcessTimedMessage(BMC_MESSAGE *p_reqMsg, BMC_MESSAGE *p_respMsg, const UINT32 timeout)
+{
+ int status = STATUS_OK;
+ IMBPREQUESTDATA requestData = {0};
+ int respDataLen = IPMI_RSPBUF_SIZE;
+ UINT8 compCode = 0;
+ // static UINT8 sendSeq = 1;
+ // UINT8 buff[DATA_BUF_SIZE] = {0};
+ ACCESN_STATUS accessn;
+ int i, j;
+
+ j = p_reqMsg->Len;
+ if (j > IPMI_REQBUF_SIZE) return(LAN_ERR_BADLENGTH);
+ // Initialize Response Message Data
+ for(i = 0; i < IPMI_RSPBUF_SIZE; i++)
+ {
+ p_respMsg->Data[i] = 0;
+ }
+
+ /* show the request */
+ DBGP("ipmidir Cmd=%02x NetFn=%02x Lun=%02x Sa=%02x Data(%d): ",
+ p_reqMsg->Cmd, p_reqMsg->NetFn,
+ p_reqMsg->LUN, p_reqMsg->DevAdd, j);
+ for (i=0; i<j; i++) DBGP("%02x ",p_reqMsg->Data[i]);
+ DBGP("\n");
+
+ j = _IOPL(3);
+ if (j != 0) {
+ DBGP("ipmi_direct: iopl errno = %d\n",errno);
+ return(errno);
+ }
+ // Initializes Request Message
+
+ // Call into IPMI
+ if (p_reqMsg->DevAdd == 0x20) {
+ requestData.cmdType = p_reqMsg->Cmd;
+ requestData.rsSa = 0x20;
+ requestData.busType = 0;
+ requestData.netFn = p_reqMsg->NetFn;
+ requestData.rsLun = p_reqMsg->LUN;
+ requestData.data = p_reqMsg->Data;
+ requestData.dataLength = (int)p_reqMsg->Len;
+
+ if (g_DriverType == DRV_KCS) /*KCS*/
+ accessn = SendTimedImbpRequest_kcs(&requestData, timeout,
+ p_respMsg->Data, &respDataLen, &compCode);
+ else if (g_DriverType == DRV_SMB) /*SMBus*/
+ accessn = SendTimedImbpRequest_ssif(&requestData, timeout,
+ p_respMsg->Data, &respDataLen, &compCode);
+ else { /* should never happen */
+ printf("ipmi_direct: g_DriverType invalid [%d]\n",g_DriverType);
+ return(ERR_NO_DRV);
+ }
+
+ status = accessn;
+ // Return Response Message
+ p_respMsg->DevAdd = p_reqMsg->DevAdd;
+ p_respMsg->NetFn = requestData.netFn;
+ p_respMsg->LUN = p_reqMsg->LUN;
+ p_respMsg->Cmd = requestData.cmdType;
+ p_respMsg->CompCode = compCode;
+ p_respMsg->Len = respDataLen;
+ } else { /*DevAdd != 0x20*/
+ status = ProcessSendMessage(p_reqMsg, p_respMsg, p_reqMsg->Bus,
+ p_reqMsg->DevAdd,10000);
+ DBGP2("ProcessSendMessage(cmd=%02x,rs,sa=%02x,10000) = %d\n",
+ p_reqMsg->Cmd,p_reqMsg->DevAdd,status);
+ }
+
+ /* validate the response data length */
+ if (p_respMsg->Len > IPMI_RSPBUF_SIZE) p_respMsg->Len = IPMI_RSPBUF_SIZE;
+ /* show the response */
+ j = p_respMsg->Len;
+ DBGP("ipmidir Resp(%x,%x): status=%d cc=%02x, Data(%d): ",
+ (p_respMsg->NetFn >> 2), p_respMsg->Cmd,
+ status,p_respMsg->CompCode, j);
+ if (status == 0)
+ for (i=0; i<j; i++) DBGP("%02x ",p_respMsg->Data[i]);
+ DBGP("\n");
+
+ return status;
+}
+
+/*
+ * ImbInit_dir
+ * Uses SMBIOS to determine the driver type and base address.
+ * It also checks the status register if KCS.
+ */
+int ImbInit_dir(void)
+{
+ uchar v = 0xff;
+
+ /* Read SMBIOS to get IPMI struct */
+ DBGP2("ImbInit: BMC_base = 0x%04x\n",BMC_base);
+ if (BMC_base == 0) { /*use get_IpmiStruct routine from mem_if.c */
+ uchar iftype, iver, sa, inc;
+ int mybase, status;
+ char *ifstr;
+ status = get_IpmiStruct(&iftype,&iver,&sa,&mybase,&inc);
+ if (status == 0) {
+ if (iftype == 0x04) {
+ g_DriverType = DRV_SMB;
+ ifstr = "SSIF";
+ mBMC_baseAddr = mybase;
+ } else /*0x01==KCS*/ {
+ g_DriverType = DRV_KCS;
+ ifstr = "KCS";
+ if (sa == BMC_SA && mybase != 0) { /*valid*/
+ kcsBaseAddress = mybase;
+ kcs_inc = inc;
+ }
+ }
+ BMC_base = mybase;
+ DBGP("SMBIOS IPMI Record found: type=%s sa=%02x base=0x%04x spacing=%d\n",
+ ifstr, sa, mybase, inc);
+ }
+ }
+
+ /* Use KCS here. There are no known SMBus implementations on 64-bit */
+ if (BMC_base == 0) {
+ DBGP("No IPMI Data Structure Found in SMBIOS Table,\n");
+ g_DriverType = DRV_KCS;
+ BMC_base = kcsBaseAddress;
+ DBGP("Continuing with KCS on Default Port 0x%04x\n",kcsBaseAddress);
+ }
+#if defined(BSD) || defined(MACOS)
+ iofd = open("/dev/io",O_RDWR);
+ if (iofd < 0) {
+ printf("Cannot open /dev/io...Exiting\n");
+ return ERR_NO_DRV;
+ }
+#endif
+ if (g_DriverType == DRV_SMB) {
+ /* Perhaps add controller type in ipmi_if.txt (?)*/
+ /* Intel SSIF: 0x0540=SJR, 0x0400=STP */
+ if (mBMC_baseAddr == 0x540 || mBMC_baseAddr == 0x400)
+ SMBChar.Controller = INTEL_SMBC;
+ else /*else try ServerWorks*/
+ SMBChar.Controller = SW_SMBC;
+ SMBChar.baseAddr = mBMC_baseAddr;
+ DBGP("BMC SSIF/SMBus Interface at i2c=%02x base=0x%04x\n",
+ mBMCADDR,mBMC_baseAddr);
+ }
+ if (g_DriverType == DRV_KCS) {
+ v = _IOPL(3);
+ v = _INB(STATUS_REG);
+ DBGP2("inb(%x) returned %02x\n",STATUS_REG,v);
+ if (v == 0xff) {
+ printf("No Response from BMC...Exiting\n");
+ return ERR_NO_DRV;
+ }
+ DBGP("BMC KCS Initialized at 0x%04x\n",kcsBaseAddress);
+ }
+ return STATUS_OK;
+}
+
+int
+SendTimedImbpRequest_ssif ( IMBPREQUESTDATA *requestData,
+ unsigned int timeout, UINT8 *resp_data, int *respDataLen,
+ unsigned char *compCode)
+{ /* SendTimedImb for SMBus */
+ unsigned char rq[IPMI_REQBUF_SIZE+35] = {0,}; /*SIZE + MAX_ISA_LENGTH=35*/
+ unsigned char rp[IPMI_RSPBUF_SIZE+35] = {0,}; /*SIZE + MAX_ISA_LENGTH=35*/
+ unsigned int i, rpl=0;
+ int status;
+ int respMax, rlen;
+
+ i = _IOPL(3);
+ rq[0] = ((requestData->netFn << 2) | (requestData->rsLun & 0x03));
+ rq[1] = requestData->cmdType;
+ if (sizeof(rq) < (requestData->dataLength + 2)) return(LAN_ERR_BADLENGTH);
+ for (i=0;i<=(unsigned int)requestData->dataLength;i++)
+ rq[i+2] = requestData->data[i];
+
+ respMax = *respDataLen;
+ if (respMax == 0) respMax = IPMI_RSPBUF_SIZE;
+ status = SendmBmcRequest(rq,requestData->dataLength+2,rp,&rpl,0);
+ if (status == IMB_SEND_ERROR) {
+ *respDataLen = 0;
+ return LAN_ERR_SEND_FAIL;
+ }
+
+ if (rpl < 3) {
+ *respDataLen = 0;
+ *compCode = 0xCA; /*cannot return #bytes*/
+ return LAN_ERR_TIMEOUT;
+ } else {
+ rlen = rpl-3; /* Chop off netfn/LUN , compcode, command */
+ if (rlen > respMax) rlen = respMax;
+ *respDataLen = rlen;
+ *compCode = rp[2];
+ for (i = 0; i < rlen; i++) resp_data[i] = rp[i+3];
+ }
+ return ACCESS_OK;
+}
+
+int SendmBmcRequest (
+ unsigned char* request,
+ UINT32 reqLength,
+ unsigned char* response,
+ UINT32 * respLength,
+ UINT32 ipmiOldFlag
+ )
+{
+ int retries = 5;
+
+ /* Send Request - Retry 5 times at most */
+ do{
+ if (SendRequest(request, reqLength, &SMBChar) == 0)
+ break;
+ } while (0 < retries--);
+
+ if (retries <= 0) { return IMB_SEND_ERROR; }
+
+ /* Read Response - Retry 5 times at most */
+ retries = 5;
+ do{
+ if ((*respLength = ReadResponse(response, &SMBChar))!=(-1)) {
+ break; // Success
+ }
+ }while (0 < retries--);
+
+ if (retries <= 0) { return IMB_SEND_ERROR; }
+
+ return IMB_SUCCESS;
+}
+
+static int
+SendRequest(unsigned char* req, int length,
+ struct SMBCharStruct* smbChar)
+{
+ UINT8 data = 0;
+ // unsigned char* msgBuf = req;
+ int i;
+ UINT8 status = 0;
+
+ // Delay of 50 ms before request is sent
+ usleep(100000);
+
+ // Handle Intel & ServerWorks Chipsets
+ // Clear all status bits, Host Status Register
+ switch (smbChar->Controller) {
+ // Intel Status Register
+ case INTEL_SMBC:
+ status = ICH_HST_STA_ALL_ERRS|ICH_HST_STA_INTR|ICH_HST_STA_BYTE_DONE_STS;
+ break;
+ // ServerWorks Status Register
+ case SW_SMBC:
+ status = ICH_HST_STA_ALL_ERRS|ICH_HST_STA_INTR;
+ break;
+ }// End of Switch
+
+ // Status Register
+ WritePortUchar( (((smbChar->baseAddr))+ICH_HST_STA), status);
+
+ // Block protocol, Host Control Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), (UINT8)(ICH_HST_CNT_SMB_CMD_BLOCK));
+ // IPMI command, Host Command Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CMD), (UINT8)(0x02));
+ // Slave address, Host Address Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_XMIT_SLVA), (UINT8)(mBMCADDR));
+ // Block length, Host DATA0 Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_D0), (UINT8)(length));
+ // Initialize timer
+
+ switch (smbChar->Controller) {
+ // Handle Intel Chipset
+ case INTEL_SMBC:
+ // the first byte
+ WritePortUchar(((smbChar->baseAddr)+ICH_BLOCK_DB), *(UINT8 *)((UINT8 *)req ));
+ // Block protocol and Start, Host Control Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), ICH_HST_CNT_START | ICH_HST_CNT_SMB_CMD_BLOCK);
+ // Send byte by byte
+ for ( i = 1; i < length; i++ ) {
+ // OsSetTimer(&SendReqTimer); * Start timer *
+ do {
+ // Read host status register
+ ReadPortUchar((smbChar->baseAddr+ICH_HST_STA), &data);
+ // if (OsTimerTimedout(&SendReqTimer)) return -1;
+ // Any error or Interrupt bit or byte done bit set ?
+ } while ((data & status) == 0);
+ // OsCancelTimer(&SendReqTimer); * End Timer *
+ // Check for byte completion in block transfer
+ if ((data & ICH_HST_STA_BYTE_DONE_STS) != ICH_HST_STA_BYTE_DONE_STS)
+ break;
+ // Write next byte
+ WritePortUchar(((smbChar->baseAddr)+ICH_BLOCK_DB), *(UINT8 *)((UINT8 *)req + i));
+ // Clear status bits, Host Status Register
+ WritePortUchar((smbChar->baseAddr), (UINT8)(data & status));
+ } // End of for - Send byte by byte
+ break; // End of Intel Chipset Handling
+ // Handle ServerWorks Chipset
+ case SW_SMBC:
+ // Block length, Host DATA1 Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_D1), (UINT8)(length));
+ // Reset block inex
+ ReadPortUchar(((smbChar->baseAddr)+ICH_HST_CNT), &data);
+ // Put all bytes of the message to Block Data Register
+ for ( i = 0; i < length; i++ )
+ WritePortUchar(((smbChar->baseAddr)+ICH_BLOCK_DB), *(UINT8 *)((UINT8 *)req + i));
+ // Block protocol and Start, Host Control Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), ICH_HST_CNT_START | ICH_HST_CNT_SMB_CMD_BLOCK);
+ // OsSetTimer(&SendReqTimer); * Start timer *
+ do {
+ // Read host status register
+ ReadPortUchar((smbChar->baseAddr+ICH_HST_STA), &data);
+ // if (OsTimerTimedout(&SendReqTimer)) return -1;
+ } while ((data & status) == 0); // Any error or Interrupt bit set ?
+ // OsCancelTimer(&SendReqTimer); * End Timer *
+ break; // End of ServerWorks Chipset Handling
+ } // End of Switch Controller
+
+ // Clear status bits, Host Status Register
+ WritePortUchar((smbChar->baseAddr), (UINT8)(data & status));
+ if (data & ICH_HST_STA_ALL_ERRS) return -1;
+
+ // Success
+ return 0;
+}
+
+static int
+ReadResponse( unsigned char* resp,
+ struct SMBCharStruct * smbChar)
+{
+ UINT8 data, dummy, length, status = 0;
+ UINT8 * msgBuf = (UINT8 *) resp;
+ int i; //, timeout =0;
+ // os_timer_t SendReqTimer;
+
+ // Delay current thread - time to delay in uSecs
+ // 100 msec = 100000 microsec
+ usleep(100000);
+
+ // Handle Intel & ServerWorks Chipsets
+ switch (smbChar->Controller) {
+ case INTEL_SMBC:
+ status = ICH_HST_STA_ALL_ERRS|ICH_HST_STA_INTR|ICH_HST_STA_BYTE_DONE_STS;
+ break;
+ case SW_SMBC:
+ status = ICH_HST_STA_ALL_ERRS|ICH_HST_STA_INTR;
+ break;
+ } // End of Switch
+
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_STA), status);
+ // Block protocol, Host Control Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), ICH_HST_CNT_SMB_CMD_BLOCK);
+ // Slave address, Host Address Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_XMIT_SLVA), (UINT8)(mBMCADDR |ICH_XMIT_SLVA_READ));
+ // IPMI command, Host Command Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CMD), 0x03);
+ // Reset block index
+ ReadPortUchar(((smbChar->baseAddr)+ICH_HST_CNT), &data);
+ // Block protocol and Start, Host Control Register
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), ICH_HST_CNT_START | ICH_HST_CNT_SMB_CMD_BLOCK);
+
+ // Initialize timer
+ do {
+ // Read host status register
+ ReadPortUchar((smbChar->baseAddr+ICH_HST_STA), &data);
+ } while ((data & status) == 0); // Any error or Interrupt bit set ?
+ // End Timer
+
+ // Clear status bits, Host Status Register
+ WritePortUchar((smbChar->baseAddr), (UINT8)(data & status));
+
+ if (data & ICH_HST_STA_ALL_ERRS) return -1;
+
+ // Block length, Host DATA0 Register
+ ReadPortUchar(((smbChar->baseAddr)+ICH_D0), &length);
+ /* check recv length > MAX (35) */
+ if (length > MAX_ISA_LENGTH) length = MAX_ISA_LENGTH;
+ switch (smbChar->Controller) {
+ case INTEL_SMBC:
+ // Read the first byte
+ ReadPortUchar((smbChar->baseAddr+ICH_BLOCK_DB), &(msgBuf[0]));
+ // Put all bytes of the message to Block Data Register
+ for ( i = 1; i < length; i++ ) {
+ if (i == (length-1)) {
+ // Set Last Byte bit
+ ReadPortUchar(((smbChar->baseAddr)+ICH_HST_CNT),&dummy);
+ WritePortUchar(((smbChar->baseAddr)+ICH_HST_CNT), (UINT8)(dummy | ICH_HST_CNT_LAST_BYTE));
+ }
+ // Clear status bits, Host Status Register
+ WritePortUchar((smbChar->baseAddr), (UINT8)(data & status));
+
+ do {
+ // Read host status register
+ ReadPortUchar((smbChar->baseAddr+ICH_HST_STA), &data);
+ } while ((data & status) == 0); // Any error or Interrupt bit set ?
+
+ if (data & ICH_HST_STA_ALL_ERRS) return -1;
+ ReadPortUchar((smbChar->baseAddr+ICH_BLOCK_DB), &(msgBuf[i]));
+ }
+ break;
+ case SW_SMBC:
+ // Put all bytes of the message to Block Data Register
+ for ( i = 0; i < length; i++ ) {
+ ReadPortUchar((smbChar->baseAddr+ICH_BLOCK_DB), &(msgBuf[i]));
+ }
+ break;
+ } /* end of switch */
+
+ if (data & ICH_HST_STA_ALL_ERRS) return -1;
+
+ return length;
+}
+#endif
+
+/* end ipmidir.c */
diff --git a/util/ipmidir.h b/util/ipmidir.h
new file mode 100644
index 0000000..079c6b6
--- /dev/null
+++ b/util/ipmidir.h
@@ -0,0 +1,301 @@
+/***********************************************
+ * ipmidir.h
+ *
+ * Definitions and data structures for direct
+ * user-space IPMI I/Os.
+ *
+ ***********************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifndef IPMIDIR_H_
+#define IPMIDIR_H_
+
+
+#define SMB_DATA_ADDRESS = 0x000
+
+//
+// State bits based on S1 & S0 below
+//
+#define ISA_STATE_MASK 0xC0
+#define ISA_IDLE_STATE 0x00
+#define ISA_READ_STATE 0x40
+#define ISA_WRITE_STATE 0x80
+#define ISA_ERROR_STATE 0xC0
+//
+// Status Register Bits
+//
+#define ISA_S1_FLAG 0x80
+#define ISA_S0_FLAG 0x40
+// RESERVED 0x20
+// RESERVED 0x10
+#define ISA_CD_FLAG 0x08
+#define ISA_SMS_MSG_FLAG 0x04
+#define ISA_IBF_FLAG 0x02
+#define ISA_OBF_FLAG 0x01
+//
+// ISA interface register access defines
+//
+
+#define BMC_SLAVE_ADDR 0x20
+#define MAX_ISA_LENGTH 35
+
+#define ISA_SMS_TIMEOUT 5000 // in miliseconds - 1 second
+#define ISA_SMM_TIMEOUT 100 // in microseconds
+//
+// mBMC Address
+//
+#define IMB_SEND_ERROR 1
+#define IMB_SUCCESS 0
+
+// typedef unsigned int DWORD;
+// typedef unsigned char BYTE;
+// typedef unsigned char UCHAR; * defined in imb_api.h *
+// typedef unsigned long ULONG; * defined in imb_api.h *
+// typedef unsigned int UINT32;
+typedef unsigned short UINT16;
+typedef unsigned char UINT8;
+
+struct SMBCharStruct
+{
+unsigned int Controller;
+unsigned int baseAddr;
+};
+
+/*---------------------------------------------------------*
+ * PCI defines for SMBus
+ *---------------------------------------------------------*/
+
+// PCI related definitions
+#define PCI_CONFIG_ADDRESS 0xCF8
+#define PCI_CONFIG_DATA 0xCFC
+
+// PCI unique identifiers
+#define ID_8111 0x746A1022
+#define ID_81801 0x24128086
+#define ID_81801AA 0x24138086
+#define ID_81801AB 0x24238086
+#define ID_82801BA 0x24438086
+#define ID_82801CA 0x24838086
+#define ID_ICH4 0x24C38086
+#define ID_ICH5 0x24D38086
+#define ID_ICH6 0x266A8086 //srini added ICH6 support
+#define ID_CSB5 0x02011166
+#define ID_CSB6 0x02031166
+#define ID_OSB4 0x02001166
+#define Hance_Rapids 0x25A48086 //lester 0627
+
+// PCI configuration registers
+#define ICH_SMB_BASE 0x20 // base address register
+#define ICH_HOSTC 0x40 // host config register
+#define ICH_HOSTC_I2C_EN 0x04 // enable i2c mode
+#define ICH_HOSTC_SMB_SMI_EN 0x02 // SMI# instead of irq
+#define ICH_HOSTC_HST_EN 0x01 // enable host cntrlr
+#define AMD_SMB_BASE_2 0x10 // base address register of SMBus 2.0
+#define AMD_SMB_BASE_2_EN 0x04 // SMBus 2.0 space enable
+#define AMD_SMB_BASE_1 0x58 // base address register of SMBus 1.0
+#define AMD_SMB_BASE_1_EN 0x41 // SMBus 1.0 space enable
+#define AMD_SMBUS_1 0xE0 // SMBus 1.0 registers
+
+// I/O registers
+#define ICH_HST_STA 0x00 // host status
+#define ICH_HST_STA_BYTE_DONE_STS 0x80 // byte send/rec'd
+#define ICH_HST_STA_INUSE_STS 0x40 // device access mutex
+#define ICH_HST_STA_SMBALERT_STS 0x20 // SMBALERT# signal
+#define ICH_HST_STA_FAILED 0x10 // failed bus transaction
+#define ICH_HST_STA_BUS_ERR 0x08 // transaction collision
+#define ICH_HST_STA_DEV_ERR 0x04 // misc. smb device error
+#define ICH_HST_STA_ALL_ERRS (ICH_HST_STA_FAILED|ICH_HST_STA_BUS_ERR|ICH_HST_STA_DEV_ERR)
+#define ICH_HST_STA_INTR 0x02 // command completed ok
+#define ICH_HST_STA_HOST_BUSY 0x01 // command is running
+#define ICH_HST_CNT 0x02 // host control
+#define ICH_HST_CNT_START 0x40 // start command
+#define ICH_HST_CNT_LAST_BYTE 0x20 // indicate last byte
+#define ICH_HST_CNT_SMB_CMD_QUICK 0x00 // command: quick
+#define ICH_HST_CNT_SMB_CMD_BYTE 0x04 // command: byte
+#define ICH_HST_CNT_SMB_CMD_BYTE_DATA 0x08 // command: byte data
+#define ICH_HST_CNT_SMB_CMD_WORD_DATA 0x0c // command: word data
+#define ICH_HST_CNT_SMB_CMD_PROC_CALL 0x10 // command: process call
+#define ICH_HST_CNT_SMB_CMD_BLOCK 0x14 // command: block
+#define ICH_HST_CNT_SMB_CMD_I2C_READ 0x18 // command: i2c read
+#define ICH_HST_CNT_KILL 0x02 // kill current transaction
+#define ICH_HST_CNT_INTREN 0x01 // enable interrupt
+#define ICH_HST_CMD 0x03 // host command
+#define ICH_XMIT_SLVA 0x04 // transmit slave address
+#define ICH_XMIT_SLVA_READ 0x01 // direction: read
+#define ICH_XMIT_SLVA_WRITE 0x00 // direction: write
+#define ICH_D0 0x05 // host data 0
+#define ICH_D1 0x06 // host data 1
+#define ICH_BLOCK_DB 0x07 // block data byte
+
+// SMBus 1.0
+#define AMD_SMB_1_STATUS 0x00 // SMBus global status
+#define AMD_SMB_1_STATUS_SMBS_BSY (1<11)
+#define AMD_SMB_1_STATUS_SMBA_STS (1<10)
+#define AMD_SMB_1_STATUS_HSLV_STS (1<9)
+#define AMD_SMB_1_STATUS_SNP_STS (1<8)
+#define AMD_SMB_1_STATUS_TO_STS (1<5)
+#define AMD_SMB_1_STATUS_HCYC_STS (1<4)
+#define AMD_SMB_1_STATUS_HST_BSY (1<3)
+#define AMD_SMB_1_STATUS_PERR_STS (1<2)
+#define AMD_SMB_1_STATUS_COL_STS (1<1)
+#define AMD_SMB_1_STATUS_ABRT_STS (1<0)
+#define AMD_SMB_1_STATUS_ALL_ERRS AMD_SMB_1_STATUS_TO_STS|AMD_SMB_1_STATUS_HST_BSY|AMD_SMB_1_STATUS_PERR_STS|AMD_SMB_1_STATUS_COL_STS
+#define AMD_SMB_1_CTL 0x02 // SMBus global control
+#define AMD_SMB_1_CTL_SMBA_EN (1<<10)
+#define AMD_SMB_1_CTL_HSLV_EN (1<<9)
+#define AMD_SMB_1_CTL_SNP_EN (1<<8)
+#define AMD_SMB_1_CTL_ABORT (1<<5)
+#define AMD_SMB_HCYC_EN (1<<4)
+#define AMD_SMB_HOSTSTS (1<<3)
+#define AMD_SMB_CYCTYPE_QC 0x0 // quick command
+#define AMD_SMB_CYCTYPE_RSB 0x1 // receive/send byte
+#define AMD_SMB_CYCTYPE_RWB 0x2 // read/write byte
+#define AMD_SMB_CYCTYPE_RWW 0x3 // read/write word
+#define AMD_SMB_CYCTYPE_PC 0x4 // process call
+#define AMD_SMB_CYCTYPE_RWBL 0x5 // read/write block
+#define AMD_SMB_1_ADDR 0x04 // SMBus host address
+#define AMD_SMB_1_ADDR_READCYC (1<<0)
+#define AMD_SMB_1_DATA 0x06 // SMBus host data
+#define AMD_SMB_1_CMD 0x08 // SMBus host command
+#define AMD_SMB_1_BLOCK_DATA 0x09 // SMBus block data FIFO access port
+
+// For SMBus 2.0, see ACPI 2.0 chapter 13 PCI interface definitions
+
+#define AMD_SMB_BLOCK_WRITE 0xa
+#define AMD_SMB_BLOCK_READ 0xb
+
+// AMD PCI control registers definitions.
+#define AMD_PCI_MISC 0x48
+#define AMD_PCI_MISC_SCI 0x04
+#define AMD_PCI_MISC_INT 0x02
+#define AMD_PCI_MISC_SPEEDUP 0x01
+
+
+// SMBus Controllers
+#define INTEL_SMBC 1 // Intel
+#define SW_SMBC 2 // ServerWorks
+#define VIA_SMBC 3 // VIA
+#define AMD_SMBC 4 // AMD
+
+/************************************************
+ * bmc.h
+ ************************************************/
+
+#define STATUS_OK 0
+#define BMC_MAX_RETRIES 3 // Max number of retries if BMC is busy
+#define DATA_BUF_SIZE 255 // Max data buffer, see IPMI_REQBUF_SIZE
+#define GETMSGTIMEOUT 5 // Time out in sec for send/get message command
+
+// Product IDs of systems with PC87431 chips (have both Sahalee and mBMC)
+#define ID_PC87431_M 0x4311
+#define ID_PC87431_S 0x4312
+#define ID_PC87431_C 0x4315
+
+// Available BMC chips that are supported by this library.
+#define BMC_UNKNOWN 0
+#define BMC_SAHALEE 1 // Intel Sahalee BMC
+#define BMC_MBMC_87431M 2 // mBMC, chip = PC87431M
+#define BMC_MBMC_87431S 3 // mBMC, chip = PC87431S
+#define BMC_MBMC_87431C 4 // mBMC, chip = PC87431C
+#define BMC_BOTH_SAHALEE_MBMC 5
+#define BMC_DUAL_NW 6 // currently not detected
+// #define BMC_AMT10 7
+
+// Available IPMI versions. There may be full and partial IPMI implementations.
+// To figure out what implementation is supported, look at the BMC_TYPE.
+#define IPMI_VERSION_UNKNOWN 0
+#define IPMI_VERSION_1_5 1
+#define IPMI_VERSION_2_0 2
+#define IPMI_VERSION_1_0 3
+
+//*****************************************************************************
+// Message struct for sending and receiving messages from the BMC. Requests
+// must have a DevAdd, NetFn, LUN, Cmd, Data, and Len. The response will have
+// all fields filled in. In both cases 'Len' is the length of the data buffer.
+typedef struct {
+ UINT8 Bus;
+ UINT8 DevAdd;
+ UINT8 NetFn;
+ UINT8 LUN;
+ UINT8 Cmd;
+ UINT8 Data[DATA_BUF_SIZE];
+ UINT32 Len;
+ UINT8 CompCode;
+} BMC_MESSAGE;
+
+/* Internal error codes from BMC or IPMI driver:
+ * ERR_NO_DRV is defined in ipmicmd.h, and the other
+ * values below are not used.
+ */
+#define ER_NO_BMC_IF -400 // could not find the BMC interface
+#define ERCANTLOCATEIPMIHANDLE -500 // Unable to locate IPMI handle
+#define ERCANTALLOCMEMORYFORIPMI -501 // Unable to allocate memory for IPMI services
+#define ERCANTLOADIPMIDRIVER -502 // Unable to dynamically load IPMI driver
+#define ERSENDINGIPMIMESSAGE -503 // Error sending request to BMC
+#define ERGETTINGIPMIMESSAGE -504 // Error getting request from BMC
+#define ERCMDRETURNEDDONTMATCH -505 // Returned command # doesn't match what was sent
+#define ERLUNRETURNEDDONTMATCH -506 // Returned LUN # doesn't match what was sent
+#define ERCOMPCODEERR -507 // Comp code is not COMPCODE_NORMAL
+#define ERSEQNUMBER -508 // Sequence number error.
+#define ERCANTCLEARMSGFLAGS -509 // Can not clear message flags
+#define ERINVALIDRESPONSELEN -510 // Response length not as expected.
+#define ER_NO_PCI_BIOS -511 // No PCI BIOS record exist
+#define ER_SMBUSBUSERROR -512
+#define ER_SMBUSTIMEOUT -513
+#define ER_SMBUSOWNERSHIP -514
+#define ER_SMBUSDEVERROR -515
+#define ER_NOTKCS -516 // Not KCS, probably SMBus
+
+// Device Addresses
+#define BMC_ADDR 0x20 // Baseboard Management Controller
+#define HSC0_ADDR 0xC0 // Hot Swap Controller 0
+#define HSC1_ADDR 0xC2 // Hot Swap Controller 1
+#define PSC_ADDR 0xC8 // Power Supply Controller
+#define CBC_ADDR 0x28 // Chassis Bridge Controller
+#define LCP_ADDR 0x22 // LCP(Local Control Panel) Address
+#define MBMC_ADDR 0x84 // MINI BMC address
+
+#define SMBUS_SLAVE_ADDRESS 0x00
+#define ID_VITESSE 0x01 // for HSC
+#define ID_GEM 0x02 // for HSC
+#define ISA_BUS 0xFF // ISA Bus address
+
+#define BMC_DEV_ADDR 0x20 // BMC Device Addr for Get Device ID
+// #define BMC_LUN 0x00 // BMC commands & event request messages
+#define OEM_LUN1 0x01 // OEM LUN 1
+#define SMS_MSG_LUN 0x02 // SMS message LUN
+#define OEM_LUN2 0x03 // OEM LUN 2
+
+#define NETFN_APP 0x06
+#define GETMESSAGE_CMD 0x33 // IPMI Get Message command
+#define SENDMESSAGE_CMD 0x34 // IPMI Send Message command
+
+#endif // IPMIDIR_H_
diff --git a/util/ipmilan.c b/util/ipmilan.c
new file mode 100644
index 0000000..64b6425
--- /dev/null
+++ b/util/ipmilan.c
@@ -0,0 +1,2430 @@
+/*M*
+// PVCS:
+// $Workfile: ipmilan.c $
+// $Revision: 1.0 $
+// $Modtime: 2 Feb 2006 15:31:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the IPMI LAN interface natively.
+//
+// 02/02/06 ARC - created.
+// 05/16/06 ARC - more added.
+// 06/19/06 ARCress - fixed sequence numbers for 1.7.1
+// 08/08/06 ARCress - fix AUTHTYPE masks
+// 08/11/06 ARCress - added lan command retries
+// 10/17/06 ARCress - special case for no MsgAuth headers
+// 11/28/06 ARCress - added ipmi_cmd_ipmb routine
+// 05/08/07 ARCress - added 1.5 SOL data packet format to _send_lan_cmd,
+// not working yet.
+// 08/21/07 ARCress - handle Dell 1855 blades that return different authcode
+// 04/17/08 ARCress - check FD_ISSET in fd_wait
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2005-2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <io.h>
+#include <time.h>
+#include <signal.h>
+
+//#define HAVE_IPV6 1
+#ifdef HAVE_IPV6
+#include <winsock2.h>
+//#include <ws2tcpip.h>
+//#include <tpipv6.h>
+#else
+#include <winsock.h>
+#define MSG_WAITALL 0x100 /* Wait for a full request */
+#endif
+
+#define INET_ADDRSTRLEN 16
+#define MSG_NONE 0x000
+#define int32_t int
+#define u_int32_t unsigned int
+#define uint32 unsigned int
+#define uchar unsigned char
+#define RECV_MSG_FLAGS MSG_NONE
+typedef unsigned int socklen_t;
+
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#undef HAVE_LANPLUS
+
+#else /* Linux */
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <sys/time.h>
+#include <time.h>
+#include <signal.h>
+#define RECV_MSG_FLAGS MSG_WAITALL
+#endif
+#include "ipmicmd.h"
+#include "ipmilan.h"
+
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#else
+#if defined(MACOS)
+typedef unsigned int socklen_t;
+#endif
+#endif
+
+#if defined(LINUX)
+/* TODO: fixups in BSD/Solaris for ipv6 method */
+#define HAVE_IPV6 1
+#endif
+
+#if defined(CROSS_COMPILE)
+#undef HAVE_IPV6
+static struct hostent *xgethostbyname(const char *nstr)
+{
+ static struct hostent hptr;
+ if (StrIsIp(nstr)) { /* the string is an IP address */
+ hptr.h_name = (char *)nstr;
+ inet_aton(nstr,(struct in_addr *)&hptr.h_addr);
+ return(&hptr);
+ } else { /*the string is a node name */
+ return(NULL);
+ }
+}
+#else
+#define xgethostbyname gethostbyname
+#endif
+
+// #define TEST_LAN 1 /*++++TEST_LAN for DEBUG++++*/
+#if defined(ALLOW_GNU)
+#define MD2OK 1 /*use md2.h GPL code*/
+#else
+/* if here, ALLOW_GPL is not defined, check for lanplus libcrypto. */
+#if defined(HAVE_LANPLUS)
+#define MD2OK 1 /*use MD2 version from lanplus libcrypto */
+#endif
+/* if libcrypto does not have EVP_md2, then skip MD2. */
+#if defined(SKIP_MD2)
+#undef MD2OK
+#endif
+#endif
+
+/* Connection States:
+ * 0 = init, 1 = socket() complete, 2 = bind/gethost complete,
+ * 3 = ping sent, 4 = pong received, 5 = session activated.
+ * see also conn_state_str[] below */
+#define CONN_STATE_INIT 0
+#define CONN_STATE_SOCK 1
+#define CONN_STATE_BIND 2
+#define CONN_STATE_PING 3
+#define CONN_STATE_PONG 4
+#define CONN_STATE_ACTIVE 5
+
+#define SOL_DATA 0xFD /*SOL Data command*/
+#define SOL_MSG 0x10000000 /*SOL message type*/
+#define SOL_HLEN 14
+// SZGNODE == 80
+#define SZ_CMD_HDR 4 /*cmd, netfn/lun, sa*/
+#define SWID_REMOTE 0x81
+#define SWID_SMSOS 0x41
+
+#pragma pack(1)
+typedef struct { /*first 30 bytes conform to IPMI header format*/
+ uchar rmcp_ver;
+ uchar rmcp_res;
+ uchar rmcp_seq;
+ uchar rmcp_type;
+ uchar auth_type;
+ uint32 seq_num; /*outgoing seq*/
+ uint32 sess_id;
+ uchar auth_code[16];
+ uchar msg_len; /* size here = 30 bytes = RQ_HDR_LEN */
+ uchar swid; /* usu SWID_REMOTE. From here down, order is changeable */
+ uchar swseq; /* outgoing swseq */
+ uchar swlun;
+ uchar priv_level;
+ uint32 iseq_num; /*incoming seq */
+ uchar bmc_addr; /*usu BMC_SA*/
+ uchar target_addr;
+ uchar target_chan;
+ uchar target_lun;
+ uchar target_cmd;
+ uchar target_netfn;
+ uchar transit_addr;
+ uchar transit_chan;
+ uchar bridge_level;
+ uchar password[16];
+ uchar challenge[16];
+ } IPMI_HDR;
+#pragma pack()
+
+typedef struct {
+ int type;
+ int len;
+ char *data;
+ } SOL_RSP_PKT;
+
+/* extern void atoip(uchar *array,char *instr); *subs.c*/
+extern FILE *open_log(char *mname); /*ipmicmd.c*/
+extern char * get_iana_str(int mfg); /*subs.c*/
+
+#define dbglog printf
+#define dbg_dump dump_buf
+extern FILE *fperr; /*defined in ipmicmd.c, usu stderr */
+extern FILE *fpdbg; /*defined in ipmicmd.c, usu stdout */
+extern int gshutdown; /* from ipmicmd.c */
+extern char gnodename[]; /* from ipmicmd.c */
+extern char *gnode; /* from ipmicmd.c */
+extern char *guser; /* from ipmicmd.c */
+extern char *gpswd; /* from ipmicmd.c */
+extern int fauth_type_set; /* from ipmicmd.c */
+extern int gauth_type; /* from ipmicmd.c */
+extern int gpriv_level; /* from ipmicmd.c */
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+
+static IPMI_HDR ipmi_hdr = { 0x06, 0, 0xFF, 0x07, 0x00, 0, 0,
+ /*auth_code*/{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, 0, /*msg_len*/
+ /*swid*/SWID_REMOTE, 1,0,0,0, BMC_SA,0,0,0,0,0,0,0,0 /*bridge_level*/
+ };
+// static IPMI_HDR *phdr;
+static uchar bmc_sa = BMC_SA; /*usu 0x20*/
+static uchar sms_swid = SWID_REMOTE; /*usu 0x81*/
+static int vend_id = 0;
+static int prod_id = 0;
+
+#if defined(DOS) || defined(EFI)
+int ipmi_open_lan(char *node, char *user, char *pswd, int fdebugcmd)
+{
+ printf("IPMI LAN is not supported under DOS.\n");
+ return(-1);
+}
+int ipmi_close_lan(char *node)
+{
+ printf("IPMI LAN is not supported under DOS.\n");
+ return(-1);
+}
+int ipmi_cmd_lan(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{
+ printf("IPMI LAN is not supported under DOS.\n");
+ return(-1);
+}
+int ipmi_cmdraw_lan(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ printf("IPMI LAN is not supported under DOS.\n");
+ return(-1);
+}
+int ipmicmd_lan(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ printf("IPMI LAN is not supported under DOS.\n");
+ return(-1);
+}
+#else
+/* All other OSs can support IPMI LAN */
+
+/*
+ * These variables pertain to ipmilan, for the node given at open time.
+ * The assumption here is that these are utilities, so no more than one
+ * node will be open at a given time.
+ * See also gnode, guser, gpswd in ipmicmd.c
+ */
+typedef struct {
+ int connect_state; /*=CONN_STATE_INIT*/
+ SockType sockfd;
+ int finsession;
+ uint32 session_id;
+ uint32 in_seq; /*=1*/
+ uint32 start_out_seq; /*=1*/
+ uchar fMsgAuth; /*0=AuthNone 1=PerMsgAuth 2=UserLevelAuth*/
+ uchar auth_type; /*=AUTHTYPE_INIT*/
+ } LAN_CONN; /*see also IPMI_HDR below*/
+ // static int connect_state = CONN_STATE_INIT;
+ // static int sockfd = 0;
+ // static int finsession = 0;
+ // static uint32 session_id = 0;
+ // static uint32 in_seq = 0x01; /* inbound sequence num */
+ // static uint32 start_out_seq = 0x01; /* initial outbound sequence num */
+ // static uchar fMsgAuth = 1;
+ static uchar auth_type = AUTHTYPE_INIT; /*initial value, not set*/
+ static char nodename[SZGNODE+1] = "";
+#if defined(AI_NUMERICSERV)
+static int my_ai_flags = AI_NUMERICSERV; /*0x0400 Dont use name resolution NEW*/
+// static int my_ai_flags = AI_NUMERICHOST; /*0x0004 Dont use name resolution*/
+#else
+#undef HAVE_IPV6
+#endif
+
+#ifdef HAVE_IPV6
+#define SOCKADDR_T struct sockaddr_storage
+#else
+#define SOCKADDR_T struct sockaddr_in
+static char _dest_ip[INET_ADDRSTRLEN+1];
+// static char _dest[MAXHOSTNAMELEN+1];
+#endif
+static SOCKADDR_T _srcaddr;
+static SOCKADDR_T _destaddr;
+static int _destaddr_len = 0;
+#ifdef TEST_LAN
+static int fdebuglan = 3;
+#else
+static int fdebuglan = 0;
+#endif
+static int fdoping = 0; /* =1 do ping first, set to 0 b/c no added value*/
+static int fdopoke1 = 0;
+static int fdopoke2 = 0;
+static int frequireping = 0; /*=1 if ping is required, =0 ignore ping error */
+static LAN_CONN conn = {CONN_STATE_INIT,0,0,0,1,1,1};
+static LAN_CONN *pconn = &conn;
+static char *authcode = NULL;
+static int authcode_len = 0;
+static int ping_timeout = 1; /* timeout: 1 sec */
+static int ipmi_timeout = 2; /* timeout: 10 sec -> 2 sec */
+static int ipmi_try = 4; /* retries: 4 */
+static uchar bridgePossible = 0;
+static char *conn_state_str[6] = {
+ "init state", "socket complete", "bind complete",
+ "ping sent", "pong received", "session activated" };
+int lasterr = 0;
+
+static uchar sol_op = 0x80; /* encrypted/not */
+static uchar sol_snd_seq = 0; /* valid if non-zero*/
+static uchar sol_rcv_seq = 0;
+static uchar sol_rcv_cnt = 0;
+static uchar sol_rcv_ctl = 0x00;
+// static uchar sol_offset = 0;
+static uchar sol_seed_cnt = 0x01; /* set after activate response */
+static char sol_Encryption = 0; /*for SOL 1.5*/
+static uint32 g_Seed[ 16 ]; /*for SOL 1.5*/
+static uchar g_Cipher[ 16 ][ 16 ]; /*SeedCount x CipherHash for SOL 1.5*/
+#define BUSY_MAX 10 /*for Dell FS12-TY Node Busy errors*/
+
+#ifdef WIN32
+int econnrefused = WSAECONNREFUSED; /*=10061.*/
+#else
+int econnrefused = ECONNREFUSED; /*=111. from Linux asm/errno.h */
+#endif
+
+#ifdef WIN32
+WSADATA lan_ws;
+
+/* See http://msdn2.microsoft.com/en-us/library/ms740668.aspx
+ * or doc/winsockerr.txt */
+#define NWINERRS 21
+static struct { int err; char *desc; } winerrs[NWINERRS] = {
+ WSAEINTR /*10004*/, "Interrupted function call",
+ WSAEBADF /*10009*/, "File handle is not valid",
+ WSAEACCES /*10013*/, "Permission denied",
+ WSAEFAULT /*10014*/, "Bad address",
+ WSAEINVAL /*10022*/, "Invalid argument",
+ WSAEMFILE /*10024*/, "Too many open files",
+ WSAENOTSOCK /*10038*/, "Socket operation on nonsocket",
+ WSAEDESTADDRREQ /*10039*/, "Destination address required",
+ WSAEMSGSIZE /*10040*/, "Message too long",
+ WSAEOPNOTSUPP /*10045*/, "Operation not supported",
+ WSAEADDRINUSE /*10048*/, "Address already in use",
+ WSAEADDRNOTAVAIL /*10049*/, "Cannot assign requested address",
+ WSAENETDOWN /*10050*/, "Network is down",
+ WSAENETUNREACH /*10051*/, "Network is unreachable",
+ WSAENETRESET /*10052*/, "Network dropped connection on reset",
+ WSAECONNABORTED /*10053*/, "Software caused connection abort",
+ WSAECONNRESET /*10054*/, "Connection reset by peer",
+ WSAENOTCONN /*10057*/, "Socket is not connected",
+ WSAECONNREFUSED /*10061*/, "Connection refused",
+ WSAEHOSTDOWN /*10064*/, "Host is down",
+ WSAEHOSTUNREACH /*10065*/, "No route to host"
+};
+
+char * strlasterr(int rv)
+{
+ char *desc;
+ int i;
+ for (i = 0; i < NWINERRS; i++) {
+ if (winerrs[i].err == rv) {
+ desc = winerrs[i].desc;
+ break;
+ }
+ }
+ if (i >= NWINERRS) desc = "";
+
+ return(desc);
+}
+#endif
+
+#ifdef MD2OK
+extern void md2_sum(uchar *string, int len, uchar *mda); /*from md2.c*/
+#endif
+extern void md5_sum(uchar *string, int len, uchar *mda); /*from md5.c*/
+
+int _ipmilan_cmd(SockType s, struct sockaddr *to, int tolen,
+ uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *sdata, int slen, uchar *rdata, int *rlen,
+ int fdebugcmd);
+static int _send_lan_cmd(SockType s, uchar *pcmd, int scmd, uchar *presp,
+ int *sresp, struct sockaddr *to, int tolen);
+static int ipmilan_open_session(SockType sfd, struct sockaddr *destaddr,
+ int destaddr_len, uchar auth_type, char *username,
+ char *authcode, int authcode_len,
+ uchar priv_level, uint32 init_out_seqnum,
+ uint32 *session_seqnum, uint32 *session_id);
+static int ipmilan_close_session(SockType sfd, struct sockaddr *destaddr,
+ int destaddr_len, uint32 session_id);
+uchar cksum(const uchar *buf, register int len);
+char *decode_rv(int rv); /*moved to ipmicmd.c*/
+
+void show_LastError(char *tag, int err)
+{
+#ifdef WIN32
+ fprintf(fperr,"%s LastError = %d %s\n",tag,err,strlasterr(err));
+#else
+ char *s;
+ s = strerror(err);
+ if (s == NULL) s = "error";
+ fprintf(fperr,"%s errno = %d, %s\n",tag,err,s);
+#endif
+}
+
+int get_LastError( void )
+{
+#ifdef WIN32
+ lasterr = WSAGetLastError();
+#else
+ lasterr = errno;
+#endif
+ return(lasterr);
+}
+
+static void cc_challenge(int cc)
+{
+ switch(cc) {
+ case 0x81:
+ printf("GetSessChallenge: Invalid user name\n");
+ break;
+ case 0x82:
+ printf("GetSessChallenge: Null user name not enabled\n");
+ break;
+ default:
+ printf("GetSessChallenge: %s\n",decode_cc((ushort)0,cc));
+ break;
+ }
+}
+
+static void cc_session(int cc)
+{
+ switch(cc) {
+ case 0x81:
+ printf("ActivateSession: No session slots available from BMC\n");
+ break;
+ case 0x82:
+ printf("ActivateSession: No sessions available for this user\n");
+ break;
+ case 0x83:
+ printf("ActivateSession: No sessions for this user/privilege\n");
+ break;
+ case 0x84:
+ printf("ActivateSession: Session sequence number out of range\n");
+ break;
+ case 0x85:
+ printf("ActivateSession: Invalid session ID in request\n");
+ break;
+ case 0x86:
+ printf("ActivateSession: Privilege level exceeds user/channel limit\n");
+ break;
+ default:
+ printf("%s\n",decode_cc((ushort)0,cc));
+ break;
+ }
+ return;
+}
+
+int StrIsIp(char *str)
+{
+ int i, j, n;
+ char ipchars[11] = "0123456789.";
+ int ndot = 0;
+ int rv = 0;
+ /* checks if the string looks like an IP address. */
+ if (str == NULL) return(rv);
+ n = (int)strlen(str);
+ for (i = 0; i < n; i++) {
+ for (j = 0; j < 11; j++)
+ if (str[i] == ipchars[j]) break;
+ if (j >= 11) break; /*some other char, not valid*/
+ if (str[i] == '.') ndot++;
+ }
+ if ((i == n) && (ndot == 3)) rv = 1; /*valid*/
+ return(rv);
+}
+
+void close_sockfd(SockType sfd);
+void close_sockfd(SockType sfd)
+{
+ if (sfd == 0) return;
+#ifdef WIN32
+ // shutdown(sfd,SD_SEND); /*done sending*/
+ closesocket(sfd); /*close lan socket */
+ WSACleanup();
+#else
+ alarm(0);
+ signal(SIGALRM,SIG_DFL);
+ signal(SIGINT,SIG_DFL);
+ close(sfd); /*close lan socket */
+#endif
+ pconn->sockfd = 0; /*set global to zero */
+}
+
+int open_sockfd(char *node, SockType *sfd, SOCKADDR_T *daddr,
+ int *daddr_len, int foutput);
+int open_sockfd(char *node, SockType *sfd, SOCKADDR_T *daddr,
+ int *daddr_len, int foutput)
+{
+ int rv = 0;
+ SockType s, _sockfd = -1;
+#ifdef HAVE_IPV6
+ struct addrinfo hints;
+ struct addrinfo *res, *res0;
+ char service[NI_MAXSERV];
+#else
+ struct hostent *hptr;
+#endif
+
+#ifdef WIN32
+ DWORD rvl;
+
+ if (sfd == NULL || daddr == NULL || daddr_len == NULL)
+ return(-3); /* invalid pointer */
+ rvl = WSAStartup(0x0202,&lan_ws);
+ if (rvl != 0) {
+ fprintf(fperr,"lan, WSAStartup(2.2) error %ld, try 1.1\n", rvl);
+ WSACleanup();
+ rvl = WSAStartup(0x0101,&lan_ws);
+ if (rvl != 0) {
+ fprintf(fperr,"lan, WSAStartup(1.1) error %ld\n", rvl);
+ WSACleanup();
+ return((int)rvl);
+ }
+ }
+#else
+ if (sfd == NULL || daddr == NULL || daddr_len == NULL)
+ return(-3); /* invalid pointer */
+#endif
+ pconn->connect_state = CONN_STATE_INIT;
+
+#ifdef HAVE_IPV6
+ memset(&_srcaddr, 0, sizeof(_srcaddr));
+ memset(daddr, 0, sizeof(_destaddr));
+ sprintf(service, "%d", RMCP_PRI_RMCP_PORT);
+ /* Obtain address(es) matching host/port */
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
+ hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
+ hints.ai_flags = my_ai_flags;
+ hints.ai_protocol = IPPROTO_UDP; /* */
+ rv = getaddrinfo(node, service, NULL, &res);
+ if (rv != 0) {
+ printf("Address lookup for %s failed, getaddrinfo error %d\n",
+ node,rv);
+ return rv;
+ }
+
+ /* getaddrinfo() returns a list of address structures.
+ * Try each address until we successfully connect(2).
+ * If socket(2) (or connect(2)) fails, we (close the socket
+ * and) try the next address.
+ */
+ for (res0 = res; res0 != NULL; res0 = res0->ai_next) {
+ s = socket(res0->ai_family, res0->ai_socktype, res0->ai_protocol);
+ if (s == SockInvalid) continue;
+ else _sockfd = s;
+ /* valid protocols are IPPROTO_UDP, IPPROTO_IPV6 */
+ if (res0->ai_protocol == IPPROTO_TCP) continue; /*IPMI != TCP*/
+ pconn->connect_state = CONN_STATE_SOCK;
+ rv = connect(_sockfd, res0->ai_addr, res0->ai_addrlen);
+ if (fdebuglan) printf("socket(%d,%d,%d), connect(%d) rv = %d\n",
+ res0->ai_family, res0->ai_socktype,
+ res0->ai_protocol, s,rv);
+ if (rv != -1) {
+ memcpy(daddr, res0->ai_addr, res0->ai_addrlen);
+ *daddr_len = res0->ai_addrlen;
+ break; /* Success */
+ }
+ close_sockfd(_sockfd);
+ _sockfd = -1;
+ }
+ freeaddrinfo(res); /* Done with addrinfo */
+ if (_sockfd < 0) {
+ printf("Connect to %s failed\n", node);
+ // ipmi_close_();
+ rv = -1;
+ }
+#else
+ /* Open lan interface (ipv4 method) */
+ s = socket(AF_INET, SOCK_DGRAM, 0);
+ if (s == SockInvalid) return (-1);
+ else _sockfd = s;
+
+ pconn->connect_state = CONN_STATE_SOCK;
+ memset(&_srcaddr, 0, sizeof(_srcaddr));
+ _srcaddr.sin_family = AF_INET;
+ _srcaddr.sin_port = htons(0);
+ _srcaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ rv = bind(_sockfd, (struct sockaddr *)&_srcaddr, sizeof(_srcaddr));
+ if (rv < 0) {
+ close_sockfd(_sockfd);
+ return (rv);
+ }
+
+ memset(daddr, 0, sizeof(SOCKADDR_T));
+ daddr->sin_family = AF_INET;
+ daddr->sin_port = htons(RMCP_PRI_RMCP_PORT); /*0x26f = 623.*/
+ if (StrIsIp(node)) { /* the node string is an IP address */
+ uchar in_ip[4];
+ atoip(in_ip,node);
+ memcpy(&daddr->sin_addr.s_addr,in_ip,4);
+ if ((hptr = xgethostbyname(node)) == NULL) /*gethost error*/
+ strncpy(gnodename,node,SZGNODE); /*but not fatal*/
+ else strncpy(gnodename,hptr->h_name,SZGNODE);
+ }
+ else if ((hptr = xgethostbyname(node)) == NULL) {
+ if (foutput) {
+#ifdef WIN32
+ fprintf(fperr,"lan, gethostbyname(%s): errno=%d\n", node,get_errno());
+#elif SOLARIS
+ fprintf(fperr,"lan, gethostbyname(%s): errno=%d\n", node,get_errno());
+#else
+ fprintf(fperr,"lan, gethostbyname(%s): %s\n", node,hstrerror(errno));
+#endif
+ }
+ close_sockfd(_sockfd);
+ return(LAN_ERR_HOSTNAME);
+ } else { /*gethostbyname(name) succeeded*/
+ daddr->sin_addr = *((struct in_addr *)hptr->h_addr);
+ strncpy(gnodename,hptr->h_name,SZGNODE);
+ }
+ *daddr_len = sizeof(SOCKADDR_T);
+#endif
+
+ *sfd = _sockfd;
+ return(rv);
+}
+
+static void
+sig_timeout(int sig)
+{
+#ifndef WIN32
+ alarm(0);
+ signal(SIGALRM,SIG_DFL);
+#endif
+ fprintf(fpdbg,"ipmilan_cmd timeout, after %s\n",conn_state_str[pconn->connect_state]);
+ _exit(LAN_ERR_TIMEOUT); /*timeout signal*/
+}
+
+static void
+sig_abort(int sig)
+{
+ static int sig_aborting = 0;
+ int rv;
+ // uchar buf_rs[4];
+ // uchar *cmd_rs;
+
+ if (sig_aborting == 0) {
+ sig_aborting = 1;
+ if (pconn->sockfd != 0) { /* socket is open */
+ if (pconn->session_id != 0) { /* session is open */
+ // cmd_rs = buf_rs;
+ rv = ipmilan_close_session(pconn->sockfd,
+ (struct sockaddr *)&_destaddr,
+ _destaddr_len, ipmi_hdr.sess_id);
+ }
+ close_sockfd(pconn->sockfd);
+ }
+ signal(SIGINT,SIG_DFL);
+ fprintf(fpdbg,"ipmilan_cmd interrupt, after %s\n", conn_state_str[pconn->connect_state]);
+ _exit(LAN_ERR_ABORT); /*abort signal*/
+ } /*endif*/
+} /*end sig_abort*/
+
+int fd_wait(SockType fd, int nsec, int usec)
+{
+ fd_set readfds;
+ struct timeval tv;
+ int rv;
+
+ FD_ZERO(&readfds);
+ FD_SET(fd, &readfds);
+ tv.tv_sec = nsec;
+ tv.tv_usec = usec;
+ rv = select((int)(fd+1), &readfds, NULL, NULL, &tv);
+ if (rv <= 0 || !FD_ISSET(fd,&readfds)) return(-1);
+ else return(0);
+}
+
+#ifndef WIN32
+ /* LINUX, Solaris, BSD */
+/* do_sleep() is currently unused. */
+/* signal handlers + sleep(3) is a bad idea */
+int do_sleep(unsigned int sleep_len)
+{
+ struct timeval tv;
+
+ if (sleep_len == 0)
+ return 0;
+
+ tv.tv_sec = sleep_len;
+ tv.tv_usec = 0;
+ if (select(1, NULL, NULL, NULL, &tv) < 0)
+ {
+ if (errno != EINTR) return(errno);
+ }
+ return 0;
+}
+#endif
+
+static void h2net(uint h, uchar *net, int n)
+{
+ int i = 0;
+ net[i++] = h & 0xff;
+ net[i++] = (h >> 8) & 0xff;
+ if (n == 2) return;
+ net[i++] = (h >> 16) & 0xff;
+ net[i++] = (h >> 24) & 0xff;
+ return;
+}
+
+static void net2h(uint *h, uchar *net, int n)
+{
+ uint v;
+ v = (net[1] << 8) | net[0];
+ if (n == 2) { *h = v; return; }
+ v |= (net[3] << 24) | (net[2] << 16);
+ *h = v;
+ return;
+}
+
+/*
+ * _ipmilan_cmd
+ * local routine to send & receive each command.
+ * called by global ipmicmd_lan()
+ */
+int _ipmilan_cmd(SockType sockfd, struct sockaddr *hostaddr, int hostaddr_len,
+ uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *sdata, int slen, uchar *rdata, int *rlen, int fdebugcmd)
+{
+ uchar cmd_rq[RQ_LEN_MAX+SZ_CMD_HDR];
+ uchar cmd_rs[RS_LEN_MAX+SZ_CMD_HDR+1];
+ int rv = 0;
+ int rs_len;
+ int clen;
+ uchar cc = 0;
+
+#ifndef TEST_LAN
+ fdebuglan = fdebugcmd;
+#endif
+ if (sockfd == 0 || hostaddr == NULL ||
+ sdata == NULL || rdata == NULL)
+ return(LAN_ERR_INVPARAM);;
+
+ if (fdebuglan > 2)
+ dbglog("_ipmilan_cmd(%02x,%02x,%02x,%02x,%02x)\n",
+ cmd,netfn,lun,sa,bus);
+ clen = SZ_CMD_HDR;
+ cmd_rq[0] = cmd;
+ cmd_rq[1] = (netfn << 2) + (lun & 0x03);
+ cmd_rq[2] = sa;
+ cmd_rq[3] = bus;
+ memcpy(&cmd_rq[clen],sdata,slen);
+ rs_len = sizeof(cmd_rs);
+ memset(cmd_rs, 0, rs_len);
+ rv = _send_lan_cmd(sockfd, cmd_rq, slen+clen, cmd_rs, &rs_len,
+ hostaddr, hostaddr_len);
+ if (rv == 0 && rs_len == 0) cc = 0;
+ else cc = cmd_rs[0];
+ if (fdebugcmd) fprintf(fpdbg,"_ipmilan_cmd[%02x]: rv = %d, cc=%x rs_len=%d\n",
+ cmd_rq[0],rv,cc,rs_len);
+ if (rv == 0 && cc != 0) { /* completion code error */
+ if (fdebugcmd) {
+ dump_buf("cmd_rq",cmd_rq,slen+clen,0);
+ dump_buf("cmd_rs",cmd_rs,rs_len,0);
+ }
+ }
+ if (rv == 0) {
+ if (rs_len < 0) rs_len = 0;
+ if (*rlen <= 0) *rlen = 1; /*failsafe*/
+ if (rs_len > 0) {
+ if (rs_len > *rlen) rs_len = *rlen;
+ memcpy(rdata,&cmd_rs[0],rs_len);
+ } else { /*(rs_len == 0)*/
+ rv = LAN_ERR_TOO_SHORT; /*no completion code returned*/
+ }
+ } else {
+ rdata[0] = cc;
+ if (rs_len < 1) rs_len = 1;
+ }
+ *rlen = rs_len;
+
+ return (rv);
+} /*end _ipmilan_cmd()*/
+
+
+static void hash(uchar *pwd, uchar *id, uchar *chaldata, int chlen, uint32 seq,
+ uchar *mda, uchar md)
+{
+ uchar pbuf[80]; /* 16 + 4 + 16 + 4 + 16 = 56 */
+ int blen, n, i;
+
+ blen = 0; n = 16;
+ memcpy(&pbuf[blen], pwd,n); /* password */
+ blen += n; n = 4;
+ memcpy(&pbuf[blen],id,n); /* session id */
+ blen += n;
+ memcpy(&pbuf[blen],chaldata,chlen); /* ipmi msg data, incl challenge */
+ blen += chlen; n = 4;
+ h2net(seq,&pbuf[blen],n); /* in_seq num */
+ blen += n; n = 16;
+ memcpy(&pbuf[blen],pwd,n); /* password */
+ blen += n;
+ if (md == IPMI_SESSION_AUTHTYPE_MD2) i = 2;
+ else i = 5;
+#ifdef TEST_AUTH
+ if (fdebuglan) {
+ fprintf(fpdbg,"hash: calling md%d_sum with seq %u\n",i,seq);
+ dump_buf("pbuf",pbuf,blen,0);
+ }
+#endif
+#ifdef MD2OK
+ if (md == IPMI_SESSION_AUTHTYPE_MD2)
+ md2_sum(pbuf,blen,mda);
+ else /* assume md5 */
+#endif
+ md5_sum(pbuf,blen,mda);
+#ifdef TEST_AUTH
+ if (fdebuglan) {
+ fprintf(fpdbg,"Hashed MD%d AuthCode: \n",i);
+ dump_buf("AuthCode",mda,16,0);
+ }
+#endif
+} /* end hash() */
+
+static void hash_special(uchar *pwd, uchar *chaldata, uchar *mda)
+{
+ uchar md_pwd[16];
+ uchar challenge[16];
+ int i;
+ /* Only used by SuperMidro, must be MD5 auth_type */
+ memset(md_pwd, 0, 16);
+ md5_sum(pwd,16,md_pwd);
+ memset(challenge, 0, 16);
+ for (i = 0; i < 16; i++)
+ challenge[i] = chaldata[i] ^ md_pwd[i];
+ memset(mda, 0, 16);
+ md5_sum(challenge,16,mda);
+}
+
+static int ipmilan_sendto(SockType s, const void *msg, size_t len, int flags,
+ const struct sockaddr *to, int tolen)
+{
+ int fusepad = 0;
+ int n;
+ if (fdebuglan > 2) {
+ dbg_dump("ipmilan_sendto",(uchar *)msg,(int)len,0);
+ }
+ /* Check whether we need a pad byte */
+ /* Note from Table 12-8, RMCP Packet for IPMI via Ethernet footnote. */
+ if (len == 56 || len == 84 || len == 112 || len == 128 || len == 156) {
+ /* include pad byte at end, require input buffer to have one extra */
+ fusepad = 1;
+ len += 1;
+ }
+ n = (int)sendto(s,msg,len,flags,to,(socklen_t)tolen);
+ if (fusepad && (n > 0)) n--;
+ return(n);
+}
+
+static int ipmilan_recvfrom(SockType s, void *buf, size_t len, int flags,
+ struct sockaddr *from, int *fromlen)
+{
+ int rv;
+ rv = (int)recvfrom(s,buf,len,flags,from,(socklen_t *)fromlen);
+#ifdef OLD
+ /* Sometimes the OS sends an ECONNREFUSED error, but
+ * retrying will catch the BMC's reply packet. */
+ if (rv < 0) {
+ int err;
+ err = get_LastError();
+ if (err == econnrefused) {
+ if (fdebuglan)
+ fprintf(fpdbg,"ipmilan_recvfrom rv=%d econnrefused, retry\n",rv);
+ rv = recvfrom(s,buf,len,flags,from,(socklen_t *)fromlen);
+ }
+ }
+#endif
+ return(rv);
+}
+
+static int ipmilan_poke1(SockType sfd, struct sockaddr *destaddr, int destlen)
+{
+ int rv;
+ uchar asfpkt[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x07, 0x20, 0x18, 0xc8, 0xc2, 0x01, 0x01, 0x3c };
+ if (fdebuglan) fprintf(fpdbg,"sending ipmilan poke1\n");
+ rv = ipmilan_sendto(sfd, asfpkt, 16, 0, destaddr, destlen);
+ os_usleep(0,100);
+ return rv;
+}
+
+static int ipmilan_poke2(SockType sfd, struct sockaddr *destaddr, int destlen)
+{
+ int rv;
+ uchar asfpkt[16] = "poke2"; /*any junk*/
+ if (fdebuglan) fprintf(fpdbg,"sending ipmilan poke2\n");
+ rv = ipmilan_sendto(sfd, asfpkt, 10, 0, destaddr, destlen);
+ os_usleep(0,100);
+ return rv;
+}
+
+
+static void do_hash(uchar *password, uchar *sessid, uchar *pdata, int sdata,
+ uint32 seq_num, uchar auth_type, uchar *auth_out)
+{
+ /* finish header with auth_code */
+ if (auth_type != IPMI_SESSION_AUTHTYPE_NONE) { /*fdoauth==1*/
+ if (auth_type == IPMI_SESSION_AUTHTYPE_MD5)
+ hash(password, sessid, pdata, sdata, seq_num,
+ auth_out,IPMI_SESSION_AUTHTYPE_MD5);
+#ifdef MD2OK
+ else if (auth_type == IPMI_SESSION_AUTHTYPE_MD2)
+ hash(password, sessid, pdata, sdata, seq_num,
+ auth_out,IPMI_SESSION_AUTHTYPE_MD2);
+#endif
+ else /* IPMI_SESSION_AUTHTYPE_PASSWORD */
+ memcpy(auth_out,password,16);
+ }
+}
+
+static uint32 inc_seq_num(uint32 seq)
+{
+ seq++;
+ if (seq == 0) seq = 1;
+ return(seq);
+}
+
+static int inc_sol_seq(int seq)
+{
+ seq++;
+ if (seq > 0x0f) seq = 1; /*limit to 4 bits*/
+ return(seq);
+}
+
+void ipmi_lan_set_timeout(int ipmito, int tries, int pingto)
+{
+ ipmi_timeout = ipmito; /*default 2*/
+ ipmi_try = tries; /*default 4*/
+ ping_timeout = pingto; /*default 1*/
+}
+
+/*
+ * _send_lan_cmd
+ * Internal routine called by local _ipmilan_cmd() and by
+ * ipmilan_open_session().
+ * Writes the data to the lan socket in IPMI LAN format.
+ * Authentication, sequence numbers, checksums are handled here.
+ *
+ * Input Parameters:
+ * s = socket descriptor for this session
+ * pcmd = buffer for the command and data
+ * Arbitrary pcmd format:
+ * cmd[0] = IPMI command
+ * cmd[1] = NETFN/LUN byte
+ * cmd[2] = Slave Address (usu 0x20)
+ * cmd[3] = Bus (usu 0x00)
+ * cmd[4-N] = command data
+ * scmd = size of command buffer (3+sdata)
+ * presp = pointer to existing response buffer
+ * sresp = On input, size of response buffer,
+ * On output, length of response data.
+ * to = sockaddr structure for to/destination
+ * tolen = length of to sockaddr
+ */
+static int _send_lan_cmd(SockType s, uchar *pcmd, int scmd, uchar *presp,
+ int *sresp, struct sockaddr *to, int tolen)
+{
+ uchar cbuf[SEND_BUF_SZ];
+ uchar rbuf[RECV_BUF_SZ];
+ // uint32 out_seq = 0; /* outbound */
+ int clen, rlen, hlen, msglen;
+ int flags;
+ int sz, n, i, j;
+ int cs1, cs2, cs3 = 0, cs4 = 0;
+ uchar *pdata;
+ int sdata;
+ IPMI_HDR *phdr;
+ uchar *psessid;
+ uchar iauth[16];
+ int fdoauth = 1;
+ uint32 sess_id_tmp;
+ int rv = 0;
+ int itry;
+ uchar fsentok;
+
+ /* set up LAN req hdr */
+ phdr = &ipmi_hdr;
+ hlen = RQ_HDR_LEN;
+ /* phdr->bmc_addr set in open_session */
+ phdr->target_addr = pcmd[2];
+ phdr->target_chan = pcmd[3];
+ phdr->target_lun = (pcmd[1] & 0x03);
+ phdr->target_netfn = (pcmd[1] >> 2);
+ phdr->target_cmd = pcmd[0];
+
+ if (phdr->seq_num != 0) pconn->finsession = 1;
+ if ( ((phdr->target_cmd == CMD_ACTIVATE_SESSION) ||
+ (phdr->target_cmd == CMD_SET_SESSION_PRIV)) &&
+ (phdr->target_netfn == NETFN_APP) ) {
+ pconn->finsession = 1; /*so do seq_num*/
+ fdoauth = 1; /*use msg auth*/
+ }
+ if (phdr->auth_type == IPMI_SESSION_AUTHTYPE_NONE) fdoauth = 0;
+ else if (pconn->finsession && (pconn->fMsgAuth == 0)) {
+ /* Forcing the type may be necessary with IBM eServer 360S. */
+ if (fauth_type_set) fdoauth = 1; /*user set it, so try anyway*/
+ else fdoauth = 0; /*auth not supported*/
+ }
+ if (fdoauth == 0) hlen = RQ_HDR_LEN - 16;
+
+ /* copy command */
+ if (scmd < SZ_CMD_HDR) return(LAN_ERR_INVPARAM);
+ sdata = scmd - SZ_CMD_HDR; /* scmd = 4 + datalen */
+ msglen = 7 + sdata;
+ if (fdebuglan > 2) {
+ dbglog("_send_lan_cmd: cmd=%02x, hlen=%d, msglen=%02x, authtype=%02x\n",
+ pcmd[0], hlen, msglen, phdr->auth_type);
+ }
+ clen = hlen + msglen;
+ if (clen > sizeof(cbuf)) {
+ fprintf(fpdbg,"message size %d > buffer size %d\n",clen,sizeof(cbuf));
+ return(LAN_ERR_TOO_SHORT);
+ }
+
+ if ((phdr->target_cmd == SOL_DATA) &&
+ (phdr->target_netfn == NETFN_SOL) ) /*SOL 1.5 data packet*/
+ {
+ hlen = SOL_HDR_LEN; /*RMCP header + 26 */
+ if (fdoauth == 0) hlen = SOL_HDR_LEN - 16;
+ msglen = sdata;
+ memcpy(&cbuf[0], phdr, 4); /* copy RMCP header to buffer */
+ pdata = &cbuf[4];
+ pdata[0] = phdr->auth_type;
+ memcpy(&pdata[1],&phdr->seq_num,4);
+ sess_id_tmp = phdr->sess_id | SOL_MSG;
+ memcpy(&pdata[5],&sess_id_tmp,4);
+ if (fdebuglan > 2)
+ dbglog("auth_type=%x/%x fdoauth=%d hlen=%d seq_num=%x\n", /*SOL*/
+ phdr->auth_type,gauth_type,fdoauth,hlen,phdr->seq_num);
+ if (fdoauth) {
+ psessid = (uchar *)&sess_id_tmp;
+ do_hash(phdr->password, psessid, &cbuf[hlen],msglen,
+ phdr->seq_num, phdr->auth_type, iauth);
+ /* copy hashed authcode to header */
+ memcpy(&pdata[9],iauth,16);
+ }
+ // pdata[hlen-1] = msglen;
+ pdata = &cbuf[hlen];
+ memcpy(pdata,&pcmd[SZ_CMD_HDR],msglen); /*copy the data*/
+ clen = hlen + msglen;
+ if (fdebuglan > 2)
+ dbg_dump("sol data, before",pdata,sdata,1); /*SOL TEST*/
+ } else { /*not SOL packet, normal IPMI packet*/
+ pdata = &cbuf[hlen];
+ j = cs1 = 0;
+ if ((phdr->target_addr == phdr->bmc_addr) || !bridgePossible ||
+ (phdr->target_addr == SWID_REMOTE) ||
+ (phdr->target_addr == SWID_SMSOS)) {
+ phdr->bridge_level = 0;
+ msglen = sdata + 7;
+ clen = hlen + msglen;
+ } else {
+ phdr->bridge_level = 1;
+ if (phdr->transit_addr != 0 && phdr->transit_addr != phdr->bmc_addr)
+ {
+ msglen = sdata + 15 + 8;
+ phdr->bridge_level++;
+ } else {
+ msglen = sdata + 15;
+ }
+ if (fdebuglan > 2) {
+ dbglog("bridge_level=%d cmd=%02x target=%02x transit=%02x\n",
+ phdr->bridge_level, phdr->target_cmd,
+ phdr->target_addr, phdr->transit_addr);
+ dbglog("bridge target_ch=%x transit_ch=%x\n",
+ phdr->target_chan, phdr->transit_chan);
+ }
+ clen = hlen + msglen;
+ pdata[j++] = bmc_sa; /*[0]=sa */
+ pdata[j++] = (NETFN_APP << 2); /*[1]=netfn/lun*/
+ pdata[j] = cksum(&pdata[cs1],j-cs1); /*[2]=cksum1*/
+ j++;
+ cs3 = j; /*start for cksum3*/
+ pdata[j++] = phdr->swid; /*[3]=swid, usu SWID_REMOTE */
+ pdata[j++] = (phdr->swseq << 2); /*[4]=swseq/lun*/
+ pdata[j++] = CMD_SEND_MESSAGE; /*[5]=cmd*/
+ if (phdr->bridge_level == 1) {
+ pdata[j++] = (0x40|phdr->target_chan); /*channel*/
+ } else { /*double bridge*/
+ pdata[j++] = (0x40|phdr->transit_chan); /*channel*/
+ cs1 = j;
+ pdata[j++] = phdr->transit_addr; /*[0]=sa */
+ pdata[j++] = (NETFN_APP << 2); /*[1]=netfn/lun*/
+ pdata[j] = cksum(&pdata[cs1],j-cs1); /*[2]=cksum1*/
+ j++;
+ cs4 = j; /*start for cksum4*/
+ pdata[j++] = bmc_sa; /*[3]=swid */
+ pdata[j++] = (phdr->swseq << 2); /*[4]=swseq/lun*/
+ pdata[j++] = CMD_SEND_MESSAGE; /*[5]=cmd*/
+ pdata[j++] = (0x40|phdr->target_chan); /*channel*/
+ }
+ } /*end-else bridged*/
+ /* normal IPMI LAN commmand packet */
+ cs1 = j; /*start for cksum1*/
+ pdata[j++] = pcmd[2]; /*[0]=sa (phdr->target_addr)*/
+ pdata[j++] = pcmd[1]; /*[1]=netfn/lun*/
+ pdata[j] = cksum(&pdata[cs1],j-cs1); /*[2]=cksum1*/
+ j++;
+ cs2 = j; /*start for cksum2*/
+ if (phdr->bridge_level == 0)
+ pdata[j++] = phdr->swid; /*[3]=swid*/
+ else /*bridged message*/
+ pdata[j++] = phdr->bmc_addr; /*[3]=swid*/
+ pdata[j++] = (phdr->swseq << 2) + phdr->swlun; /*[4]=swseq/lun*/
+ pdata[j++] = phdr->target_cmd; /*[5]=cmd (pcmd[0])*/
+ if (sdata > 0) {
+ memcpy(&pdata[j],&pcmd[SZ_CMD_HDR],sdata); /*[6]=data*/
+ j += sdata;
+ }
+ pdata[j] = cksum(&pdata[cs2],j-cs2); /*cksum2*/
+ j++;
+
+ if (phdr->bridge_level > 0) {
+ if (phdr->bridge_level > 1) {
+ pdata[j] = cksum(&pdata[cs4],j-cs4); /*cksum4*/
+ j++;
+ }
+ pdata[j] = cksum(&pdata[cs3],j-cs3); /*cksum3*/
+ j++;
+ }
+ if (fdebuglan && (msglen != j))
+ fprintf(fpdbg,"warning: msglen(%d)!=j(%d), hlen=%d clen=%d\n",
+ msglen,j,hlen,clen);
+
+ if (fdoauth) {
+ psessid = (uchar *)&phdr->sess_id;
+ do_hash(phdr->password, psessid, &cbuf[hlen],msglen,
+ phdr->seq_num, phdr->auth_type, iauth);
+ /* copy hashed authcode to header */
+ memcpy(phdr->auth_code,iauth,16);
+ }
+ memcpy(&cbuf[0], phdr, hlen); /* copy header to buffer */
+ } /*end-else normal IPMI */
+
+ if (fdoauth == 0 && phdr->auth_type != IPMI_SESSION_AUTHTYPE_NONE) {
+ /* force the packet auth type to NONE (0) */
+ IPMI_HDR *pchdr;
+ pchdr = (IPMI_HDR *)&cbuf[0];
+ pchdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE;
+ // memset(phdr->auth_code,0,16);
+ }
+ cbuf[hlen-1] = (uchar)msglen; /* IPMI Message Length = 7 + data */
+ if (fdebuglan > 2) {
+ if ((phdr->target_cmd == SOL_DATA) &&
+ (phdr->target_netfn == NETFN_SOL) ) {
+ // phdr->sess_id = sess_id_sav; /*restore sess_id*/
+ if (fdebuglan) fprintf(fpdbg,"sending lan sol data (len=%d)\n",clen);
+ } else {
+ if (fdebuglan) fprintf(fpdbg,"sending ipmi lan data (len=%d)\n",clen);
+ }
+ }
+ flags = 0;
+ rlen = 0;
+
+ if ((fdebuglan > 2) &&
+ (phdr->target_cmd == CMD_GET_CHAN_AUTH_CAP) &&
+ (phdr->target_netfn == NETFN_APP) )
+ dbg_dump("get_chan_auth_cap command",cbuf,clen,1);
+ memset(rbuf,0,sizeof(rbuf));
+ fsentok = 0;
+ for (itry = 0; (itry < ipmi_try) && (rlen == 0); itry++)
+ {
+ if (fdebuglan > 2)
+ dbglog("ipmilan_cmd(seq=%x) fsentok=%d itry=%d\n",
+ phdr->seq_num, fsentok, itry);
+ if (fsentok == 0) {
+ if (fdebuglan)
+ fprintf(fpdbg,"ipmilan_sendto(seq=%x,clen=%d)\n",
+ phdr->seq_num, clen);
+ sz = ipmilan_sendto(s,cbuf,clen,flags,to,tolen);
+ if (sz < 1) {
+ lasterr = get_LastError();
+ if (fdebuglan) show_LastError("ipmilan_sendto",lasterr);
+ rv = LAN_ERR_SEND_FAIL;
+ os_usleep(0,5000);
+ continue; /* retry */
+ }
+ fsentok = 1; /*sent ok, no need to resend*/
+ }
+
+ /* receive the response */
+ rv = fd_wait(s, ipmi_timeout,0);
+ if (rv != 0) {
+ if (fdebuglan)
+ fprintf(fpdbg,"ipmilan_cmd timeout, after request, seq=%x itry=%d\n",
+ phdr->seq_num, itry);
+ rv = LAN_ERR_RECV_FAIL;
+ if (fdopoke2) ipmilan_poke2(s, to, tolen);
+ os_usleep(0,5000);
+ continue; /* retry */
+ }
+ flags = RECV_MSG_FLAGS;
+ rlen = ipmilan_recvfrom(s,rbuf,sizeof(rbuf),flags,to,&tolen);
+ if (rlen < 0) {
+ lasterr = get_LastError();
+ if (fdebuglan) {
+ fprintf(fpdbg,"ipmilan_recvfrom rlen=%d, err=%d iseq=%x itry=%d\n",
+ rlen,lasterr,phdr->iseq_num,itry);
+ show_LastError("ipmilan_recvfrom",lasterr);
+ }
+ rv = rlen; /* -3 = LAN_ERR_RECV_FAIL */
+ rlen = 0;
+ *sresp = rlen;
+ /* Sometimes the OS sends an ECONNREFUSED error, but
+ * retrying will catch the BMC's reply packet. */
+ if (lasterr == econnrefused) continue; /*try again*/
+ else break; /* goto EXIT; */
+ } else { /* successful receive */
+ net2h(&phdr->iseq_num,&rbuf[5],4); /*incoming seq_num from hdr*/
+ if (fdebuglan) {
+ fprintf(fpdbg,"ipmilan_recvfrom rlen=%d, iseq=%x\n",
+ rlen,phdr->iseq_num);
+ if (fdebuglan > 2)
+ dbg_dump("ipmilan_recvfrom", rbuf,rlen,1);
+ }
+
+ /* incoming auth_code may differ from request auth code, (Dell 1855)*/
+ if (rbuf[4] == IPMI_SESSION_AUTHTYPE_NONE) { /* if AUTH_NONE */
+ phdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE;
+ hlen = RQ_HDR_LEN - 16; /*RMCP header + 10*/
+ } else {
+ hlen = RQ_HDR_LEN; /*RMCP header + 26 */
+ // memcpy(phdr->iauth_code,&rbuf[13],16); /*iauthcode*/
+ }
+
+ i = hlen + 6;
+ if (rlen <= i) rv = LAN_ERR_TOO_SHORT;
+ else { /* successful */
+ n = rlen - i - 1;
+ if (bridgePossible && (phdr->target_addr != bmc_sa)) {
+ if (phdr->bridge_level &&
+ ((rbuf[hlen+1] >> 2) == (NETFN_APP + 1)) && /*0x07*/
+ rbuf[hlen+5] == CMD_SEND_MESSAGE) /*0x34*/
+ {
+ phdr->bridge_level--;
+ if (n <= 1) { /* no data, wait for next */
+ if (fdebuglan)
+ fprintf(fpdbg,"bridged response empty, cc=%x\n",rbuf[i]);
+ if (rbuf[i] == 0) { /* if sendmsg cc==0, recv again*/
+ rlen = 0;
+ continue;
+ } /*else done*/
+ } else { /* has data, copy it*/
+ //if (fdebuglan) fprintf(fpdbg,"bridged response, n=%d\n",n);
+ // memmove(&rbuf[i-7],&rbuf[i],n);
+ phdr->swseq = rbuf[i-3] >> 2; /*needed?*/
+ rbuf[i-8] -= 8;
+ n -= 8;
+ i -= 7;
+ if (fdebuglan) dump_buf("bridged response",&rbuf[i],n,1);
+ continue; /*recv again*/
+ }
+ }
+ } /*endif bridge*/
+ if (n > *sresp) n = *sresp;
+ memcpy(presp,&rbuf[i],n);
+ *sresp = n;
+ rv = 0;
+ }
+ } /*end else success*/
+ } /*end for loop*/
+// EXIT:
+#ifdef NOT
+ /* do not increment sequence numbers for SEND_MESSAGE command */
+ if ((phdr->target_cmd == IPMB_SEND_MESSAGE) &&
+ (phdr->target_netfn == NETFN_APP) )
+ pconn->finsession = 0;
+#endif
+ if (pconn->finsession) {
+ /* increment seqnum - even if error */
+ phdr->seq_num = inc_seq_num( phdr->seq_num );
+ if (rlen > 0) pconn->in_seq = phdr->iseq_num;
+ else pconn->in_seq = inc_seq_num(pconn->in_seq);
+ phdr->swseq = (uchar)inc_seq_num(phdr->swseq);
+ }
+ return(rv);
+} /*end _send_lan_cmd*/
+
+static char *auth_type_str(int authcode)
+{
+ char *pstr;
+ switch(authcode) {
+ case IPMI_SESSION_AUTHTYPE_MD5: pstr = "MD5"; break;
+ case IPMI_SESSION_AUTHTYPE_MD2: pstr = "MD2"; break;
+ case IPMI_SESSION_AUTHTYPE_PASSWORD: pstr = "PSWD"; break;
+ case IPMI_SESSION_AUTHTYPE_OEM: pstr = "OEM"; break;
+ case IPMI_SESSION_AUTHTYPE_NONE: pstr = "NONE"; break;
+ default: pstr = "Init"; break; /* AUTHTYPE_INIT, etc. */
+ }
+ return (pstr);
+}
+
+#ifdef NOT_USED
+static uchar auth_type_mask(int authcode, uchar allowed)
+{
+ uchar mask;
+ switch(authcode) {
+ case IPMI_SESSION_AUTHTYPE_MD5:
+ mask = IPMI_MASK_AUTHTYPE_MD5;
+ break;
+ case IPMI_SESSION_AUTHTYPE_MD2:
+ mask = IPMI_MASK_AUTHTYPE_MD2;
+ break;
+ case IPMI_SESSION_AUTHTYPE_PASSWORD:
+ mask = IPMI_MASK_AUTHTYPE_PASSWORD;
+ break;
+ case IPMI_SESSION_AUTHTYPE_OEM:
+ mask = IPMI_MASK_AUTHTYPE_OEM;
+ break;
+ case IPMI_SESSION_AUTHTYPE_NONE:
+ mask = IPMI_MASK_AUTHTYPE_NONE;
+ break;
+ default: /* AUTHTYPE_INIT, etc. */
+ mask = 0;
+ break;
+ }
+ return (mask);
+}
+#endif
+
+/*
+ * ipmilan_open_session
+ * Performs the various command/response sequence needed to
+ * initiate an IPMI LAN session.
+ */
+static int ipmilan_open_session(SockType sfd, struct sockaddr *destaddr,
+ int destaddr_len, uchar auth_type, char *username,
+ char *authcode, int authcode_len,
+ uchar priv_level, uint32 init_out_seqnum,
+ uint32 *session_seqnum, uint32 *session_id)
+{
+ int rv = 0;
+ uchar ibuf[RQ_LEN_MAX+3];
+ uchar rbuf[RS_LEN_MAX+4];
+ uint32 iseqn;
+ uchar ipasswd[16];
+ uchar iauthtype;
+ uchar iauthcap, imsgauth;
+ int rlen, ilen;
+ IPMI_HDR *phdr;
+ uchar cc;
+ int busy_tries = 0;
+
+ if (fdebuglan)
+ fprintf(fpdbg,"ipmilan_open_session(%d,%02x,%s,%02x,%x) called\n",
+ sfd,auth_type,username,priv_level,init_out_seqnum);
+ if (sfd == 0 || destaddr == NULL) return LAN_ERR_INVPARAM;
+ phdr = &ipmi_hdr;
+ /* Initialize ipmi_hdr fields */
+ memset(phdr,0,sizeof(ipmi_hdr));
+ phdr->rmcp_ver = 0x06;
+ phdr->rmcp_res = 0x00;
+ phdr->rmcp_seq = 0xFF;
+ phdr->rmcp_type = 0x07;
+ phdr->swid = sms_swid;
+ phdr->swseq = 1;
+ phdr->priv_level = priv_level;
+
+ /* Get Channel Authentication */
+ phdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE; /*use none(0) at first*/
+ ibuf[0] = 0x0e; /*this channel*/
+ ibuf[1] = phdr->priv_level;
+ rlen = sizeof(rbuf);
+ if (fdebuglan)
+ fprintf(fpdbg,"GetChanAuth(sock %x, level %x) called\n",sfd,ibuf[1]);
+ rv = _ipmilan_cmd(sfd, destaddr, destaddr_len, CMD_GET_CHAN_AUTH_CAP,
+ NETFN_APP,BMC_LUN,bmc_sa, PUBLIC_BUS,
+ ibuf,2, rbuf,&rlen, fdebuglan);
+ if (rv != 0) { /*retry if error*/
+ rv = _ipmilan_cmd(sfd, destaddr, destaddr_len, CMD_GET_CHAN_AUTH_CAP,
+ NETFN_APP,BMC_LUN,bmc_sa, PUBLIC_BUS,
+ ibuf,2, rbuf,&rlen, fdebuglan);
+ }
+ cc = rbuf[0];
+ if (fdebuglan)
+ fprintf(fpdbg,"GetChanAuth rv = %d, cc=%x rbuf: %02x %02x %02x "
+ "%02x %02x %02x %02x\n",
+ rv, rbuf[0],rbuf[1],rbuf[2],rbuf[3],
+ rbuf[4],rbuf[5],rbuf[6],rbuf[7]);
+ if (rv != 0 || cc != 0) goto ERREXIT;
+
+ /* Check Channel Auth params */
+ if ((rbuf[2] & 0x80) != 0) { /*have IPMI 2.0 extended capab*/
+ if ( ((rbuf[4]&0x02) != 0) && ((rbuf[4]&0x01) == 0) ) {
+ if (fdebuglan)
+ fprintf(fpdbg,"GetChanAuth reports only v2 capability\n");
+ rv = LAN_ERR_V2; /*try v2 instead*/
+ goto ERREXIT;
+ }
+ }
+ /* Check authentication support */
+ imsgauth = rbuf[3];
+ if ((imsgauth & 0x10) == 0) pconn->fMsgAuth = 1; /*per-message auth*/
+ else if ((imsgauth & 0x08) == 0) pconn->fMsgAuth = 2; /*user-level auth*/
+ else pconn->fMsgAuth = 0; /*no auth support*/
+ iauthcap = rbuf[2] & 0x3f;
+ if (fauth_type_set) {
+ iauthtype = (uchar)gauth_type; // set by user
+ auth_type = iauthtype;
+ } else {
+ iauthtype = AUTHTYPE_INIT; /*initial value, not set*/
+ }
+ if (auth_type != iauthtype) {
+ /* default of MD5 is preferred, but try what BMC allows */
+ if (iauthcap & IPMI_MASK_AUTHTYPE_MD5) {
+ iauthtype = IPMI_SESSION_AUTHTYPE_MD5;
+ auth_type = iauthtype;
+#ifdef MD2OK
+ } else if (iauthcap & IPMI_MASK_AUTHTYPE_MD2) {
+ iauthtype = IPMI_SESSION_AUTHTYPE_MD2;
+ auth_type = iauthtype;
+ if (fdebuglan)
+ fprintf(fpdbg,"auth_type set to MD2 (%02x)\n",iauthtype);
+#endif
+ } else if (iauthcap & IPMI_MASK_AUTHTYPE_PASSWORD) {
+ iauthtype = IPMI_SESSION_AUTHTYPE_PASSWORD;
+ auth_type = iauthtype;
+ if (fdebuglan)
+ fprintf(fpdbg,"auth_type set to Password (%02x)\n",iauthtype);
+ } else {
+ if (fdebuglan) fprintf(fpdbg,
+ "auth_type set to %02x, using None\n",auth_type);
+ iauthtype = IPMI_SESSION_AUTHTYPE_NONE;
+ auth_type = iauthtype;
+ }
+ }
+ if (fdebuglan) fprintf(fpdbg,
+ "auth_type=%02x(%s) allow=%02x iauthtype=%02x msgAuth=%d(%02x)\n",
+ auth_type,auth_type_str(auth_type),iauthcap,iauthtype,
+ pconn->fMsgAuth,imsgauth);
+
+ /* get session challenge */
+ phdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE;
+ memset(ibuf,0,17);
+ ibuf[0] = iauthtype;
+ if (username != NULL)
+ strncpy(&ibuf[1],username,16);
+ while (busy_tries < BUSY_MAX) {
+ rlen = sizeof(rbuf);
+ rv = _ipmilan_cmd(sfd, destaddr,destaddr_len, CMD_GET_SESSION_CHALLENGE,
+ NETFN_APP,BMC_LUN,bmc_sa, PUBLIC_BUS,
+ ibuf,17, rbuf,&rlen, fdebuglan);
+ cc = rbuf[0];
+ if (rv != 0) break;
+ else if (cc == 0xc0) busy_tries++;
+ else break;
+ }
+ if (fdebuglan) {
+ if ((rv == 0) && (cc == 0))
+ dump_buf("GetSessionChallenge rv=0, rbuf",rbuf,rlen,0);
+ else
+ fprintf(fpdbg,"GetSessionChallenge rv=%d cc=%x rlen=%d tries=%d\n",
+ rv, cc, rlen,busy_tries);
+ }
+ if (rv != 0) goto ERREXIT;
+ else if (cc != 0) { cc_challenge(cc); goto ERREXIT; }
+
+ /* save challenge response data */
+ memcpy(&phdr->sess_id, &rbuf[1], 4);
+ memcpy(phdr->challenge, &rbuf[5], 16);
+
+ /* Save authtype/authcode in ipmi_hdr for later use in _send_lan_cmd. */
+ phdr->bmc_addr = bmc_sa;
+ phdr->auth_type = iauthtype;
+ if (authcode_len > 16 || authcode_len < 0) authcode_len = 16;
+ memset(&ipasswd,0,16);
+ if (authcode != NULL && authcode_len > 0)
+ memcpy(&ipasswd,(uchar *)authcode,authcode_len); /* AuthCode=passwd */
+ memcpy(phdr->password,&ipasswd,16); /* save password */
+
+ /* ActivateSession request */
+ ibuf[0] = phdr->auth_type;
+ ibuf[1] = phdr->priv_level;
+ if (vend_id == VENDOR_SUPERMICRO) {
+ /* if supermicro, do special auth logic here */
+ hash_special(phdr->password, phdr->challenge, ipasswd);
+ memcpy(phdr->password,ipasswd,16);
+ memset(&ibuf[2],0,16); /*zero challenge string here*/
+ if (fdebuglan) printf("Using supermicro OEM challenge\n");
+ } else {
+ memcpy(&ibuf[2],phdr->challenge,16); /*copy challenge string to data*/
+ }
+ phdr->seq_num = 0;
+ iseqn = init_out_seqnum;
+ h2net(iseqn,&ibuf[18],4); /* write iseqn to buffer */
+ ilen = 22;
+ if (fdebuglan) dump_buf("ActivateSession req",ibuf,ilen,0);
+
+ rlen = sizeof(rbuf);
+ rv = _ipmilan_cmd(sfd,destaddr,destaddr_len,CMD_ACTIVATE_SESSION,
+ NETFN_APP,BMC_LUN,bmc_sa, PUBLIC_BUS,
+ ibuf, ilen, rbuf, &rlen, fdebuglan);
+ cc = rbuf[0];
+ if (fdebuglan) {
+ if (rv > 0) fprintf(fpdbg,"ActivateSession rv = 0x%02x\n",rv); /*cc*/
+ else fprintf(fpdbg,"ActivateSession rv = %d\n",rv);
+ }
+ if (rv != 0) goto ERREXIT;
+ else if (cc != 0) { cc_session(cc); goto ERREXIT; }
+
+ if (pconn->fMsgAuth == 2) /*user-level auth*/
+ phdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE;
+
+ memcpy(&phdr->sess_id,&rbuf[2],4); /* save new session id */
+ net2h(&iseqn, &rbuf[6],4); /* save returned out_seq_num */
+ if (iseqn == 0) iseqn = inc_seq_num(iseqn); /* was ++iseqn */
+ phdr->seq_num = iseqn; /* new session seqn */
+ if (fdebuglan)
+ fprintf(fpdbg,"sess_id=%x seq_num=%x priv_allow=%x priv_req=%x\n",
+ phdr->sess_id,phdr->seq_num,rbuf[10],phdr->priv_level);
+
+ /* set session privileges (set_session_privilege_level) */
+ ibuf[0] = phdr->priv_level;
+ rlen = sizeof(rbuf);
+ rv = _ipmilan_cmd(sfd, destaddr, destaddr_len, CMD_SET_SESSION_PRIV,
+ NETFN_APP,BMC_LUN,bmc_sa, PUBLIC_BUS,
+ ibuf,1, rbuf,&rlen, fdebuglan);
+ cc = rbuf[0];
+ if (fdebuglan) fprintf(fpdbg,"SetSessionPriv(%x) rv = %d\n",ibuf[0], rv);
+
+ bridgePossible = 1;
+ *session_id = phdr->sess_id;
+ *session_seqnum = phdr->seq_num;
+ERREXIT:
+ if (rv == 0 && cc != 0) rv = cc;
+ return(rv);
+} /*end ipmilan_open_session*/
+
+/*
+ * ipmilan_close_session
+ */
+static int ipmilan_close_session(SockType sfd, struct sockaddr *destaddr,
+ int destaddr_len, uint32 session_id)
+{
+ uchar ibuf[RQ_LEN_MAX+3];
+ uchar rbuf[RS_LEN_MAX+4];
+ int rlen;
+ int rv = 0;
+
+ if (session_id == 0) return(0);
+ /* send close session command */
+ memcpy(ibuf,&session_id,4);
+ rlen = sizeof(rbuf);
+ bridgePossible = 0;
+ rv = _ipmilan_cmd(sfd, destaddr, destaddr_len, CMD_CLOSE_SESSION,
+ NETFN_APP,BMC_LUN,bmc_sa,PUBLIC_BUS,
+ ibuf,4, rbuf,&rlen, fdebuglan);
+ if (fdebuglan) fprintf(fpdbg,"CloseSession rv = %d, cc = %02x\n",
+ rv, rbuf[0]);
+ if (rbuf[0] != 0) rv = rbuf[0]; /*comp code*/
+ if (rv == 0) pconn->session_id = 0;
+ ipmi_hdr.seq_num = 0;
+ ipmi_hdr.swseq = 1;
+ ipmi_hdr.iseq_num = 0;
+ ipmi_hdr.sess_id = 0;
+ pconn->finsession = 0;
+ return(rv);
+}
+
+
+int rmcp_ping(SockType sfd, struct sockaddr *saddr, int saddr_len, int foutput)
+{
+ /* The ASF spec says to use network byte order */
+ uchar asf_pkt[40] = {06,0,0xFF,06,0x00,0x00,0x11,0xBE,0x80,0,0,0 };
+ struct sockaddr from_addr;
+ int from_len;
+ int rv;
+ int iana;
+
+ /* Send RMCP ASF ping to verify IPMI LAN connection. */
+ asf_pkt[9] = 1; /*tag*/
+ rv = ipmilan_sendto(sfd, asf_pkt, 12, 0, saddr, saddr_len);
+ if (foutput)
+ fprintf(fpdbg,"ipmilan ping, sendto len=%d\n",rv);
+ if (rv < 0) return(LAN_ERR_PING);
+ pconn->connect_state = CONN_STATE_PING; /*ping was sent ok*/
+
+ from_len = sizeof(struct sockaddr);
+ rv = fd_wait(sfd,ping_timeout,0);
+ if (rv != 0) {
+ fprintf(fpdbg,"ping timeout, after %s\n",
+ conn_state_str[pconn->connect_state]);
+ rv = LAN_ERR_CONNECT;
+ } else {
+ rv = ipmilan_recvfrom(sfd, asf_pkt, sizeof(asf_pkt), 0,
+ &from_addr,&from_len);
+ if (foutput) {
+ fprintf(fpdbg,"ipmilan pong, recvfrom len=%d\n", rv);
+ if (rv > 0) {
+ iana = asf_pkt[15] + (asf_pkt[14] << 8) +
+ (asf_pkt[13] << 16) + (asf_pkt[12] << 24);
+ dump_buf("ping response",asf_pkt, rv,0);
+ printf("ping IANA = %d (%s)\n",iana,get_iana_str(iana));
+ }
+ }
+ if (rv < 0) return(LAN_ERR_CONNECT);
+ }
+ return(0);
+}
+
+int ping_bmc(char *node, int fdebugcmd)
+{
+ SOCKADDR_T toaddr;
+ int toaddr_len;
+ SockType sfd;
+ int rv;
+
+ rv = open_sockfd(node,&sfd, &toaddr, &toaddr_len, fdebugcmd);
+ if (rv != 0) return(rv);
+
+ rv = rmcp_ping(sfd, (struct sockaddr *)&toaddr,toaddr_len, fdebugcmd);
+
+ close_sockfd(sfd);
+ return(rv);
+}
+
+static int get_rand(void *data, int len)
+{
+ int rv = 0;
+ int fd;
+
+#if defined(LINUX)
+ fd = open("/dev/urandom", O_RDONLY);
+ if (fd < 0 || len < 0) return errno;
+ rv = read(fd, data, len);
+ close(fd);
+#else
+ fd = rand();
+ if (fd == 0) fd = 1;
+ if (len > sizeof(int)) len = sizeof(int);
+ memcpy(data,&fd,len);
+#endif
+ return rv;
+}
+
+/*
+ * ipmi_open_lan
+ */
+int ipmi_open_lan(char *node, char *user, char *pswd, int fdebugcmd)
+{
+ char *username;
+ uchar priv_level;
+ int rv = -1;
+#ifndef HAVE_IPV6
+ char *temp;
+#endif
+
+#ifndef TEST_LAN
+ fdebuglan = fdebugcmd;
+ if (fdebugcmd) fprintf(fpdbg,"ipmi_open_lan: fdebug = %d\n",fdebugcmd);
+#endif
+ if (fdebugcmd > 2) fdoping = 1;
+ get_mfgid(&vend_id,&prod_id);
+ if (nodeislocal(node)) {
+ fprintf(fpdbg,"ipmi_open_lan: node %s is local!\n",node);
+ rv = LAN_ERR_INVPARAM;
+ goto EXIT;
+ } else {
+
+ if ((gshutdown==0) || fdebugcmd)
+ fprintf(fpdbg,"Opening lan connection to node %s ...\n",node);
+ /* save nodename for sig_abort later */
+ if (strlen(node) > SZGNODE) {
+ strncpy(nodename, node, SZGNODE); nodename[SZGNODE] = 0;
+ } else strcpy(nodename, node);
+
+ rv = open_sockfd(node, &(pconn->sockfd), &_destaddr, &_destaddr_len, 1);
+ if (fdebugcmd)
+ printf("open_sockfd returned %d, fd=%d\n", rv, pconn->sockfd);
+ if (rv != 0) goto EXIT;
+
+#ifdef HAVE_IPV6
+ strcpy(gnodename,nodename);
+ fprintf(fpdbg,"Connecting to node %s\n",gnodename);
+#else
+#ifdef WIN32
+ /* check for ws2_32.lib(getnameinfo) resolution */
+ gnodename[0] = 0;
+/*
+ int getnameinfo( const struct sockaddr * sa, socklen_t salen,
+ char * host, DWORD hostlen,
+ char * serv, DWORD servlen,
+ int flags);
+ rv = getnameinfo((SOCKADDR *)&_destaddr, _destaddr_len,
+ gnodename,SZGNODE, NULL,0,0);
+*/
+#else
+ rv = getnameinfo((struct sockaddr *)&_destaddr, _destaddr_len,
+ gnodename,SZGNODE, NULL,0,0);
+#endif
+ if (rv != 0) {
+ if (fdebugcmd)
+ fprintf(fpdbg,"ipmi_open_lan: getnameinfo rv = %d\n",rv);
+ gnodename[0] = 0;
+ }
+ temp = inet_ntoa(_destaddr.sin_addr);
+ fprintf(fpdbg,"Connecting to node %s %s\n",gnodename, temp);
+ strncpy(_dest_ip, temp, INET_ADDRSTRLEN);
+ _dest_ip[INET_ADDRSTRLEN] = 0;
+#endif
+
+#ifndef WIN32
+ /* Linux: Set up signals to handle errors & timeouts. */
+ signal(SIGINT,sig_abort);
+ signal(SIGALRM,sig_timeout);
+#endif
+
+ pconn->connect_state = CONN_STATE_BIND;
+
+ if (fdoping) {
+ rv = rmcp_ping(pconn->sockfd,(struct sockaddr *)&_destaddr,
+ _destaddr_len, fdebugcmd);
+ if (fdopoke1 && rv != 0) {
+ /* May sometimes need a poke to free up the BMC (cant hurt) */
+ ipmilan_poke1(pconn->sockfd,(struct sockaddr *)&_destaddr,
+ _destaddr_len);
+ }
+
+ if (rv != 0) {
+ if (rv == LAN_ERR_CONNECT && frequireping == 0) {
+ /* keep going even if ping/pong failure */
+ rv = 0;
+ } else {
+ close_sockfd(pconn->sockfd);
+ rv = LAN_ERR_CONNECT;
+ goto EXIT;
+ }
+ }
+ pconn->connect_state = CONN_STATE_PONG;
+ }
+
+ {
+ auth_type = (uchar)gauth_type;
+ priv_level = (uchar)gpriv_level;
+ username = user;
+ authcode = pswd;
+ authcode_len = (pswd) ? strlen_(authcode) : 0;
+ if ((vend_id == VENDOR_INTEL) || (vend_id == VENDOR_IBM))
+ pconn->start_out_seq = 1;
+ else {
+ if (fdebugcmd)
+ printf("calling get_rand(%d)\n", pconn->start_out_seq);
+ get_rand(&pconn->start_out_seq,sizeof(pconn->start_out_seq));
+ }
+ }
+ rv = ipmilan_open_session(pconn->sockfd, (struct sockaddr *)&_destaddr,
+ _destaddr_len, auth_type, username,
+ authcode, authcode_len,priv_level, pconn->start_out_seq,
+ &pconn->in_seq, &pconn->session_id);
+ if (rv == 0) { /* successful (session active) */
+ pconn->connect_state = CONN_STATE_ACTIVE; /*set connection state to active*/
+ } else { /* open_session rv != 0 */
+ if ((gshutdown==0) || fdebugcmd) {
+ if (rv < 0)
+ fprintf(fpdbg,"ipmilan_open_session error, rv = %d\n",rv);
+ else fprintf(fpdbg,"ipmilan_open_session error, rv = 0x%x\n",rv);
+ }
+ close_sockfd(pconn->sockfd);
+ }
+ }
+EXIT:
+ if (rv != 0) {
+ // if ((gshutdown==0) || fdebugcmd)
+ printf("ipmilan %s\n",decode_rv(rv));
+ if (rv == -1 && lasterr != 0) show_LastError("ipmilan",lasterr);
+ }
+ return(rv);
+}
+
+int ipmi_flush_lan(char *node)
+{
+ int rv = 0;
+ /* could match node via pconn = find_conn(node); */
+ if (!nodeislocal(node)) { /* ipmilan, need to close & cleanup */
+ if (pconn->sockfd != 0) close_sockfd(pconn->sockfd);
+ } else { /* kcs cleanup */
+#ifndef WIN32
+ alarm(0);
+ signal(SIGALRM,SIG_DFL);
+#endif
+ } /* endif */
+ pconn->connect_state = CONN_STATE_INIT;
+ pconn->finsession = 0;
+ pconn->session_id = 0;
+ pconn->sockfd = 0;
+ pconn->in_seq = 1;
+ pconn->start_out_seq = 1;
+ pconn->fMsgAuth = 1; /*1=PerMsgAuth*/
+ pconn->auth_type = AUTHTYPE_INIT;
+ return (rv);
+}
+
+int ipmi_close_lan(char *node)
+{
+ int rv = 0;
+
+ /* could match node via pconn = find_conn(node); */
+ if (!nodeislocal(node)) { /* ipmilan, need to close & cleanup */
+ if (pconn->sockfd != 0) { /* socket is open */
+ if (gshutdown) pconn->session_id = 0;
+ if (pconn->session_id != 0) { /* session is open */
+ // cmd_rs = buf_rs;
+ rv = ipmilan_close_session(pconn->sockfd,
+ (struct sockaddr *)&_destaddr,
+ _destaddr_len, ipmi_hdr.sess_id);
+ /* flush session_id even if error, let it time out */
+ pconn->session_id = 0;
+ }
+ close_sockfd(pconn->sockfd);
+ pconn->sockfd = 0;
+ }
+ pconn->connect_state = CONN_STATE_INIT;
+ pconn->finsession = 0;
+ } else { /* kcs cleanup */
+#ifndef WIN32
+ alarm(0);
+ signal(SIGALRM,SIG_DFL);
+#endif
+ } /* endif */
+ return (rv);
+}
+
+/*
+ * ipmicmd_lan
+ * This is called by ipmi_cmd_lan, all commands come through here.
+ */
+int ipmicmd_lan(char *node,
+ uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ uchar rq_data[RQ_LEN_MAX+3];
+ uchar cmd_rs[RS_LEN_MAX+4];
+ uchar cc = 0;
+ int rlen;
+ int rv = -1;
+
+#ifndef TEST_LAN
+ fdebuglan = fdebugcmd;
+#endif
+ /* check sdata/sresp against MAX_ */
+ if (sdata > RQ_LEN_MAX) {
+ if (fdebugcmd) printf("cmd %x sdata(%d) > RQ_LEN_MAX(%d)\n",
+ cmd,sdata,RQ_LEN_MAX);
+ return(LAN_ERR_BADLENGTH);
+ }
+ if (*sresp > RS_LEN_MAX) {
+ if (fdebugcmd) printf("cmd %x sresp(%d) > RS_LEN_MAX(%d), use less\n",
+ cmd,*sresp,RS_LEN_MAX);
+ /* This is ok, just receive up to the max. */
+ *sresp = RS_LEN_MAX;
+ }
+ if (pdata == NULL) { pdata = rq_data; sdata = 0; }
+ rlen = *sresp;
+
+ if (nodeislocal(node)) { /*local, use kcs*/
+ fprintf(fpdbg,"ipmicmd_lan: node %s is local", node);
+ goto EXIT;
+ } else { /* ipmilan */
+ if (pconn->sockfd == 0) { /* closed, do re-open */
+ if (fdebugcmd)
+ fprintf(fpdbg,"sockfd==0, node %s needs re-open\n",node);
+ rv = ipmi_open_lan(gnode, guser, gpswd, fdebugcmd);
+ if (rv != 0) goto EXIT;
+ }
+ if (fdebugcmd) {
+ fprintf(fpdbg,"lan_cmd(seq=%x) %02x %02x %02x %02x, (dlen=%d): ",
+ ipmi_hdr.seq_num, cmd,netfn,lun,sa,sdata);
+ dump_buf("cmd data",pdata,sdata,0);
+ }
+ if (fdebuglan > 2)
+ dbglog("calling _ipmilan_cmd(%02x,%02x)\n",cmd,netfn);
+ rlen = sizeof(cmd_rs);
+ rv = _ipmilan_cmd(pconn->sockfd, (struct sockaddr *)&_destaddr,
+ _destaddr_len, cmd, netfn, lun, sa, bus, pdata, sdata,
+ cmd_rs, &rlen, fdebugcmd);
+ }
+
+ cc = cmd_rs[0];
+ if (rv == 0 && cc == 0) { /* success */
+ if (fdebugcmd) {
+ fprintf(fpdbg,"lan_rsp rv=0 cc=0 (rlen=%d): ",rlen);
+ dump_buf("cmd rsp",cmd_rs,rlen,0);
+ }
+ rlen--;
+ if (rlen > *sresp) { /*received data > receive buffer*/
+ if (fdebugcmd)
+ printf("rlen(%d) > sresp(%d), truncated\n",rlen,*sresp);
+ rlen = *sresp;
+ }
+ memcpy(presp,&cmd_rs[1],rlen);
+ *sresp = rlen;
+ } else { /* error */
+ if (fdebugcmd)
+ fprintf(fpdbg,"ipmicmd_lan: cmd=%02x rv=%d, cc=%02x, rlen=%d\n",
+ cmd,rv,cc,rlen);
+ presp[0] = 0; /*memset(presp,0,*sresp);*/
+ *sresp = 0;
+ }
+
+EXIT:
+ *pcc = cc;
+ return(rv);
+} /*end ipmicmd_lan()*/
+
+/*
+ * ipmi_cmd_lan
+ * This is the entry point, called from ipmicmd.c
+ */
+int ipmi_cmd_lan(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+ uchar mycmd;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ fprintf(fperr, "ipmi_cmd_lan: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) mycmd = (uchar)(cmd & CMDMASK); /* unmask it */
+ else mycmd = (uchar)cmd;
+ if (fdebuglan > 2)
+ dbglog("ipmi_cmd_lan: cmd=%04x, mycmd=%02x\n",cmd,mycmd);
+ rc = ipmicmd_lan(node,mycmd,ipmi_cmds[i].netfn,ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return (rc);
+}
+
+int ipmi_cmdraw_lan(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ int rc;
+ if (fdebuglan > 2)
+ dbglog("ipmi_cmdraw_lan: cmd=%02x, netfn=%02x\n",cmd,netfn);
+ /* bus is not used for lan */
+ rc = ipmicmd_lan(node, cmd, netfn, lun, sa, bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return (rc);
+}
+
+
+SockType lan_get_fd(void)
+{
+ return(pconn->sockfd);
+}
+
+/* static SOL v1.5 encryption routines */
+
+static void sol15_cipherinit( uchar SeedCount, char *password, uint32 out_seq)
+{
+ uchar temp[ 40 ]; /* 16 + 4 + 8 + 4 = 32 bytes */
+ int i;
+
+ i = SeedCount & 0x0f;
+
+ srand((unsigned int)time(NULL));
+ g_Seed[i] = (int32_t)rand();
+
+ if (password == NULL)
+ memset(&temp[0], 0, 16);
+ else memcpy(&temp[0], password,16); /*16-byte password*/
+ h2net(g_Seed[i],&temp[16],4); /*4-byte seed */
+ memset(&temp[20], 0, 8 ); /*8-byte pad*/
+ h2net(out_seq,&temp[28],4); /*4-byte seq num */
+ md5_sum(temp,32, g_Cipher[i]);
+}
+
+#ifdef NOT_USED
+static void sol15_encrypt( uchar *dst, uchar *src, int len, uchar SeedCount )
+{
+ uchar cipher;
+ unsigned int val;
+ int i;
+
+ SeedCount &= 0x0f;
+ if ( sol_Encryption ) {
+ for (i = 0; i < len; i++, dst++, src++) {
+ cipher = g_Cipher[ SeedCount ][ (i & 0x0f) ];
+ val = (*src) << (cipher & 0x07);
+ *dst = (uchar)((val | (val >> 8)) ^ cipher);
+ }
+ } else {
+ memcpy( dst, src, len );
+ }
+}
+
+static void sol15_decrypt( uchar *dst, uchar *src, int len, uchar SeedCount )
+{
+ uchar cipher;
+ unsigned int val;
+ int i;
+ SeedCount &= 0x0f;
+ if ( sol_Encryption ) {
+ for (i = 0; i < len; i++, dst++, src++) {
+ cipher = g_Cipher[ SeedCount ][ (i & 0x0f) ];
+ val = ((*src) ^ cipher) << 8;
+ val >>= (cipher & 0x07);
+ *dst = (uchar)((val >> 8) | val);
+ }
+ } else {
+ memcpy( dst, src, len );
+ }
+}
+#endif
+
+/*
+ * lan_get_sol_data
+ * Called before ACTIVATE_SOL1 command
+ */
+void lan_get_sol_data(uchar fEnc, uchar seed_cnt, uint32 *seed)
+{
+ if (seed_cnt != sol_seed_cnt && (seed_cnt < 16))
+ sol_seed_cnt = seed_cnt;
+ pconn->start_out_seq = ipmi_hdr.seq_num;
+ sol_snd_seq = (uchar)pconn->start_out_seq;
+ sol15_cipherinit(sol_seed_cnt, gpswd, pconn->start_out_seq);
+ *seed = g_Seed[sol_seed_cnt];
+ if (fdebuglan > 2)
+ dbglog("lan_get_sol_data: %02x %02x %02x\n", /*SOL*/
+ fEnc, seed_cnt, ipmi_hdr.seq_num);
+}
+
+/*
+ * lan_set_sol_data
+ * Called after ACTIVATE_SOL1 response received
+ */
+void lan_set_sol_data(uchar fenc, uchar auth, uchar seed_cnt,
+ int insize, int outsize)
+{
+ if (fdebuglan > 2)
+ dbglog("lan_set_sol_data: %02x %02x %02x %02x\n", /*SOL*/
+ auth,seed_cnt,insize,outsize);
+ if (fenc || (auth & 0x07) == 1) {
+ sol_op = 0x80; /*OEM encryption*/
+ sol_Encryption = 1;
+ } else {
+ sol_op = 0x00; /*no encryption*/
+ sol_Encryption = 0;
+ }
+ if (seed_cnt != sol_seed_cnt && (seed_cnt < 16)) {
+ /* if seed count changed, re-init the cipher. */
+ sol_seed_cnt = seed_cnt;
+ sol15_cipherinit(sol_seed_cnt, gpswd, pconn->start_out_seq);
+ }
+}
+
+/*
+ * lan_send_sol
+ * buffer contains characters entered at console.
+ * build an SOL data frame, which ends up
+ * calling _send_lan_cmd().
+ *
+ * SOL 1.5 Message Format
+ * 0 : Packet Sequence Number
+ * 1 : Packet ack/nak seq num (recvd)
+ * 2 : Character offset (of recvd)
+ * 3 : Seed count
+ * 4 : Operation/Status
+ */
+int lan_send_sol( uchar *buffer, int len, SOL_RSP_PKT *rsp)
+{
+ int rv = -1;
+ int ilen;
+ uchar idata[IPMI_REQBUF_SIZE]; /*=80 bytes*/
+ uchar *pdata;
+ int hlen, msglen;
+ int sz;
+ IPMI_HDR *phdr;
+ int fdoauth = 1;
+ uchar iauth[16];
+ uint32 sess_id_tmp;
+ uchar *psessid;
+ int flags;
+
+ phdr = &ipmi_hdr;
+ hlen = 4 + 10 + 16; // was SOL_HLEN (14);
+
+ pdata = &idata[0];
+ memset(pdata,0,hlen);
+ memcpy(&pdata[0], phdr, 4); /* copy RMCP header to buffer */
+ if (phdr->auth_type == IPMI_SESSION_AUTHTYPE_NONE) fdoauth = 0;
+ else fdoauth = 1;
+ if (fdoauth == 0 && phdr->auth_type != IPMI_SESSION_AUTHTYPE_NONE)
+ pdata[4] = IPMI_SESSION_AUTHTYPE_NONE;
+ else pdata[4] = phdr->auth_type;
+ memcpy(&pdata[5],&phdr->seq_num,4); /*session sequence number*/
+ sess_id_tmp = phdr->sess_id | SOL_MSG;
+ memcpy(&pdata[9],&sess_id_tmp,4); /*session id*/
+ if (fdoauth == 0) hlen -= 16;
+
+ pdata = &idata[hlen];
+ if (len == 0) {
+ pdata[0] = 0x00; /*ack for keepalive*/
+ } else {
+ sol_snd_seq = (uchar)inc_sol_seq(sol_snd_seq);
+ pdata[0] = sol_snd_seq;
+ // sol15_encrypt(&pdata[5],buffer,len, sol_seed_cnt);
+ memcpy(&pdata[5],buffer,len);
+ }
+ pdata[1] = sol_rcv_seq; /* seq to ack*/
+ pdata[2] = sol_rcv_cnt; /* num bytes ack'd */
+ pdata[3] = sol_seed_cnt;
+ pdata[4] = 0x00; /*Operation/Status*/
+ msglen = len + 5;
+ {
+ if (fdebuglan > 2) { /*SOL*/
+ dbg_dump("lan_send_sol input", buffer,len,1);
+ dbglog("auth_type=%x/%x fdoauth=%d hlen=%d seq_num=%x enc=%d\n",
+ phdr->auth_type,gauth_type,fdoauth,hlen,phdr->seq_num,
+ sol_Encryption);
+ dbg_dump("send_sol buf", pdata,msglen,1);
+ }
+ if (fdoauth) {
+ psessid = (uchar *)&sess_id_tmp;
+ do_hash(phdr->password, psessid, &idata[hlen],msglen,
+ phdr->seq_num, phdr->auth_type, iauth);
+ /* copy hashed authcode to header */
+ memcpy(&pdata[13],iauth,16);
+ }
+ }
+ idata[hlen-1] = (uchar)msglen;
+ ilen = hlen + msglen;
+ // rlen = sizeof(rdata);;
+
+ if (fdebuglan > 2)
+ dbg_dump("lan_send_sol sendto",idata,ilen,1);
+ flags = 0;
+ sz = ipmilan_sendto(pconn->sockfd,idata,ilen,flags,
+ (struct sockaddr *)&_destaddr,_destaddr_len);
+ if (fdebuglan) dbglog("lan_send_sol, sent %d bytes\n",sz);
+ if (sz < 1) {
+ lasterr = get_LastError();
+ if (fdebuglan) show_LastError("lan_send_sol",lasterr);
+ rv = LAN_ERR_SEND_FAIL;
+ os_usleep(0,5000);
+ }
+ else {
+ phdr->seq_num = inc_seq_num( phdr->seq_num );
+ rv = 0;
+ }
+
+ if (rsp != NULL) {
+ rsp->len = 0;
+#ifdef RCV_EXTRA
+ if (rv == 0) { /*send was ok, try to receive*/
+ rv = lan_recv_sol( rsp );
+ if (fdebuglan) printf("lan_recv_sol ret = %d, len = %d\n",rv,rsp->len);
+ }
+#endif
+ }
+ return(rv);
+}
+
+int lan_keepalive( uchar bType )
+{
+ int rv = 0;
+#ifdef KAL_OK
+ if (bType == 2) {
+ /* don't try if no data sent yet */
+ if (sol_snd_seq == 0) return(rv);
+ /* use lan_send_sol, but with 0 length data */
+ rv = lan_send_sol(NULL,0,NULL);
+ }
+ else
+#endif
+ {
+ uchar devrec[16];
+ rv = ipmi_getdeviceid(devrec,16,0);
+ }
+ return(rv);
+}
+
+int lan_recv_sol( SOL_RSP_PKT *rsp )
+{
+ static uchar rsdata[MAX_BUFFER_SIZE]; /*LANplus allows 1024*/
+ uchar rdata[MAX_BUFFER_SIZE];
+ int rlen, hlen;
+ IPMI_HDR *phdr;
+ int fdoauth = 1;
+ uchar *pdata;
+ int itry;
+ int flags;
+ int rv = -1;
+
+ phdr = &ipmi_hdr;
+ rsp->data = rsdata;
+ fdoauth = 0;
+ hlen = SOL_HLEN;
+ rlen = 0;
+ if (fdebuglan)
+ printf("lan_recv_sol, fdebug=%d, fpdbg=%p\n",fdebuglan,fpdbg);
+ // for (itry = 0; (itry < ipmi_try) && (rlen == 0); itry++)
+ for (itry = 0; (itry < 1) && (rlen == 0); itry++)
+ {
+ /* receive the response */
+ rv = fd_wait(pconn->sockfd, ipmi_timeout,0);
+ if (rv != 0) {
+ if (fdebuglan) fprintf(fpdbg,"lan_recv_sol timeout\n");
+ rv = LAN_ERR_RECV_FAIL;
+ os_usleep(0,5000);
+ continue; /* ok to retry */
+ }
+ flags = RECV_MSG_FLAGS;
+ rlen = ipmilan_recvfrom(pconn->sockfd,rdata,sizeof(rdata),flags,
+ (struct sockaddr *)&_destaddr,&_destaddr_len);
+ if (rlen < 0) {
+ lasterr = get_LastError();
+ if (fdebuglan) show_LastError("ipmilan_recvfrom",lasterr);
+ rv = rlen; /* -3 = LAN_ERR_RECV_FAIL */
+ rlen = 0;
+ rsp->len = rlen;
+ if (lasterr == econnrefused) continue; /*try again*/
+ else break; /* goto EXIT; */
+ } else { /* successful receive */
+ rv = 0;
+ if (fdebuglan) {
+ dump_buf("lan_recv_sol rdata",rdata,rlen,1); /*SOL*/
+ }
+ if (rdata[4] == IPMI_SESSION_AUTHTYPE_NONE) { /* if AUTH_NONE */
+ /* may have tried with auth, but denied, Dell 1855 */
+ phdr->auth_type = IPMI_SESSION_AUTHTYPE_NONE;
+ hlen = SOL_HLEN;
+ }
+ net2h(&phdr->iseq_num,&rdata[5],4); /*incoming seq_num from hdr*/
+ if (rlen >= hlen) {
+ pdata = &rdata[hlen];
+ if (fdebuglan)
+ dump_buf("lan_recv_sol rsp",rdata,rlen,1); /*SOL*/
+ rlen -= hlen;
+ if (rlen >= 5) { /*have some data*/
+ /* 0=seq, 1=ack, 2=cnt, 3=ctl, 4=rsv */
+ sol_rcv_seq = pdata[0];
+ sol_rcv_ctl = pdata[3];
+ pdata = &rdata[hlen+5];
+ rlen -= 5;
+ /* rlen should match rdata[hlen-1] */
+ sol_rcv_cnt = (uchar)rlen;
+ }
+ rsp->type = PAYLOAD_TYPE_SOL;
+ rsp->len = rlen;
+ // sol15_decrypt(rsp->data,pdata,rlen, sol_seed_cnt);
+ memcpy(rsp->data,pdata,rlen);
+ } else {
+ if (fdebuglan)
+ printf("lan_recv_sol rlen %d < %d\n",rlen,hlen); /*fpdbg*/
+ rsp->type = PAYLOAD_TYPE_SOL;
+ rsp->len = 0;
+ }
+ break;
+ }
+ } /*end for*/
+ return(rv);
+}
+#endif
+
+uchar
+cksum(const uchar *buf, register int len)
+{
+ register uchar csum;
+ register int i;
+
+ /* 8-bit 2s compliment checksum */
+ csum = 0;
+ for (i = 0; i < len; i++)
+ csum = (csum + buf[i]) % 256;
+ csum = -csum;
+ return(csum);
+}
+
+/*
+ * ipmi_cmd_ipmb()
+ * This is an entry point for IPMB indirect commands.
+ * Embed the command withn a SendMessage command.
+ *
+ * The iseq value needs to be the same as ipmi_hdr.swseq if
+ * the session is ipmilan, so this routine was moved here.
+ * However, ipmi_cmd_ipmb will also work ok via ipmi_cmdraw
+ * for local commands.
+ */
+int ipmi_cmd_ipmb(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i, j;
+ uchar idata[IPMI_REQBUF_SIZE];
+ uchar rdata[MAX_BUFFER_SIZE];
+ uchar ilen;
+ int rlen;
+ uchar iseq;
+ IPMI_HDR *phdr;
+ char *pstr;
+ uchar fneedclear = 0;
+ uchar cc;
+
+ if (fdebugcmd) printf("ipmi_cmd_ipmb(%02x,%02x,%02x,%02x,%02x) sdata=%d\n",
+ cmd,netfn,sa,bus,lun,sdata);
+ phdr = &ipmi_hdr;
+ iseq = phdr->swseq;
+ i = 0;
+ idata[i++] = bus;
+ j = i;
+ idata[i++] = sa; /*rsAddr (target)*/
+ idata[i++] = (netfn << 2) | (lun & 0x03); /*metFm/rsLUN*/
+ idata[i++] = cksum(&idata[j],2);
+ j = i;
+ idata[i++] = bmc_sa; /* rqAddr (main sa) */
+ idata[i++] = (iseq << 2) | SMS_LUN; /*rqSeq num, SMS Message LUN = 0x02*/
+ idata[i++] = cmd;
+ if (sdata > 0) {
+ memcpy(&idata[i],pdata,sdata);
+ i += sdata;
+ }
+ idata[i] = cksum(&idata[j],(i - j));
+ ilen = ++i;
+ rlen = sizeof(rdata);
+ rc = ipmi_cmdraw(IPMB_SEND_MESSAGE,NETFN_APP, bmc_sa,PUBLIC_BUS,BMC_LUN,
+ idata, ilen, rdata, &rlen, pcc, fdebugcmd);
+ if (rc == 0x83 || *pcc == 0x83) { /*retry*/
+ rlen = sizeof(rdata);
+ rc = ipmi_cmdraw(IPMB_SEND_MESSAGE,NETFN_APP, bmc_sa,PUBLIC_BUS,BMC_LUN,
+ idata, ilen, rdata, &rlen, pcc, fdebugcmd);
+ }
+ if (fdebugcmd) {
+ if (rc == 0 && *pcc == 0)
+ dump_buf("ipmb sendmsg ok",rdata,rlen,0);
+ else {
+ if (*pcc == 0x80) { pstr = "Invalid session handle"; }
+ else if (*pcc == 0x81) pstr = "Lost Arbitration";
+ else if (*pcc == 0x82) pstr = "Bus Error";
+ else if (*pcc == 0x83) pstr = "NAK on Write";
+ else pstr = "";
+ fprintf(fpdbg,"ipmb sendmsg error %d, cc %x %s\n",rc,*pcc,pstr);
+ }
+ }
+ if (presp == NULL || sresp == NULL) return(LAN_ERR_INVPARAM);
+ if (rc != 0 || *pcc != 0) { *sresp = 0; return(rc); }
+ if (*sresp < 0) return(LAN_ERR_TOO_SHORT);
+
+ /* sent ok, now issue a GET_MESSAGE command to get the response. */
+ for (i = 0; i < 10; i++)
+ {
+ rlen = sizeof(rdata);
+ rc = ipmi_cmdraw(IPMB_GET_MESSAGE,NETFN_APP, bmc_sa,PUBLIC_BUS,BMC_LUN,
+ idata, 0, rdata, &rlen, pcc, fdebugcmd);
+ if (fdebugcmd) printf("ipmb get_message rc=%d cc=%x\n",rc,*pcc);
+ if (rc == 0x80 || *pcc == 0x80) /*empty, so retry*/;
+ else if (rc == 0x83 || *pcc == 0x83) /*busy, so retry*/;
+ else break; /* done w success or error */
+#ifdef DOS
+ ; /*short wait*/
+#else
+ fd_wait(0,0,10); /* wait 1 msec before retry */
+#endif
+ /* will retry up to 10 msec for a get_message response on ipmb */
+ }
+ if (rc == 0 && *pcc == 0) {
+ if (fdebugcmd)
+ dump_buf("ipmb getmsg ok",rdata,rlen,0);
+ i = 0;
+ if (rlen >= 8) { /* strip out the getmsg header */
+ *pcc = rdata[6];
+ rlen -= 8;
+ i = 7;
+ }
+ /* copy the data */
+ if (rlen > *sresp) rlen = *sresp;
+ memcpy(presp,&rdata[i],rlen);
+ } else {
+ if (*pcc == 0x80) pstr = "buffer empty";
+ else { fneedclear = 1; pstr = ""; }
+ if (fdebugcmd)
+ fprintf(fpdbg,"ipmb getmsg[%d] error %d, cc %x %s\n",i,rc,*pcc,pstr);
+ if (fneedclear) { /* Clear pending message flags */
+ idata[0] = 0x03; /* clear EvtMsgBuf & RecvMsgQueue */
+ rlen = 16;
+ rc = ipmi_cmdraw(IPMB_CLEAR_MSGF, NETFN_APP,
+ bmc_sa, PUBLIC_BUS,BMC_LUN,
+ idata, 1, rdata, &rlen, &cc, fdebugcmd);
+ }
+ rlen = 0;
+ }
+ *sresp = rlen;
+ return(rc);
+}
+/* end ipmilan.c */
+
diff --git a/util/ipmilan.h b/util/ipmilan.h
new file mode 100644
index 0000000..9e92e55
--- /dev/null
+++ b/util/ipmilan.h
@@ -0,0 +1,83 @@
+/***********************************************
+ * ipmilan.h
+ *
+ * Definitions and data structures for the
+ * IPMI LAN interface
+ *
+ ***********************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifndef IPMILAN_H_
+#define IPMILAN_H_
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 64
+#endif
+#define SOL_HDR_LEN 30 /*SOL 1.5 HDR: 4(rmcp) + 9 + 1 + 5(sol) */
+#define RQ_HDR_LEN 30
+#define RQ_LEN_MAX 200 /*see IPMI_REQBUF_SIZE, was 25 */
+#define RS_LEN_MAX 200 /*see IPMI_RSPBUF_SIZE */
+/* Note that the send buffer is [RQ_LEN_MAX+RQ_HDR_LEN+7] = 62 */
+/* Note that the receive buffer is [RS_LEN_MAX+RQ_HDR_LEN+7] = 237 */
+#define SEND_BUF_SZ (RQ_LEN_MAX+RQ_HDR_LEN+7+8+8) /*RQ_LEN+53= 78*/
+#define RECV_BUF_SZ (RS_LEN_MAX+RQ_HDR_LEN+7+8+8) /*RS_LEN+53=253*/
+/* #define IPMI_LAN_SEQ_NUM_MAX 0x3F * only for gnulan */
+#define RMCP_PRI_RMCP_PORT 0x26F
+
+#define PAYLOAD_TYPE_SOL 0x01
+
+/* IPMI commands used for LAN sessions */
+#define CMD_GET_CHAN_AUTH_CAP 0x38
+#define CMD_GET_SESSION_CHALLENGE 0x39
+#define CMD_ACTIVATE_SESSION 0x3A
+#define CMD_SET_SESSION_PRIV 0x3B
+#define CMD_CLOSE_SESSION 0x3C
+#define CMD_GET_MESSAGE 0x33
+#define CMD_SEND_MESSAGE 0x34
+
+/* see ipmicmd.h for LAN_ERR definitions */
+
+int ipmi_open_lan(char *node, char *user, char *pswd, int fdebugcmd);
+int ipmi_close_lan(char *node);
+int ipmi_flush_lan(char *node);
+int ipmi_cmd_lan(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+int ipmi_cmdraw_lan(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd);
+int ipmicmd_lan(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd);
+int ipmi_cmd_ipmb(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+
+#endif // IPMILAN_H_
diff --git a/util/ipmilan2.c b/util/ipmilan2.c
new file mode 100644
index 0000000..0ff2fac
--- /dev/null
+++ b/util/ipmilan2.c
@@ -0,0 +1,68 @@
+/*
+ * ipmilan2.c
+ *
+ * Interface to call libintf_lanplus from ipmitool to do RMCP+ protocol.
+ *
+ * 01/09/07 Andy Cress - created
+ * 02/22/07 Andy Cress - initialize cipher_suite to 3 (was 0)
+ */
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <time.h>
+#if defined(LINUX) || defined(BSD)
+#include <sys/time.h>
+#endif
+
+#undef HAVE_LANPLUS
+
+// #define DEBUG 1
+#ifndef HAVE_LANPLUS
+/* No lanplus, so stub these functions returning errors. */
+#define uchar unsigned char
+#define ushort unsigned short
+#define LAN_ERR_INVPARAM -8
+#define LOG_WARN 4
+#define LOG_MSG_LENGTH 1024 /*usu. ipmicmd.h*/
+int verbose = 0;
+char fdbglog = 0;
+void set_loglevel(int level);
+void lprintf(int level, const char * format, ...);
+
+int ipmi_open_lan2(char *node, char *user, char *pswd, int fdebugcmd)
+{ if (fdebugcmd) verbose = 1; return(LAN_ERR_INVPARAM); }
+
+int ipmi_close_lan2(char *node)
+{ return(LAN_ERR_INVPARAM); }
+
+int ipmi_cmdraw_lan2(char *node, uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{ return(LAN_ERR_INVPARAM); }
+
+int ipmi_cmd_lan2(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{ return(LAN_ERR_INVPARAM); }
+
+int lan2_send_sol( uchar *payload, int len, void *rsp)
+{ return(LAN_ERR_INVPARAM); }
+int lan2_recv_sol( void *rsp )
+{ return(LAN_ERR_INVPARAM); }
+int lan2_keepalive(int type, void *rsp)
+{ return(LAN_ERR_INVPARAM); }
+void lan2_recv_handler( void *rs )
+{ return; }
+void lan2_set_sol_data(int insize, int outsize, int port, void *handler,
+ char esc_char)
+{ return; }
+int lan2_get_fd(void) { return(1); }
+void lanplus_set_recvdelay( int delay ) { return; }
+long lan2_get_latency( void ) { return(1); }
+int lan2_send_break( void *rsp) { return(LAN_ERR_INVPARAM); }
+int lan2_send_ctlaltdel( void *rsp) { return(LAN_ERR_INVPARAM); }
+
+#else /* else HAVE_LANPLUS is defined */
+
+#endif
+
+/* end ipmilan2.c */
diff --git a/util/ipmilan2.h b/util/ipmilan2.h
new file mode 100644
index 0000000..aaa5318
--- /dev/null
+++ b/util/ipmilan2.h
@@ -0,0 +1,62 @@
+/***********************************************
+ * ipmilan2.h
+ *
+ * Definitions and data structures for the
+ * IPMI 2.0 LAN interface
+ *
+ ***********************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifndef IPMILAN2_H_
+#define IPMILAN2_H_
+
+#include "ipmilan.h"
+
+#define IPMI_AUTH_RAKP_NONE 0x00
+#define IPMI_INTEGRITY_NONE 0x00
+#define IPMI_CRYPT_NONE 0x00
+
+int ipmi_open_lan2(char *node, char *user, char *pswd, int fdebugcmd);
+int ipmi_close_lan2(char *node);
+int ipmi_cmd_lan2(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd);
+int ipmi_cmdraw_lan2(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd);
+int ipmicmd_lan2(char *node, uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd);
+int ipmi_cmd_ipmb2(uchar cmd, uchar netfn, uchar sa, uchar bus, uchar lun,
+ uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd);
+
+
+#endif // IPMILAN2_H_
diff --git a/util/ipmilanplus.c b/util/ipmilanplus.c
new file mode 100644
index 0000000..771c7e7
--- /dev/null
+++ b/util/ipmilanplus.c
@@ -0,0 +1,790 @@
+/*
+ * ipmilanplus.c
+ *
+ * Interface to call libintf_lanplus from ipmitool to do RMCP+ protocol.
+ *
+ * 01/09/07 Andy Cress - created
+ * 02/22/07 Andy Cress - initialize cipher_suite to 3 (was 0)
+ */
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <time.h>
+#if defined(LINUX) || defined(BSD) || defined(MACOS)
+#include <sys/time.h>
+#endif
+
+// #define DEBUG 1
+int verbose = 0;
+char fdbglog = 0;
+
+#ifndef HAVE_LANPLUS
+#ifdef WIN32
+#include <windows.h>
+extern int strncasecmp(char *s1, char *s2, int n); /*ipmicmd.c*/
+#define snprintf _snprintf
+#define SockType SOCKET
+#else
+#define SockType int
+#endif
+/* No lanplus, so stub these functions returning errors. */
+#define uchar unsigned char
+#define ushort unsigned short
+#define LAN_ERR_INVPARAM -8
+#define LOG_MSG_LENGTH 1024 /*usu. ipmicmd.h*/
+struct valstr { /*usually in ipmicmd.h*/
+ ushort val;
+ char * str;
+};
+struct oemvalstr {
+ unsigned int oem;
+ ushort val;
+ const char * str;
+};
+int ipmi_open_lan2(char *node, char *user, char *pswd, int fdebugcmd)
+{ if (fdebugcmd) verbose = 1; return(LAN_ERR_INVPARAM); }
+
+int ipmi_close_lan2(char *node)
+{ return(LAN_ERR_INVPARAM); }
+
+int ipmi_cmdraw_lan2(char *node, uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{ return(LAN_ERR_INVPARAM); }
+
+int ipmi_cmd_lan2(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{ return(LAN_ERR_INVPARAM); }
+
+int lan2_send_sol( uchar *payload, int len, void *rsp)
+{ return(LAN_ERR_INVPARAM); }
+int lan2_recv_sol( void *rsp )
+{ return(LAN_ERR_INVPARAM); }
+int lan2_keepalive(int type, void *rsp)
+{ return(LAN_ERR_INVPARAM); }
+void lan2_recv_handler( void *rs )
+{ return; }
+void lan2_set_sol_data(int insize, int outsize, int port, void *handler,
+ char esc_char)
+{ return; }
+SockType lan2_get_fd(void) { return(1); }
+void lanplus_set_recvdelay( int delay ) { return; }
+long lan2_get_latency( void ) { return(1); }
+int lan2_send_break( void *rsp) { return(LAN_ERR_INVPARAM); }
+int lan2_send_ctlaltdel( void *rsp) { return(LAN_ERR_INVPARAM); }
+
+#else /* else HAVE_LANPLUS is defined */
+
+#include "ipmilanplus.h"
+#include "ipmicmd.h"
+void set_loglevel(int level); /*defined in subs.c*/
+void lprintf(int level, const char * format, ...);
+// #define LOG_WARN 4
+// #define LOG_INFO 6
+
+#ifdef METACOMMAND
+extern void dbglog( char *pattn, ... ); /*from isolconsole.c*/
+extern void sol_output_handler(void *rsp); /*from isolconsole.c*/
+extern void dbg_dump(char *tag, uchar *pdata, int len, int fascii);
+#else
+static void dbglog( char *pattn, ... ) { return; }
+static void sol_output_handler(void *rsp) { return; }
+static void dbg_dump(char *tag, uchar *pdata, int len, int fascii) { return; }
+#endif
+int ipmi_close_lan2(char *node); /*prototype*/
+extern char *gnode; /* from ipmicmd.c */
+extern char *guser; /* from ipmicmd.c */
+extern char *gpswd; /* from ipmicmd.c */
+extern int gauth_type; /* from ipmicmd.c */
+extern int gpriv_level; /* from ipmicmd.c */
+extern int gshutdown; /* from ipmicmd.c */
+extern int gcipher_suite; /*from ipmicmd.c, see table 22-19 IPMI 2.0 spec*/
+extern FILE *fpdbg; /* == stdout, from ipmicmd.c */
+extern FILE *fperr; /* == stderr, from ipmicmd.c */
+extern FILE *fplog; /* from ipmicmd.c */
+extern ipmi_cmd_t ipmi_cmds[]; /* from ipmicmd.c */
+//extern char lan2_nodename[]; /*from lib/lanplus/lanplus.c */
+extern struct ipmi_intf ipmi_lanplus_intf; /*from libintf_lanplus.a*/
+
+typedef struct {
+ int type;
+ int len;
+ char *data;
+ } SOL_RSP_PKT;
+typedef struct {
+ struct ipmi_intf *intf;
+ SockType lan2_fd;
+ uchar sol_seq; /*sending SOL sequence num, will call inc_sol_seq*/
+ uchar sol_len; /*sending SOL num chars */
+ uchar sol_seq_acked; /*last acked sent SOL sequence num*/
+ uchar sol_rseq; /*received SOL sequence num*/
+ uchar sol_rlen; /*received SOL num chans*/
+ } LAN2_CONN; /*see also IPMI_HDR below*/
+
+static int loglvl = LOG_WARN; /*3=LOG_ERR 4=LOG_WARN 6=LOG_INFO 7=LOG_DEBUG*/
+static LAN2_CONN conn = {NULL,0,0,0,0,0,0};
+static LAN2_CONN *pconn = &conn;
+// static SockType lan2_fd = 0;
+// static struct ipmi_intf *intf = NULL;
+static uchar sol_seq = 0; /*sending SOL sequence num, will call inc_sol_seq*/
+static uchar sol_len = 0; /*sending SOL num chars */
+static uchar sol_seq_acked = 0; /*last acked sent SOL sequence num*/
+static uchar sol_rseq = 0; /*received SOL sequence num*/
+static uchar sol_rlen = 0; /*received SOL num chans*/
+static uchar chars_to_resend = 0;
+static long lan2_latency = 0;
+
+// #define LAN_ERR_INVPARAM -8
+#define PSWD_MAX 16
+
+#if defined(WIN32)
+/* Windows does not have gettimeofday, so do it here */
+#include <windows.h>
+#define UNIX_EPOCH_USEC 11644473600000000ULL
+struct timezone
+{
+ int tz_minuteswest;
+ int tz_dsttime;
+};
+
+int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+ FILETIME ft;
+ unsigned __int64 nusec, tmpres = 0;
+ static int tzflag = 0;
+
+ if (tv != NULL) {
+ GetSystemTimeAsFileTime(&ft);
+ tmpres |= ft.dwHighDateTime;
+ tmpres <<= 32;
+ tmpres |= ft.dwLowDateTime;
+ nusec = tmpres / 10; /*convert 100-nanosec into microseconds*/
+ nusec -= UNIX_EPOCH_USEC; /*windows -> unix epoch*/
+ tv->tv_sec = (long)(nusec / 1000000UL);
+ tv->tv_usec = (long)(nusec % 1000000UL);
+ }
+
+ if (tz != NULL) {
+ if (!tzflag) {
+ _tzset();
+ tzflag++;
+ }
+ tz->tz_minuteswest = _timezone / 60;
+ tz->tz_dsttime = _daylight;
+ }
+ return 0;
+}
+#endif
+
+#if defined(WIN32) || defined(SOLARIS)
+#ifdef OLD
+/* Now moved to lib/lanplus/lanplus.c */
+void ipmilanplus_init(struct ipmi_intf *intf)
+{
+ strcpy(intf->name,"lanplus");
+ intf->setup = ipmi_lanplus_setup;
+ intf->open = ipmi_lanplus_open;
+ intf->close = ipmi_lanplus_close;
+ intf->sendrecv = ipmi_lanplus_send_ipmi_cmd;
+ intf->recv_sol = ipmi_lanplus_recv_sol;
+ intf->send_sol = ipmi_lanplus_send_sol;
+ intf->keepalive = ipmi_lanplus_keepalive;
+ intf->target_addr = IPMI_BMC_SLAVE_ADDR; /*0x20*/
+ intf->my_addr = IPMI_BMC_SLAVE_ADDR; /*0x20*/
+}
+#else
+extern void ipmilanplus_init(struct ipmi_intf *intf);
+#endif
+#endif
+
+struct ipmi_intf * ipmi_intf_load(char * name)
+{
+ if (strcmp(name,"lanplus") == 0) {
+#if defined(WIN32) || defined(SOLARIS)
+ /* initialize the intf */
+ ipmilanplus_init(&ipmi_lanplus_intf);
+#endif
+ return (&ipmi_lanplus_intf);
+ }
+ else return (NULL);
+}
+
+long lan2_get_latency(void)
+{
+ return(lan2_latency);
+}
+
+static void set_latency( struct timeval *t1, struct timeval *t2, long *latency)
+{
+ long nsec;
+ nsec = t2->tv_sec - t1->tv_sec;
+ if ((ulong)(nsec) > 1) nsec = 1;
+ *latency = nsec*1000 + (t2->tv_usec - t1->tv_usec)/1000;
+}
+
+/*
+ * ipmi_open_lan2
+ */
+int ipmi_open_lan2(char *node, char *puser, char *pswd, int fdebugcmd)
+{
+ char *user = "";
+ int rv = -1;
+ size_t n;
+ struct ipmi_intf *intf;
+
+ if (puser != NULL) user = puser;
+#ifdef DEBUG
+ if (fdbglog && fdebugcmd) fdebugcmd = 3; /*full debug*/
+ else if (fdbglog) fdebugcmd = 2; /*special log only from isolconsole.c*/
+ else if (fdebugcmd) fdebugcmd = 1; /*debug, no packets*/
+ if (fdebugcmd) fdebugcmd = 4; /*max debug*/
+#endif
+ switch (fdebugcmd) {
+ case 4: /* max debug */
+ loglvl = 8; /* 8=(LOG_DEBUG=1, max), 7=LOG_DEBUG */
+ verbose = 8; /* usually 0 or 1, but max is 8. */
+ break;
+ case 3: /* full debug */
+ loglvl = 7; /* 7=LOG_DEBUG; max=8 (LOG_DEBUG+1) */
+ verbose = 4; /* show packets */
+ break;
+ case 2: /* debug log file only*/
+ loglvl = 6; /* 6=LOG_INFO, 4=LOG_WARN */
+ verbose = 1; /* usually 0 or 1, but could be up to 8. */
+ break;
+ case 1: /* debug, no packets */
+ loglvl = 7; /* 7=LOG_DEBUG; max=8 (LOG_DEBUG+1) */
+ verbose = 1; /* usually 0 or 1, but could be up to 8. */
+ break;
+ case 0: /* no debug*/
+ /* by default loglevel = 4; (4=LOG_WARN) verbose = 0; */
+ default: break;
+ }
+ if (fdbglog)
+ dbglog("ipmi_open_lan2(%s,%s,%p,%d) verbose=%d loglevel=%d\n",
+ node,user,pswd,fdebugcmd,verbose,loglvl);
+ else if (fdebugcmd)
+ fprintf(fpdbg,"ipmi_open_lan2(%s,%s,%p,%d) verbose=%d loglevel=%d\n",
+ node,user,pswd,fdebugcmd,verbose,loglvl);
+ set_loglevel(loglvl);
+ intf = pconn->intf;
+
+ if (nodeislocal(node)) {
+ fprintf(fpdbg,"ipmi_open_lan2: node %s is local!\n",node);
+ rv = LAN_ERR_INVPARAM;
+ goto EXIT;
+ } else {
+ /* if attempting re-open to a new node, close the previous one. */
+ if (intf != NULL) {
+ if ((intf->session != NULL) &&
+ (strcmp(intf->session->hostname,node) != 0)) {
+ rv = ipmi_close_lan2(intf->session->hostname);
+ }
+ }
+ if ((gshutdown==0) || fdebugcmd)
+ fprintf(fpdbg,"Opening lanplus connection to node %s ...\n",node);
+
+ rv = 0;
+ if (intf == NULL) {
+ /* fill in the intf structure */
+ intf = ipmi_intf_load("lanplus");
+ if (intf == NULL) return(-1);
+ }
+ if (intf->session == NULL && intf->opened == 0) {
+ if (intf->setup == NULL) return(-1);
+ rv = intf->setup(intf); /*allocates session struct*/
+ if (fdebugcmd) printf("lan2 intf setup returned %d\n",rv);
+ }
+
+ if (rv == 0) {
+ if (intf->open == NULL) return(-1);
+ if (intf->session == NULL) return(-1);
+ intf->session->authtype_set = (uchar)gauth_type;
+ intf->session->privlvl = (uchar)gpriv_level;
+ intf->session->cipher_suite_id = (uchar)gcipher_suite;
+ if (node != NULL) { strcpy(intf->session->hostname,node); }
+ if (user != NULL) { strcpy(intf->session->username,user); }
+ if (pswd == NULL || pswd[0] == 0)
+ intf->session->password = 0;
+ else {
+ intf->session->password = 1;
+ n = strlen(pswd);
+ if (n > PSWD_MAX) n = PSWD_MAX;
+ memset(intf->session->authcode,0,PSWD_MAX);
+ strncpy(intf->session->authcode, pswd, n);
+ }
+ rv = intf->open(intf);
+ if (fdebugcmd)
+ printf("lan2 open.intf(auth=%d,priv=%d,cipher=%d) returned %d\n",
+ gauth_type,gpriv_level,gcipher_suite, rv);
+ if (rv != -1) { /*success is >= 0*/
+ sol_seq = 0; /*init new session, will call inc_sol_seq*/
+ sol_len = 0;
+ sol_seq_acked = 0;
+ pconn->lan2_fd = intf->fd; /*not same as rv if Windows*/
+ rv = 0;
+ }
+ }
+ pconn->intf = intf;
+ }
+EXIT:
+ if (rv != 0) {
+ if ((gshutdown == 0) || fdebugcmd)
+ fprintf(fperr, "ipmi_open_lan2 error %d\n",rv);
+ }
+ return(rv);
+}
+
+int ipmi_close_lan2(char *node)
+{
+ int rv = 0;
+ struct ipmi_intf *intf;
+
+ intf = pconn->intf;
+ if (!nodeislocal(node)) { /* ipmilan, need to close & cleanup */
+ if (fdbglog) dbglog("ipmi_close_lan2(%s) intf=%p\n",node,intf);
+ if (intf != NULL) {
+ if (intf->opened > 0 && intf->close != NULL) {
+ intf->close(intf); /* do the close */
+ intf->fd = -1;
+ intf->opened = 0;
+ }
+ }
+ pconn->lan2_fd = -1;
+ sol_seq = 0; sol_len = 0;
+ sol_rseq = 0; sol_rlen = 0;
+ sol_seq_acked = 0;
+ }
+ return (rv);
+}
+
+int ipmi_cmdraw_lan2(char *node, uchar cmd, uchar netfn, uchar lun,
+ uchar sa, uchar bus, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, n;
+ struct ipmi_rq req;
+ struct ipmi_rs *rsp;
+ struct timeval t1, t2;
+ struct ipmi_intf *intf = pconn->intf;
+
+ if (fdebugcmd) verbose = 5; /* show packets */
+#ifdef DEBUG
+ if (fdebugcmd) verbose = 8;
+#endif
+ if (intf == NULL || (intf->opened == 0)) {
+ rc = ipmi_open_lan2(node,guser,gpswd,fdebugcmd);
+ if (rc != 0) {
+ if (fdebugcmd)
+ fprintf(fperr, "ipmi_cmd_lan2: interface open error %d\n",rc);
+ return(rc);
+ }
+ intf = pconn->intf;
+ }
+
+ /* do the command */
+ memset(&req, 0, sizeof(req));
+ req.msg.cmd = cmd;
+ req.msg.netfn = netfn;
+ req.msg.lun = lun;
+ req.msg.target_cmd = cmd;
+ req.msg.data = pdata;
+ req.msg.data_len = sdata;
+ intf->target_addr = sa; /*usu 0x20*/
+ intf->target_lun = lun;
+ intf->target_channel = bus;
+
+
+ gettimeofday(&t1, NULL);
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) rc = -1;
+ else {
+ *pcc = rsp->ccode;
+ rc = rsp->ccode;
+ }
+ gettimeofday(&t2, NULL);
+ set_latency(&t1,&t2,&lan2_latency);
+ if (rc == 0) {
+ /* copy data */
+ if (rsp->data_len > *sresp) n = *sresp;
+ else n = rsp->data_len;
+ memcpy(presp,rsp->data,n);
+ *sresp = n;
+ } else {
+ *sresp = 0;
+ if (fdebugcmd)
+ fprintf(fperr, "ipmi_cmd_lan2 error %d\n",rc);
+ }
+ return (rc);
+}
+
+/*
+ * ipmi_cmd_lan2
+ * This is the entry point, called from ipmicmd.c
+ */
+int ipmi_cmd_lan2(char *node, ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+ uchar mycmd;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ fprintf(fperr, "ipmi_cmd_lan2: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) mycmd = (uchar)(cmd & CMDMASK); /* unmask it */
+ else mycmd = (uchar)cmd;
+
+ rc = ipmi_cmdraw_lan2(node,mycmd, ipmi_cmds[i].netfn, ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata, sdata, presp, sresp, pcc, fdebugcmd);
+ return(rc);
+}
+
+
+
+#define NOEM 4
+static struct { int id; char *name; } oem_list[NOEM] = {
+ {0x000157, "intelplus"}, /*VENDOR_INTEL*/
+ {0x002A7C, "supermicro"}, /*VENDOR_SUPERMICRO*/
+ /* { 0, "icts"}, *ICTS testware, needs user option*/
+ {0x00000B, "hp"}, /*VENDOR_HP*/
+ {0x000002, "ibm"} /*VENDOR_IBM*/
+};
+#ifdef METACOMMAND
+extern int is_lan2intel(int vend, int prod); /*oem_intel.c*/
+#else
+static int is_lan2intel(int vend, int prod) {
+ int rv = 0;
+ /* Older Intel BMCs use oem lan2i method, newer Intel FW uses lan2. */
+ if (vend == VENDOR_INTEL)
+ if ((prod < 0x0030) || (prod == 0x0811)) rv = 1;
+ return(rv);
+}
+#endif
+
+int ipmi_oem_active(struct ipmi_intf * intf, const char * oemtype)
+{
+ int i, vend, prod, dtype;
+ get_mfgid(&vend,&prod);
+ dtype = get_driver_type();
+ if (verbose)
+ lprintf(LOG_INFO,"oem_active(is_type==%s ?) vend=%x prod=%x", oemtype,vend,prod);
+ if (strncmp("intelplus", oemtype, strlen(oemtype)) == 0) {
+ /* special case to detect intelplus, not all Intel platforms */
+ if (dtype == DRV_LAN2I) {
+ i = 1;
+ } else {
+ if (is_lan2intel(vend,prod)) {
+ i = 1;
+ set_driver_type("lan2i");
+ } else { /* If iBMC, does not use intelplus */
+ if (verbose) lprintf(LOG_WARN,"detected as not intelplus");
+ i = 0;
+ }
+ }
+ if (verbose && i == 1) lprintf(LOG_WARN,"intelplus detected, vend=%x prod=%x",vend, prod);
+ return i;
+ } else {
+ // if (intf->oem == NULL) return 0;
+ for (i = 0; i < NOEM; i++) {
+ if (strncmp(oem_list[i].name,oemtype,strlen(oemtype)) == 0)
+ if (oem_list[i].id == vend) {
+ if (verbose) lprintf(LOG_WARN,"%s detected, vend=%x",oemtype,vend);
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+/*
+ * lan2_validate_solrcv()
+ * Validate the SOL receive packet, and save received SOL info
+ * (recv seq num, char count) for use in send_sol header.
+ * return value (bitwise):
+ * 0x01 bit set: received packet is present with data len > 0
+ * 0x02 bit set: received packet flags error in the previously sent packet
+ * 0x04 bit set: received packet is a retry of previous
+ * 0x08 bit set: break detected
+ */
+static int lan2_validate_solrcv(struct ipmi_rs * rs)
+{
+ int rv = 0;
+ if (rs == NULL) return(rv);
+ if (verbose > 4)
+ dbg_dump("rs_sol_hdr",
+ (uchar *)&rs->payload.sol_packet.packet_sequence_number,8,1);
+ chars_to_resend = 0;
+ sol_rlen = (uchar)rs->data_len;
+ if (sol_rlen > 4) sol_rlen -= 4;
+ else sol_rlen = 0;
+ if (sol_rlen > 0) rv |= 0x01; /* have a receive packet with dlen > 0 */
+ if (rs->payload.sol_packet.packet_sequence_number != 0) {
+ if (rs->payload.sol_packet.packet_sequence_number == sol_rseq) {
+ lprintf(LOG_INFO,"received retry of sol_rseq %d, rlen=%d",
+ sol_rseq,sol_rlen);
+ /* do nothing because rs->data_len was set to 4 in lanplus */
+ // rv |= 0x04;
+ /* return, don't process this again */
+ return(rv);
+ } else sol_rseq = rs->payload.sol_packet.packet_sequence_number;
+ }
+ /* check for errors in previously sent packet */
+ if (rs->payload.sol_packet.acked_packet_number != 0) {
+ if (rs->payload.sol_packet.acked_packet_number != sol_seq) rv |= 0x02;
+ else if ((rs->payload.sol_packet.accepted_character_count < sol_len)
+ && (sol_seq_acked < sol_seq)) {
+ lprintf(LOG_INFO,"partial_ack, seq=%d: acked=%d < sent=%d",
+ sol_seq,rs->payload.sol_packet.accepted_character_count,
+ sol_len);
+ chars_to_resend = sol_len -
+ rs->payload.sol_packet.accepted_character_count;
+ rv |= 0x02;
+ }
+ sol_seq_acked = rs->payload.sol_packet.acked_packet_number;
+ }
+ if (sol_seq != 0) { /*if we have sent something*/
+ if (rs->payload.sol_packet.is_nack) rv |= 0x02;
+ if (rs->payload.sol_packet.transfer_unavailable) rv |= 0x02;
+ if (rs->payload.sol_packet.sol_inactive) rv |= 0x02;
+ if (rs->payload.sol_packet.transmit_overrun) rv |= 0x02;
+ }
+ if (rs->payload.sol_packet.break_detected) rv |= 0x08;
+ if (rv & 0x02) {
+ if (sol_seq_acked < sol_seq) { /*not already acked, needs retry*/
+ lprintf(LOG_INFO,"need to retry sol_seq=%d, acked=%d len=%d rv=%x",
+ sol_seq,sol_seq_acked,sol_len,rv);
+ if (chars_to_resend == 0) chars_to_resend = sol_len;
+ } else rv &= 0xFD;
+ }
+ return(rv);
+}
+
+/*
+ * lan2_set_sol_data
+ * called from isolconsole when SOL 2.0 session is activated.
+ */
+void lan2_set_sol_data(int insize, int outsize, int port, void *handler,
+ char esc_char)
+{
+ struct ipmi_intf *intf = pconn->intf;
+ if (intf == NULL) return;
+ lprintf(LOG_INFO,"setting lanplus intf params(%d,%d,%d,%p,%c)",
+ insize,outsize,port,handler,esc_char);
+ intf->session->sol_data.max_inbound_payload_size = (ushort)insize;
+ intf->session->sol_data.max_outbound_payload_size = (ushort)outsize;
+ intf->session->sol_data.port = (ushort)port;
+ intf->session->sol_data.sol_input_handler = handler;
+ intf->session->timeout = 1; /* lib/.../lanplus.h: IPMI_LAN_TIMEOUT =1sec*/
+ intf->session->sol_escape_char = esc_char; /*usu '~'*/
+}
+
+int lan2_keepalive(int type, SOL_RSP_PKT *rsp)
+{
+ int rv = 0;
+ struct ipmi_intf *intf = pconn->intf;
+ if (fdbglog) dbglog("lan2_keepalive(%d,%p) called\n",type,rsp); /*++++*/
+ if (intf == NULL) return -1;
+ if (rsp) rsp->len = 0;
+ if (type == 2) { /*send empty SOL data*/
+ struct ipmi_v2_payload v2_payload;
+ struct ipmi_rs * rs = NULL;
+ memset(&v2_payload, 0, sizeof(v2_payload));
+ v2_payload.payload.sol_packet.packet_sequence_number = 0;
+ v2_payload.payload.sol_packet.character_count = 0;
+ v2_payload.payload.sol_packet.acked_packet_number = 0;
+ v2_payload.payload.sol_packet.accepted_character_count = 0;
+ rs = intf->send_sol(intf, &v2_payload);
+ if (rs == NULL) {
+ rv = -1;
+ } else { /*may sometimes get data back*/
+ rsp->type = rs->session.payloadtype;
+ rsp->len = rs->data_len;
+ rsp->data = rs->data;
+ lprintf(LOG_INFO,
+ "keepalive: rq_seq=%d rs_seq=%d (0x%02x) rseq=%d rlen=%d",
+ // v2_payload.payload.ipmi_request.rq_seq,
+ v2_payload.payload.sol_packet.packet_sequence_number,
+ rs->session.seq, rs->session.seq,
+ rs->payload.sol_packet.packet_sequence_number,rs->data_len);
+ rv = lan2_validate_solrcv(rs);
+ if (rv > 1) lprintf(LOG_INFO,
+ "keepalive: rv=%x need retry of sol_seq=%d(%d) sol_len=%d(%d)",
+ rv,v2_payload.payload.sol_packet.packet_sequence_number,
+ sol_seq,v2_payload.payload.sol_packet.character_count,sol_len);
+ rv = 0; /* 0 = have recv buffer to process*/
+ }
+ } else {
+ rv = intf->keepalive(intf); /*get_device_id*/
+ }
+ if (fdbglog) dbglog("lan2_keepalive rv = %d\n",rv); /*++++*/
+ return(rv);
+}
+
+static uchar inc_sol_seq( uchar lastseq )
+{
+ uchar seq;
+ seq = lastseq + 1;
+ if (seq > 15) seq = 1;
+ pconn->intf->session->sol_data.sequence_number = seq;
+ return(seq);
+}
+
+int lan2_send_break( SOL_RSP_PKT *rsp)
+{
+ struct ipmi_rs *rs;
+ static struct ipmi_v2_payload v2_payload;
+ int rv = 0;
+ struct ipmi_intf *intf = pconn->intf;
+
+ if (intf == NULL) return -1;
+ if (rsp == NULL) return -1;
+ rsp->len = 0; /*just in case*/
+ memset(&v2_payload, 0, sizeof(v2_payload));
+ v2_payload.payload.sol_packet.character_count = 0;
+ v2_payload.payload.sol_packet.generate_break = 1;
+
+ rs = intf->send_sol(intf, &v2_payload);
+ if (rs == NULL) {
+ rv = -1;
+ lprintf(LOG_INFO,"send_break error");
+ } else {
+ rv = 0;
+ rsp->type = rs->session.payloadtype;
+ rsp->len = rs->data_len;
+ rsp->data = rs->data;
+ lprintf(LOG_INFO,"send_break(rs): sol_seq=%d rs_sol=%d "
+ "rs_seq=%d (0x%02x) rseq=%d rlen=%d",
+ v2_payload.payload.sol_packet.packet_sequence_number,
+ rs->payload.sol_packet.packet_sequence_number,
+ rs->session.seq, rs->session.seq,
+ rs->payload.sol_packet.packet_sequence_number,rs->data_len);
+ }
+ return(rv);
+}
+
+int lan2_send_sol( uchar *payload, int len, SOL_RSP_PKT *rsp)
+{
+ struct ipmi_rs *rs;
+ static struct ipmi_v2_payload v2_payload;
+ int rv = 0;
+ struct ipmi_intf *intf = pconn->intf;
+
+ if (rsp) rsp->len = 0; /*just in case*/
+ if (intf == NULL) return -1;
+ memset(&v2_payload, 0, sizeof(v2_payload));
+ memcpy(v2_payload.payload.sol_packet.data,payload,len);
+ sol_seq = inc_sol_seq(sol_seq);
+ sol_len = (uchar)len;
+ v2_payload.payload.sol_packet.packet_sequence_number = sol_seq;
+ v2_payload.payload.sol_packet.character_count = (uchar)len;
+#ifdef TEST
+ /* Note that the lanplus layer already did auto-ack of sol recv pkts,
+ * but we can put the info in send_sol also for completeness. */
+ /* Further debug shows that this doesn't matter, so skip it. */
+ v2_payload.payload.sol_packet.acked_packet_number = sol_rseq;
+ v2_payload.payload.sol_packet.accepted_character_count = sol_rlen;
+ /* These flags were initialized to zero above via memset. */
+ v2_payload.payload.sol_packet.is_nack = 0;
+ v2_payload.payload.sol_packet.assert_ring_wor = 0;
+ v2_payload.payload.sol_packet.generate_break = 0;
+ v2_payload.payload.sol_packet.deassert_cts = 0;
+ v2_payload.payload.sol_packet.deassert_dcd_dsr = 0;
+ v2_payload.payload.sol_packet.flush_inbound = 0;
+ v2_payload.payload.sol_packet.flush_outbound = 0;
+#endif
+ lprintf(LOG_INFO,"send_sol(rq): sol_seq=%d acked=%d chars=%d len=%d",
+ v2_payload.payload.sol_packet.packet_sequence_number,
+ v2_payload.payload.sol_packet.acked_packet_number,
+ v2_payload.payload.sol_packet.accepted_character_count,len);
+ if (verbose > 4)
+ dbg_dump("rq_sol_hdr",
+ (uchar *)&v2_payload.payload.sol_packet.packet_sequence_number,
+ 10,1);
+ rs = intf->send_sol(intf, &v2_payload);
+ if (rs == NULL) {
+ rv = -1;
+ lprintf(LOG_INFO,"send_sol error (%d bytes)",len);
+ } else {
+ rsp->type = rs->session.payloadtype;
+ rsp->len = rs->data_len;
+ rsp->data = rs->data;
+ lprintf(LOG_INFO,"send_sol(rs): sol_seq=%d rs_sol=%d rs_seq=%d (0x%02x)"
+ " rseq=%d rlen=%d",
+ v2_payload.payload.sol_packet.packet_sequence_number,
+ // v2_payload.payload.sol_packet.acked_packet_number,
+ rs->payload.sol_packet.packet_sequence_number,
+ rs->session.seq, rs->session.seq,
+ rs->payload.sol_packet.packet_sequence_number,rs->data_len);
+ rv = lan2_validate_solrcv(rs);
+ if (rv > 1) lprintf(LOG_INFO,
+ "send_sol: rv=%x sol_seq=%d(%d) sol_len=%d(%d) not acked",
+ rv,v2_payload.payload.sol_packet.packet_sequence_number,
+ sol_seq,v2_payload.payload.sol_packet.character_count,sol_len);
+ rv = 0; /* 0 = have recv buffer to process*/
+ }
+ return(rv);
+}
+
+int lan2_recv_sol( SOL_RSP_PKT *rsp )
+{
+ struct ipmi_rs * rs;
+ int rv;
+ struct ipmi_intf *intf = pconn->intf;
+
+ if (rsp == NULL) return -1;
+ rsp->len = 0;
+ if (intf == NULL) return -1;
+ rs = intf->recv_sol(intf);
+ if (rs == NULL) return -1;
+ rsp->type = rs->session.payloadtype;
+ rsp->len = rs->data_len;
+ rsp->data = rs->data;
+ lprintf(LOG_INFO,"recv_sol: rs_sol=%d rs_seq=%d (0x%02x) rseq=%d rlen=%d",
+ rs->payload.sol_packet.packet_sequence_number,
+ rs->session.seq, rs->session.seq,
+ rs->payload.sol_packet.packet_sequence_number,rs->data_len);
+ rv = lan2_validate_solrcv(rs);
+ if (rv > 1) {
+ lprintf(LOG_INFO,
+ "recv_sol: rv=%x sol_seq=%d sol_len=%d not acked",
+ rv,sol_seq,sol_len);
+ }
+ return(rsp->len);
+}
+
+void lan2_recv_handler( void *rs0)
+{
+ struct ipmi_rs *rs = rs0;
+ SOL_RSP_PKT rsp;
+ int rv;
+
+ rsp.len = 0;
+ rsp.type = 0;
+ if (rs == NULL) return;
+ lprintf(LOG_INFO,"recv_handler: len=%d rs_seq=%d (0x%02x) rseq=%d rlen=%d",
+ rs->data_len, rs->session.seq, rs->session.seq,
+ rs->payload.sol_packet.packet_sequence_number,rs->data_len);
+ rsp.type = rs->session.payloadtype;
+ rsp.len = rs->data_len;
+ rsp.data = rs->data;
+ rv = lan2_validate_solrcv(rs);
+ if (rv > 1) lprintf(LOG_INFO,
+ "recv_handler: rv=%x sol_seq=%d sol_len=%d not acked",
+ rv,sol_seq,sol_len);
+ sol_output_handler(&rsp);
+ return;
+}
+
+SockType lan2_get_fd(void)
+{
+ if (pconn->intf == NULL) return pconn->lan2_fd;
+ return(pconn->intf->fd);
+}
+#endif
+
+/* end ipmilanplus.c */
diff --git a/util/ipmilanplus.h b/util/ipmilanplus.h
new file mode 100644
index 0000000..0003cf0
--- /dev/null
+++ b/util/ipmilanplus.h
@@ -0,0 +1,64 @@
+/*
+ * ipmilanplus.h: (a copy of ipmitool/ipmi_intf.h)
+ *
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMILANPLUS_H
+#define IPMILANPLUS_H
+
+#ifdef WIN32
+#include <windows.h>
+#include <winsock.h>
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef int int32_t;
+typedef uint32_t socklen_t;
+
+#else
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif
+
+/**************************************/
+
+#define IPMI_BMC_SLAVE_ADDR 0x20
+#define IPMI_BUF_SIZE 1024
+
+#ifdef HAVE_LANPLUS
+#include "../lib/lanplus/lanplus_defs.h"
+#endif
+
+void lanplus_set_sol_data(int insize, int outsize, int port);
+
+#endif /* IPMILANPLUS_H */
diff --git a/util/ipmild.c b/util/ipmild.c
new file mode 100644
index 0000000..5ad54f2
--- /dev/null
+++ b/util/ipmild.c
@@ -0,0 +1,250 @@
+/*M*
+// PVCS:
+// $Workfile: ipmild.c $
+// $Revision: 1.0 $
+// $Modtime: 23 Feb 2005 15:20:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the /dev/ldipmi native interface from
+// the LanDesk IPMI driver.
+// Requires linking with libldipmi.a, or equivalent.
+//
+// 02/23/05 ARC - created, but stubbed out, since the
+// LanDesk libipmiapi.a isn't clean yet.
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2005, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef LINUX
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "ipmicmd.h" /* for uchar, NCMDS */
+// #define uchar unsigned char
+#define MAX_NO_OF_RETRIES 3
+
+// Request structure provided to SendTimedImbpRequest()
+#pragma pack(1)
+typedef struct {
+ uchar cmdType; // IMB command
+ uchar rsSa; // command destination address
+ uchar busType; // not used
+ uchar netFn; // IMB command class (network function)
+ uchar rsLun; // subsystem on destination
+ uchar * data; // command body
+ int dataLength; // body size
+} IMBPREQUESTDATA;
+#pragma pack()
+
+#ifdef LINK_LANDESK
+/* typedef enum { 0, 1, 2, 3, 4, 5, 6 } ACCESN_STATUS; */
+/* Note that this routine name conflicts with ia_ imb routine. */
+extern int SendTimedImbpRequest (
+ IMBPREQUESTDATA *reqPtr,
+ int timeOut,
+ uchar * respDataPtr,
+ int * respDataLen,
+ uchar * completionCode);
+extern int initIPMI();
+extern int termIPMI();
+static int ipmi_timeout_ld = 100000; /*100 * 1000 ms = 100 sec */
+#endif
+
+extern FILE *fperr; /*defined in ipmicmd.c*/
+extern FILE *fpdbg; /*defined in ipmicmd.c*/
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+#ifdef TEST
+static int ipmi_fd = -1;
+#endif
+
+int ipmi_open_ld(char fdebugcmd)
+{
+ int rc = -1;
+#ifdef TEST
+ char *pdev;
+
+ if (ipmi_fd != -1) return(0);
+ pdev = "/dev/ldipmi";
+ ipmi_fd = open(pdev, O_RDWR);
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) printf("ipmi_open_ld: cannot open %s\n",pdev);
+ pdev = "/dev/ldipmi/0";
+ ipmi_fd = open(pdev, O_RDWR);
+ }
+#endif
+#ifdef LINK_LANDESK
+ rc = initIPMI();
+ if (rc != 0) {
+ if (fdebugcmd) printf("ipmi_open_ld: cannot open ldipmi, rc=%d errno=%d\n",rc,errno);
+ return(-1);
+ }
+ ipmi_fd = 1; /*show that open was ok*/
+ if (fdebugcmd) printf("ipmi_open_ld: successfully opened ldipmi\n");
+#endif
+ return(rc);
+}
+
+int ipmi_close_ld(void)
+{
+ int rc = 0;
+#ifdef LINK_LANDESK
+ if (ipmi_fd != -1) {
+ termIPMI();
+ ipmi_fd = -1;
+ }
+#endif
+ return(rc);
+}
+
+int ipmicmd_ld( uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+#ifdef LINK_LANDESK
+ IMBPREQUESTDATA requestData;
+ int status = 0;
+ uchar * pc;
+ int sz, i;
+
+ requestData.cmdType = cmd;
+ requestData.rsSa = sa;
+ requestData.busType = bus;
+ requestData.netFn = netfn;
+ requestData.rsLun = lun;
+ requestData.dataLength = sdata;
+ requestData.data = pdata;
+
+ if (fdebugcmd) {
+ sz = sizeof(IMBPREQUESTDATA);
+ pc = (uchar *)&requestData.cmdType;
+ fprintf(fpdbg,"ipmicmd_ld: request (len=%d): ",sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ pc = requestData.data;
+ sz = requestData.dataLength;
+ fprintf(fpdbg," req.data=%p, dlen=%d: ", pc, sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ }
+
+ if (ipmi_fd == -1) {
+ status = ipmi_open_ld(fdebugcmd);
+ if (status != 0) return(status);
+ }
+
+ {
+ sz = *sresp; /* note that sresp must be pre-set */
+ memset(presp, 0, sz);
+ for ( i =0 ; i < MAX_NO_OF_RETRIES; i++)
+ {
+ *sresp = sz; /* retries may need to re-init *sresp */
+ if((status =SendTimedImbpRequest(&requestData,
+ ipmi_timeout_ld, presp, sresp,
+ pcc)) == 0 ) {
+ break;
+ }
+ if (fdebugcmd) // only gets here if error
+ fprintf(fpdbg,"ipmi_cmd_ld: sendImbRequest error status=%x, ccode=%x\n",
+ (uint)status, *pcc);
+ }
+ }
+
+ if (fdebugcmd) { /* if debug, show both good and bad statuses */
+ fprintf(fpdbg,"ipmi_cmd_ld: sendImbRequest status=%x, ccode=%x\n",
+ (uint)status, *pcc);
+ if (status == 0) {
+ uchar * pc; int sz;
+ sz = *sresp;
+ pc = (uchar *)presp;
+ fprintf(fpdbg,"ipmi_cmd_ld: response (len=%d): ",sz);
+ for (i = 0; i < sz; i++) fprintf(fpdbg,"%02x ",pc[i]);
+ fprintf(fpdbg,"\n");
+ }
+ }
+
+ return(status);
+#else
+ return(-1);
+#endif
+} /* end ipmicmd_ld() */
+
+int ipmi_cmdraw_ld( uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ int rc;
+ rc = ipmicmd_ld(cmd, netfn, lun, sa, bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return(rc);
+}
+
+int ipmi_cmd_ld(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ fprintf(fperr, "ipmi_cmd_ld: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) cmd = cmd & CMDMASK; /* unmask it */
+ rc = ipmicmd_ld(cmd, ipmi_cmds[i].netfn, ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return(rc);
+}
+
+#ifdef LINK_LANDESK
+/* define extra stuff that the LanDesk library needs */
+void * _Unwind_Resume(void *context)
+{
+ printf("called Unwind_Resume\n");
+ return(NULL);
+}
+
+int __gxx_personality_v0(void *a)
+{
+ return(0);
+}
+
+#endif
+
+#endif
+
diff --git a/util/ipmilipmi.c b/util/ipmilipmi.c
new file mode 100644
index 0000000..89fa12e
--- /dev/null
+++ b/util/ipmilipmi.c
@@ -0,0 +1,182 @@
+/*M*
+// $Workfile: ipmilipmi.c $
+// $Revision: 0.1 $
+// $Modtime: 18 Oct 2010 15:20:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the /dev/lipmi interface from
+// the Solaris 8 & 9 LIPMI driver.
+//
+// 10/18/10 ARC - created
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef SOLARIS
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stropts.h>
+
+#include "ipmicmd.h" /* for uchar, NCMDS */
+
+#define MAX_SEND_SIZE 34
+#define MAX_RECV_SIZE 33 /*TODO: compare with RECV_MAX_PAYLOAD_SIZE */
+#define IOCTL_IPMI_KCS_ACTION 0x01
+/* I_STR should be defined in stropts.h */
+
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+static int ipmi_fd = -1;
+static char *pdev = "/dev/lipmi";
+
+#ifndef _SYS_STROPTS_H
+/* see sys/stropts.h, sys/lipmi/lipmi_intf.h*/
+typedef struct strioctl {
+ int ic_cmd;
+ int ic_timout;
+ int ic_len;
+ char *ic_dp;
+} strioctl_t;
+#endif
+
+typedef struct bmc_req {
+ uchar fn;
+ uchar lun;
+ uchar cmd;
+ uchar datalength;
+ uchar data[MAX_SEND_SIZE];
+} bmc_req_t;
+
+typedef struct bmc_rsp {
+ uchar fn;
+ uchar lun;
+ uchar cmd;
+ uchar ccode;
+ uchar datalength;
+ uchar data[MAX_RECV_SIZE];
+} bmc_rsp_t;
+
+typedef struct lipmi_reqrsp { /*TODO: see sys/lipmi/lipmi_intf.h*/
+ bmc_req_t req;
+ bmc_rsp_t rsp;
+} lipmi_reqrsp_t;
+
+
+int ipmi_open_lipmi(char fdebugcmd)
+{
+ int rc = -1;
+
+ if (ipmi_fd != -1) return(0);
+ ipmi_fd = open(pdev, O_RDWR);
+ if (ipmi_fd < 0) {
+ if (fdebugcmd) printf("ipmi_open_lipmi: cannot open %s, errno=%d\n",
+ pdev,errno);
+ return(rc);
+ }
+ rc = 0;
+ if (fdebugcmd) printf("ipmi_open_lipmi: successfully opened\n");
+ return(rc);
+}
+
+int ipmi_close_lipmi(void)
+{
+ int rc = 0;
+ if (ipmi_fd != -1) {
+ close(ipmi_fd);
+ ipmi_fd = -1;
+ }
+ return(rc);
+}
+
+int ipmi_cmdraw_lipmi( uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ int rv = -1;
+ struct strioctl istr;
+ static struct lipmi_reqrsp reqrsp;
+ int len;
+ uchar cc;
+
+ if (ipmi_fd == -1) return -1;
+
+ memset(&reqrsp, 0, sizeof(reqrsp));
+ reqrsp.req.fn = netfn;
+ reqrsp.req.lun = lun;
+ reqrsp.req.cmd = cmd;
+ reqrsp.req.datalength = sdata;
+ memcpy(reqrsp.req.data, pdata, sdata);
+ reqrsp.rsp.datalength = MAX_RECV_SIZE;
+
+ istr.ic_cmd = IOCTL_IPMI_KCS_ACTION;
+ istr.ic_timout = 0;
+ istr.ic_dp = (char *)&reqrsp;
+ istr.ic_len = sizeof(struct lipmi_reqrsp);
+
+ rv = ioctl(ipmi_fd, I_STR, &istr);
+ if (rv < 0) {
+ perror("LIPMI IOCTL: I_STR");
+ return rv;
+ }
+
+ cc = reqrsp.rsp.ccode;
+ len = reqrsp.rsp.datalength;
+ *pcc = cc;
+ *sresp = len;
+ if (cc == 0 && len > 0)
+ memcpy(presp, reqrsp.rsp.data, len);
+ return(rv);
+}
+
+int ipmi_cmd_lipmi(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int rc, i;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ printf("ipmi_cmd_lipmi: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) cmd = cmd & CMDMASK; /* unmask it */
+ rc = ipmi_cmdraw_lipmi(cmd, ipmi_cmds[i].netfn, ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return(rc);
+}
+#endif
+/* end of ipmilipmi.c */
diff --git a/util/ipmims.cpp b/util/ipmims.cpp
new file mode 100644
index 0000000..2ba0611
--- /dev/null
+++ b/util/ipmims.cpp
@@ -0,0 +1,638 @@
+/*M*
+// $Workfile: ipmims.cpp $
+// $Revision: 1.0 $
+// $Modtime: 08 Sep 2008 13:31:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the Microsoft Windows 2003 R2 IPMI driver.
+// Note that this should be compiled with /TP (as C++).
+//
+// 09/08/08 ARCress - created.
+// 04/27/11 Jay Krell - fixed WIN64-unsafe logic
+// 09/30/13 ARCress - fixed Win2012 x64 SafeArrayDestroy fault
+//
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2008, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+Copyright (c) 2013 Andy Cress <arcress at users.sourceforge.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef WIN32
+/* Microsoft IPMI drver is only valid in Windows */
+#define _WIN32_DCOM
+#pragma once
+#include <windows.h>
+#include <stdio.h>
+#include <iostream> //deprecated iostream.h
+#include <Objbase.h> //ole32.lib
+#include <comutil.h>
+#include <Wbemcli.h>
+
+#ifdef ALONE
+#define uchar unsigned char
+#define ushort unsigned short
+#define ulong unsigned long
+#else
+#include "ipmicmd.h"
+extern "C" { extern ipmi_cmd_t ipmi_cmds[NCMDS]; }
+#endif
+static char fmsopen = 0;
+static char fdebugms = 0;
+static IWbemLocator *pLoc = 0;
+static IWbemServices *pSvc = 0;
+static IWbemClassObject* pClass = NULL;
+static IEnumWbemClassObject* pEnumerator = NULL;
+static IWbemClassObject* pInstance = NULL;
+static VARIANT varPath;
+#define NVAR 32
+/* Wbem error return codes, returned by WMI */
+#ifdef RES_ALL
+#define NRES 82
+#else
+#define NRES 10
+#endif
+static struct { char *desc; int val; } res_list[NRES] = {
+{"WBEM_E_FAILED", 0x80041001 },
+{"WBEM_E_NOT_FOUND", 0x80041002 },
+{"WBEM_E_ACCESS_DENIED", 0x80041003 },
+{"WBEM_E_PROVIDER_FAILURE", 0x80041004 },
+{"WBEM_E_TYPE_MISMATCH", 0x80041005 },
+{"WBEM_E_OUT_OF_MEMORY", 0x80041006 },
+{"WBEM_E_INVALID_CONTEXT", 0x80041007 },
+{"WBEM_E_INVALID_PARAMETER", 0x80041008 },
+{"WBEM_E_NOT_AVAILABLE", 0x80041009 },
+{"WBEM_E_CRITICAL_ERROR", 0x8004100A }
+#ifdef RES_ALL
+,
+{"WBEM_E_CRITICAL_ERROR", 0x8004100A } ,
+{"WBEM_E_INVALID_STREAM", 0x8004100B },
+{"WBEM_E_NOT_SUPPORTED", 0x8004100C },
+{"WBEM_E_INVALID_SUPERCLASS", 0x8004100D },
+{"WBEM_E_INVALID_NAMESPACE", 0x8004100E },
+{"WBEM_E_INVALID_OBJECT", 0x8004100F },
+{"WBEM_E_INVALID_CLASS", 0x80041010 },
+{"WBEM_E_PROVIDER_NOT_FOUND", 0x80041011 },
+{"WBEM_E_INVALID_PROVIDER_REGISTRATION", 0x80041012 },
+{"WBEM_E_PROVIDER_LOAD_FAILURE", 0x80041013 },
+{"WBEM_E_INITIALIZATION_FAILURE", 0x80041014 },
+{"WBEM_E_TRANSPORT_FAILURE", 0x80041015 },
+{"WBEM_E_INVALID_OPERATION", 0x80041016 },
+{"WBEM_E_INVALID_QUERY", 0x80041017 },
+{"WBEM_E_INVALID_QUERY_TYPE", 0x80041018 },
+{"WBEM_E_ALREADY_EXISTS", 0x80041019 },
+{"WBEM_E_OVERRIDE_NOT_ALLOWED", 0x8004101A },
+{"WBEM_E_PROPAGATED_QUALIFIER", 0x8004101B },
+{"WBEM_E_PROPAGATED_PROPERTY", 0x8004101C },
+{"WBEM_E_UNEXPECTED", 0x8004101D },
+{"WBEM_E_ILLEGAL_OPERATION", 0x8004101E },
+{"WBEM_E_CANNOT_BE_KEY", 0x8004101F },
+{"WBEM_E_INCOMPLETE_CLASS", 0x80041020 },
+{"WBEM_E_INVALID_SYNTAX", 0x80041021 },
+{"WBEM_E_NONDECORATED_OBJECT", 0x80041022 },
+{"WBEM_E_READ_ONLY", 0x80041023 },
+{"WBEM_E_PROVIDER_NOT_CAPABLE", 0x80041024 },
+{"WBEM_E_CLASS_HAS_CHILDREN", 0x80041025 },
+{"WBEM_E_CLASS_HAS_INSTANCES", 0x80041026 },
+{"WBEM_E_QUERY_NOT_IMPLEMENTED", 0x80041027 },
+{"WBEM_E_ILLEGAL_NULL", 0x80041028 },
+{"WBEM_E_INVALID_QUALIFIER_TYPE", 0x80041029 },
+{"WBEM_E_INVALID_PROPERTY_TYPE", 0x8004102A },
+{"WBEM_E_VALUE_OUT_OF_RANGE", 0x8004102B },
+{"WBEM_E_CANNOT_BE_SINGLETON", 0x8004102C },
+{"WBEM_E_INVALID_CIM_TYPE", 0x8004102D },
+{"WBEM_E_INVALID_METHOD", 0x8004102E },
+{"WBEM_E_INVALID_METHOD_PARAMETERS", 0x8004102F },
+{"WBEM_E_SYSTEM_PROPERTY", 0x80041030 },
+{"WBEM_E_INVALID_PROPERTY", 0x80041031 },
+{"WBEM_E_CALL_CANCELLED", 0x80041032 },
+{"WBEM_E_SHUTTING_DOWN", 0x80041033 },
+{"WBEM_E_PROPAGATED_METHOD", 0x80041034 },
+{"WBEM_E_UNSUPPORTED_PARAMETER", 0x80041035 },
+{"WBEM_E_MISSING_PARAMETER_ID", 0x80041036 },
+{"WBEM_E_INVALID_PARAMETER_ID", 0x80041037 },
+{"WBEM_E_NONCONSECUTIVE_PARAMETER_IDS", 0x80041038 },
+{"WBEM_E_PARAMETER_ID_ON_RETVAL", 0x80041039 },
+{"WBEM_E_INVALID_OBJECT_PATH", 0x8004103A },
+{"WBEM_E_OUT_OF_DISK_SPACE", 0x8004103B },
+{"WBEM_E_BUFFER_TOO_SMALL", 0x8004103C },
+{"WBEM_E_UNSUPPORTED_PUT_EXTENSION", 0x8004103D },
+{"WBEM_E_UNKNOWN_OBJECT_TYPE", 0x8004103E },
+{"WBEM_E_UNKNOWN_PACKET_TYPE", 0x8004103F },
+{"WBEM_E_MARSHAL_VERSION_MISMATCH", 0x80041040 },
+{"WBEM_E_MARSHAL_INVALID_SIGNATURE", 0x80041041 },
+{"WBEM_E_INVALID_QUALIFIER", 0x80041042 },
+{"WBEM_E_INVALID_DUPLICATE_PARAMETER", 0x80041043 },
+{"WBEM_E_TOO_MUCH_DATA", 0x80041044 },
+{"WBEM_E_SERVER_TOO_BUSY", 0x80041045 },
+{"WBEM_E_INVALID_FLAVOR", 0x80041046 },
+{"WBEM_E_CIRCULAR_REFERENCE", 0x80041047 },
+{"WBEM_E_UNSUPPORTED_CLASS_UPDATE", 0x80041048 },
+{"WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE", 0x80041049 },
+{"WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE", 0x80041050 },
+{"WBEM_E_TOO_MANY_PROPERTIES", 0x80041051 },
+{"WBEM_E_UPDATE_TYPE_MISMATCH", 0x80041052 },
+{"WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED", 0x80041053 },
+{"WBEM_E_UPDATE_PROPAGATED_METHOD", 0x80041054 },
+{"WBEM_E_METHOD_NOT_IMPLEMENTED", 0x80041055 },
+{"WBEM_E_METHOD_DISABLED", 0x80041056 },
+{"WBEMESS_E_REGISTRATION_TOO_BROAD", 0x80042001 },
+{"WBEMESS_E_REGISTRATION_TOO_PRECISE", 0x80042002 }
+#endif
+};
+
+/*
+ * Microsoft_IPMI methods:
+ * void RequestResponse(
+ * [in] uint8 Command,
+ * [out] uint8 CompletionCode,
+ * [in] uint8 Lun,
+ * [in] uint8 NetworkFunction,
+ * [in] uint8 RequestData[],
+ * [out] uint32 ResponseDataSize,
+ * [in] uint32 RequestDataSize,
+ * [in] uint8 ResponderAddress,
+ * [out] uint8 ResponseData
+ * );
+ *
+ * void SMS_Attention(
+ * [out] boolean AttentionSet,
+ * [out] uint8 StatusRegisterValue
+ * );
+ */
+
+static void cleanup_wmi(void)
+{
+ VariantClear(&varPath);
+ if (pInstance != NULL) pInstance->Release();
+ if (pEnumerator != NULL) pEnumerator->Release();
+ if (pClass != NULL) pClass->Release();
+ if (pSvc != 0) pSvc->Release();
+ if (pLoc != 0) pLoc->Release();
+ CoUninitialize();
+}
+
+static void dumpbuf(uchar *p, int len, char fwrap)
+{
+ int i;
+ for (i = 0; i < len; i++) {
+ if (fwrap) {
+ if ((i % 16) == 0) printf("\n%04x: ",i);
+ }
+ printf(" %02x",p[i]);
+ }
+ printf("\n");
+ return;
+}
+
+static char *res_str(HRESULT res)
+{
+ char *pstr = "";
+ int i;
+ for (i = 0; i < NRES; i++) {
+ if (res_list[i].val == res) {
+ pstr = &res_list[i].desc[0];
+ break;
+ }
+ }
+ return (pstr);
+}
+
+extern "C" {
+
+int ipmi_open_ms(char fdebugcmd)
+{
+ int bRet = -1;
+ HRESULT hres;
+ ULONG dwCount = NULL;
+
+ fdebugms = fdebugcmd;
+ // Initialize COM.
+ hres = CoInitializeEx(0, COINIT_MULTITHREADED);
+ if (FAILED(hres)) {
+ if (fdebugcmd) printf("ipmi_open_ms: CoInitializeEx error\n");
+ return bRet;
+ }
+
+ // Obtain the initial locator to Windows Management
+ // on a particular host computer.
+ hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
+ IID_IWbemLocator, (LPVOID *) &pLoc);
+ if (FAILED(hres)) {
+ CoUninitialize();
+ if (fdebugcmd) printf("ipmi_open_ms: CreateInstance(WbemLoc) error\n");
+ return bRet;
+ }
+
+
+ // Connect to the root\cimv2 namespace with the current user
+ // and obtain pointer pSvc to make IWbemServices calls.
+ hres = pLoc->ConnectServer( _bstr_t(L"ROOT\\WMI"), NULL, NULL, 0,
+ NULL, 0, 0, &pSvc );
+ if (FAILED(hres)) {
+ pLoc->Release();
+ CoUninitialize();
+ if (fdebugcmd) printf("ipmi_open_ms: ConnectServer error\n");
+ return bRet;
+ }
+
+ // Set the IWbemServices proxy so that impersonation
+ // of the user (client) occurs.
+ hres = CoSetProxyBlanket( pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE,
+ NULL, EOAC_NONE );
+ if (FAILED(hres)) {
+ if (fdebugcmd) printf("ipmi_open_ms: Cannot SetProxyBlanket\n");
+ cleanup_wmi();
+ return bRet; // Program has failed.
+ }
+
+ hres = pSvc->GetObject( L"Microsoft_IPMI", 0, NULL, &pClass, NULL);
+ if (FAILED(hres)) {
+ cleanup_wmi();
+ if (fdebugcmd)
+ printf("ipmi_open_ms: cannot open microsoft_ipmi driver (ipmidrv.sys)\n");
+ return bRet;
+ }
+
+ hres = pSvc->CreateInstanceEnum( L"microsoft_ipmi", 0, NULL, &pEnumerator);
+ if (FAILED(hres)) {
+ cleanup_wmi();
+ if (fdebugcmd)
+ printf("ipmi_open_ms: cannot open microsoft_ipmi Enum\n");
+ return bRet;
+ }
+
+ hres = pEnumerator->Next( WBEM_INFINITE, 1, &pInstance, &dwCount);
+ if (FAILED(hres)) {
+ if (fdebugcmd)
+ printf("ipmi_open_ms: Cannot get microsoft_ipmi instance\n");
+ cleanup_wmi();
+ return bRet;
+ }
+ VariantInit(&varPath);
+ hres = pInstance->Get(_bstr_t(L"__RelPath"), 0, &varPath, NULL, 0);
+ if (FAILED(hres)) {
+ if (fdebugcmd)
+ printf("ipmi_open_ms: Cannot get instance Path %s\n","__RelPath");
+ cleanup_wmi();
+ return bRet;
+ } else { /*success*/
+ if (fdebugcmd)
+ printf("ipmi_open_ms: ObjectPath: %ls\n",V_BSTR(&varPath));
+ // usually L"Microsoft_IPMI.InstanceName=\"Root\\SYSTEM\\0003_0\"",
+ fmsopen = 1;
+ bRet = 0;
+ }
+
+ return bRet;
+}
+
+int ipmi_close_ms(void)
+{
+ int bRet = -1;
+ if (fmsopen) {
+ cleanup_wmi();
+ fmsopen = 0;
+ bRet = 0;
+ }
+ return bRet;
+}
+
+int ipmi_cmdraw_ms(uchar cmd, uchar netfn, uchar lun, uchar sa,
+ uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ int bRet;
+ HRESULT hres;
+ IWbemClassObject* pInParams = NULL; /*class definition*/
+ IWbemClassObject* pInReq = NULL; /*instance*/
+ IWbemClassObject* pOutResp = NULL;
+ VARIANT varCmd, varNetfn, varLun, varSa, varSize, varData;
+ SAFEARRAY* psa = NULL;
+ long i;
+ uchar *p;
+
+ fdebugms = fdebugcmd;
+ if (!fmsopen) {
+ bRet = ipmi_open_ms(fdebugcmd);
+ if (bRet != 0) return(bRet);
+ }
+ bRet = -1;
+
+
+ hres = pClass->GetMethod(L"RequestResponse",0,&pInParams,NULL);
+ if (FAILED(hres)) {
+ if (fdebugcmd)
+ printf("ipmi_cmdraw_ms: Cannot get RequestResponse method\n");
+ return (bRet);
+ }
+
+#ifdef WDM_FIXED
+ /* see http://support.microsoft.com/kb/951242 for WDM bug info */
+ hres = pInParams->SpawnInstance(0,&pInReq);
+ if (FAILED(hres)) {
+ if (fdebugcmd)
+ printf("ipmi_cmdraw_ms: Cannot get RequestResponse instance\n");
+ return (bRet);
+ }
+ // also substitute pInReq for pInParams below if this gets fixed.
+#endif
+
+ VariantInit(&varCmd);
+ varCmd.vt = VT_UI1;
+ varCmd.bVal = cmd;
+ hres = pInParams->Put(_bstr_t(L"Command"), 0, &varCmd, 0);
+ // VariantClear(&varCmd);
+ if (FAILED(hres)) goto MSRET;
+
+ VariantInit(&varNetfn);
+ varNetfn.vt = VT_UI1;
+ varNetfn.bVal = netfn;
+ hres = pInParams->Put(_bstr_t(L"NetworkFunction"), 0, &varNetfn, 0);
+ // VariantClear(&varNetfn);
+ if (FAILED(hres)) goto MSRET;
+
+ VariantInit(&varLun);
+ varLun.vt = VT_UI1;
+ varLun.bVal = lun;
+ hres = pInParams->Put(_bstr_t(L"Lun"), 0, &varLun, 0);
+ // VariantClear(&varLun);
+ if (FAILED(hres)) goto MSRET;
+
+ VariantInit(&varSa);
+ varSa.vt = VT_UI1;
+ varSa.bVal = sa;
+ hres = pInParams->Put(_bstr_t(L"ResponderAddress"), 0, &varSa, 0);
+ // VariantClear(&varSa);
+ if (FAILED(hres)) goto MSRET;
+
+ VariantInit(&varSize);
+ varSize.vt = VT_I4;
+ varSize.lVal = sdata;
+ hres = pInParams->Put(_bstr_t(L"RequestDataSize"), 0, &varSize, 0);
+ // VariantClear(&varSize);
+ if (FAILED(hres)) goto MSRET;
+
+ SAFEARRAYBOUND rgsabound[1];
+ rgsabound[0].cElements = sdata;
+ rgsabound[0].lLbound = 0;
+ psa = SafeArrayCreate(VT_UI1,1,rgsabound);
+ if(!psa) {
+ printf("ipmi_cmdraw_ms: SafeArrayCreate failed\n");
+ goto MSRET;
+ }
+#ifdef SHOULD_WORK_BUT_NO
+ /* The SafeArrayPutElement does not put the data in the right
+ * place, so skip this and copy the raw data below. */
+ VARIANT tvar;
+ if (fdebugcmd && sdata > 0)
+ { printf("psa1(%p):",psa); dumpbuf((uchar *)psa,42,1); }
+
+ for(i =0; i< sdata; i++)
+ {
+ VariantInit(&tvar);
+ tvar.vt = VT_UI1;
+ tvar.bVal = pdata[i];
+ hres = SafeArrayPutElement(psa, &i, &tvar);
+ // VariantClear(&tvar);
+ if (FAILED(hres)) {
+ printf("ipmi_cmdraw_ms: SafeArrayPutElement(%d) failed\n",i);
+ goto MSRET;
+ }
+ } /*end for*/
+ if (fdebugcmd && sdata > 0)
+ { printf("psa2(%p):",psa); dumpbuf((uchar *)psa,42,1); }
+#endif
+
+ /* Copy the real RequestData into psa */
+ memcpy(psa->pvData,pdata,sdata);
+
+ VariantInit(&varData);
+ varData.vt = VT_ARRAY | VT_UI1;
+ varData.parray = psa;
+ hres = pInParams->Put(_bstr_t(L"RequestData"), 0, &varData, 0);
+ // VariantClear(&varData);
+ if (FAILED(hres)) {
+ printf("Put(RequestData) error %x\n",hres);
+ goto MSRET;
+ }
+
+#ifdef TEST_METHODS
+ IWbemClassObject* pOutSms = NULL;
+ if (fdebugcmd) printf("ipmi_cmdraw_ms: calling SMS_Attention(%ls)\n",
+ V_BSTR(&varPath));
+ hres = pSvc->ExecMethod( V_BSTR(&varPath), _bstr_t(L"SMS_Attention"),
+ 0, NULL, NULL, &pOutSms, NULL);
+ if (FAILED(hres)) {
+ printf("ipmi_cmdraw_ms: SMS_Attention method error %x\n",hres);
+ goto MSRET;
+ }
+ if (fdebugcmd) printf("ipmi_cmdraw_ms: SMS_Attention method ok\n");
+ /* This does work, without input parameters */
+ pOutSms->Release();
+#endif
+
+ hres = pSvc->ExecMethod( V_BSTR(&varPath), _bstr_t(L"RequestResponse"),
+ 0, NULL, pInParams, &pOutResp, NULL);
+ if (fdebugcmd) {
+ printf("ipmi_cmdraw_ms(cmd=%x,netfn=%x,lun=%x,sa=%x,sdata=%d)"
+ " RequestResponse ret=%x\n", cmd,netfn,lun,sa,sdata,hres);
+ if (sdata > 0) {
+ printf("ipmi_cmdraw_ms: req data(%d):",sdata);
+ dumpbuf(pdata,sdata,0);
+ }
+ }
+ if (FAILED(hres)) {
+ printf("ipmi_cmdraw_ms: RequestResponse error %x %s\n",
+ hres,res_str(hres));
+#ifdef EXTRA_DESC
+ /* This does not usually add any meaning for IPMI. */
+ BSTR desc;
+ IErrorInfo *pIErrorInfo;
+ GetErrorInfo(0,&pIErrorInfo);
+ pIErrorInfo->GetDescription(&desc);
+ printf("ipmi_cmdraw_ms: ErrorInfoDescr: %ls\n",desc);
+ SysFreeString(desc);
+#endif
+ bRet = -1;
+ /*fall through for cleanup and return*/
+ }
+ else { /*successful, get ccode and response data */
+ VARIANT varByte, varRSz, varRData;
+ VariantInit(&varByte);
+ VariantInit(&varRSz);
+ VariantInit(&varRData);
+ long rlen;
+
+ hres = pOutResp->Get(_bstr_t(L"CompletionCode"),0, &varByte, NULL, 0);
+ if (FAILED(hres)) goto MSRET;
+ if (fdebugcmd) printf("ipmi_cmdraw_ms: CompletionCode %x returned\n",
+ V_UI1(&varByte) );
+ *pcc = V_UI1(&varByte);
+
+ hres = pOutResp->Get(_bstr_t(L"ResponseDataSize"),0, &varRSz, NULL, 0);
+ if (FAILED(hres)) goto MSRET;
+ rlen = V_I4(&varRSz);
+ if (rlen > 1) rlen--; /*skip cc*/
+ if (rlen > *sresp) {
+ if (fdebugcmd) printf("ResponseData truncated from %d to %d\n",
+ rlen,*sresp);
+ rlen = *sresp; /*truncate*/
+ }
+ *sresp = (int)rlen;
+
+ hres = pOutResp->Get(_bstr_t(L"ResponseData"),0, &varRData, NULL,0);
+ if (FAILED(hres)) { /*ignore failure */
+ if (fdebugcmd) printf("Get ResponseData error %x\n",hres);
+ } else { /* success */
+#ifdef SHOULD_WORK_BUT_NO
+ uchar *pa;
+ p = (uchar*)varRData.parray->pvData;
+ pa = (uchar*)varRData.parray;
+ printf("pa=%p, pa+12=%p p=%p\n",pa,(pa+12),p);
+ if (fdebugcmd) {
+ printf("Data.vt = %04x, Data.parray(%p):",
+ varRData.vt, varRData.parray);
+ // 0x2011 means VT_ARRAY | VT_UI1
+ dumpbuf((uchar *)varRData.parray,40,1);
+ }
+ /* The SafeArrayGetElement does not get the data from the right
+ * place, so skip this and copy the raw data below. */
+ VARIANT rgvar[NVAR];
+ if (rlen > NVAR) *pcc = 0xEE;
+ for (i = 0; i <= rlen; i++)
+ VariantInit(&rgvar[i]);
+ /* copy the response data from varRData to presp */
+ for( i = 0; i <= rlen; i++)
+ {
+ hres = SafeArrayGetElement(varRData.parray, &i, &rgvar[i]);
+ if (FAILED(hres)) {
+ if (fdebugcmd)
+ printf("ipmi_cmdraw_ms: SafeArrayGetElement(%d) failed\n",i);
+ break;
+ }
+ if (fdebugcmd) {
+ printf("Data[%d] vt=%02x val=%02x, rgvar(%p):",i,
+ rgvar[i].vt, V_UI1(&rgvar[i]),&rgvar[i]);
+ dumpbuf((uchar *)&rgvar[i],12,0);
+ }
+ /* skip the completion code */
+ // if (i > 0) presp[i-1] = V_UI1(&rgvar[i]);
+ } /*end for*/
+#endif
+ /*
+ * parray from a GetDeviceId response:
+ * 0015CEE0: 01 00 80 00 01 00 00 00 00 00 00 00 00 cf 15 00
+ * 0015CEF0: 10 00 00 00 00 00 00 00 03 00 06 00 95 01 08 00
+ * ^- datalen=0x10
+ * 0015CF00: 00 20 01 00 19 02 9f 57 01 ...
+ * ^- start of data (cc=00, ...)
+ */
+ /* Copy the real ResponseData into presp. */
+ p = (uchar*)varRData.parray->pvData;
+ for( i = 0; i <= rlen; i++) {
+ /* skip the completion code */
+ if (i > 0) presp[i-1] = p[i];
+ }
+ if (fdebugcmd) {
+ printf("ipmi_cmdraw_ms: resp data(%d):",rlen+1);
+ dumpbuf(p,rlen+1,0);
+ }
+ }
+ bRet = 0;
+ }
+
+MSRET:
+#define CLEAN_OK 1
+#ifdef CLEAN_OK
+ /* VariantClear(&var*) should be done by pInParams->Release() */
+ if (psa != NULL) SafeArrayDestroy(psa);
+ if (pInParams != NULL) pInParams->Release();
+ if (pOutResp != NULL) pOutResp->Release();
+#endif
+ return(bRet);
+}
+
+#ifndef ALONE
+int ipmi_cmd_ms(ushort cmd, uchar *pdata, int sdata,
+ uchar *presp, int *sresp, uchar *pcc, char fdebugcmd)
+{
+ int bRet = -1;
+ int i;
+
+ fdebugms = fdebugcmd;
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ printf("ipmi_cmd_ms: Unknown command %04x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) cmd = cmd & CMDMASK; /* unmask it */
+
+ bRet = ipmi_cmdraw_ms((uchar)cmd,ipmi_cmds[i].netfn,ipmi_cmds[i].lun,
+ ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ pdata,sdata,presp,sresp,pcc,fdebugcmd);
+ return (bRet);
+}
+#endif
+
+} /* end C */
+
+#ifdef TEST_BIN
+int main(int argc, char **argv)
+{
+ uchar rdata[40];
+ int i, rv;
+ int rlen = 0;
+ uchar cc;
+
+ fdebugms = 1;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw_ms(0x01, 0x06, 0, 0x20, 0, /*get_device_id*/
+ NULL, 0, rdata, &rlen, &cc, fdebugms);
+ printf("ipmi_cmdraw_ms ret=%d, cc=%02x\n",rv,cc);
+ if (rv == 0) {
+ printf(" ** Return Code: %2.2X\n", cc);
+ printf(" ** Data[%d]:",rlen);
+ for (i=0; i < rlen; i++)
+ printf(" %2.2X", rdata[i]);
+ printf("\n");
+ }
+ ipmi_close_ms();
+ return 0;
+}
+#endif
+
+
+#endif
+/* endif WIN32 */
+
+/* end ipmims.cpp */
diff --git a/util/ipmimv.c b/util/ipmimv.c
new file mode 100644
index 0000000..06b1baf
--- /dev/null
+++ b/util/ipmimv.c
@@ -0,0 +1,784 @@
+/*M*
+// PVCS:
+// $Workfile: ipmimv.c $
+// $Revision: 1.1 $
+// $Modtime: 08 Apr 2003 15:31:14 $
+// $Author: arcress at users.sourceforge.net $
+//
+// This implements support for the /dev/ipmi0 native interface from
+// the MontaVista OpenIPMI Linux driver.
+//
+// To build this as a standalone test program, do this:
+// # gcc -DLINUX -g -O2 -DTEST_BIN -o ipmimv ipmimv.c
+//
+// 01/29/03 ARC - created, derived from ipmi_test.c and ipmitool_mv.c
+// 04/08/03 ARC - don't watch stdin on select, since stdin may not be
+// valid if invoked from cron, etc.
+// 06/11/03 ARC - ignore EMSGSIZE errno for get_wdt command
+// 05/05/04 ARC - only open/close device once per application,
+// rely on each app calling ipmi_close, helps performance.
+// 08/10/04 ARC - handle alternate device filenames for some 2.6 kernels
+// 03/01/05 ARC - fix /dev/ipmi0 IPMB requests (to other than BMC_SA)
+// 04/12/07 ARC - check for IPMI_ASYNC_EVENT_RECV_TYPE in ipmicmd_mv
+ *M*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2002-2005, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#if defined(LINUX) || defined(BSD) || defined(MACOS)
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#if defined(MACOS)
+#include <sys/time.h>
+#else
+#include <sys/poll.h>
+#endif
+#ifdef SCO_UW
+#include <sys/ioccom.h>
+#endif
+
+#ifdef TEST_BIN
+#define ALONE 1
+#endif
+
+static void dbgmsg(char *pattn, ...);
+#ifdef ALONE
+#define uchar unsigned char
+#define ACCESS_OK 0
+#define GET_SEL_ENTRY 0x43
+static FILE *fperr = NULL;
+static FILE *fpdbg = NULL;
+void dump_buf(char *tag,uchar *pbuf,int sz, char fshowascii)
+{
+ if (pbuf == NULL || sz == 0) return;
+ dbgmsg("%s sz=%d buf: %02x %02x %02x %02x\n",tag,sz,
+ pbuf[0],pbuf[1], pbuf[2],pbuf[3]);
+}
+#else
+#include "ipmicmd.h"
+extern FILE *fperr; /*defined in ipmicmd.c*/
+extern FILE *fpdbg; /*defined in ipmicmd.c*/
+extern ipmi_cmd_t ipmi_cmds[NCMDS];
+#endif
+
+#define MV_BUFFER_SIZE 300 /*see IPMI_RSPBUF_SIZE also */
+#define IPMI_MAX_ADDR_SIZE 32
+#define IPMI_RESPONSE_RECV_TYPE 1
+#define IPMI_ASYNC_EVENT_RECV_TYPE 2
+#define IPMI_CMD_RECV_TYPE 3
+#define IPMI_RESPONSE_RESPONSE_TYPE 4
+
+#ifdef TV_PORT
+/* use this to define timeval if it is a portability issue */
+struct timeval {
+ long int tv_sec; /* (time_t) seconds */
+ long int tv_usec; /* (suseconds_t) microseconds */
+};
+#endif
+
+int ipmi_timeout_mv = 10; /* 10 seconds, was 5 sec */
+#if defined(BSD) || defined(MACOS)
+#pragma pack(1)
+#endif
+
+struct ipmi_addr
+{
+ int adrtype;
+ short channel;
+ char data[IPMI_MAX_ADDR_SIZE];
+};
+
+struct ipmi_msg
+{
+ uchar netfn;
+ uchar cmd;
+ ushort data_len;
+ uchar *data;
+};
+
+struct ipmi_req
+{
+ unsigned char *addr; /* Address to send the message to. */
+ unsigned int addr_len;
+ long msgid; /* The sequence number for the message. */
+ struct ipmi_msg msg;
+};
+
+struct ipmi_recv
+{
+ int recv_type; /* Is this a command, response, etc. */
+ unsigned char *addr; /* Address the message was from */
+ int addr_len; /* The size of the address buffer. */
+ long msgid; /* The sequence number from the request */
+ struct ipmi_msg msg; /* The data field must point to a buffer. */
+};
+
+struct ipmi_cmdspec
+{
+ unsigned char netfn;
+ unsigned char cmd;
+};
+#if defined(BSD) || defined(MACOS)
+#pragma pack()
+/* FreeBSD 7.x ipmi ioctls, use _IOW */
+#define IPMI_IOC_MAGIC 'i'
+#define IPMICTL_RECEIVE_MSG_TRUNC _IOWR(IPMI_IOC_MAGIC, 11, struct ipmi_recv)
+#define IPMICTL_RECEIVE_MSG _IOWR(IPMI_IOC_MAGIC, 12, struct ipmi_recv)
+#define IPMICTL_SEND_COMMAND _IOW(IPMI_IOC_MAGIC, 13, struct ipmi_req)
+#define IPMICTL_REGISTER_FOR_CMD _IOW(IPMI_IOC_MAGIC, 14, struct ipmi_cmdspec)
+#define IPMICTL_UNREGISTER_FOR_CMD _IOW(IPMI_IOC_MAGIC, 15, struct ipmi_cmdspec)
+#define IPMICTL_SET_GETS_EVENTS_CMD _IOW(IPMI_IOC_MAGIC, 16, int)
+#define IPMICTL_SET_MY_ADDRESS_CMD _IOW(IPMI_IOC_MAGIC, 17, unsigned int)
+#define IPMICTL_GET_MY_ADDRESS_CMD _IOW(IPMI_IOC_MAGIC, 18, unsigned int)
+
+#else
+/* Linux ipmi ioctls */
+#define IPMI_IOC_MAGIC 'i'
+#define IPMICTL_RECEIVE_MSG_TRUNC _IOWR(IPMI_IOC_MAGIC, 11, struct ipmi_recv)
+#define IPMICTL_RECEIVE_MSG _IOWR(IPMI_IOC_MAGIC, 12, struct ipmi_recv)
+#define IPMICTL_SEND_COMMAND _IOR(IPMI_IOC_MAGIC, 13, struct ipmi_req)
+#define IPMICTL_REGISTER_FOR_CMD _IOR(IPMI_IOC_MAGIC, 14,struct ipmi_cmdspec)
+#define IPMICTL_UNREGISTER_FOR_CMD _IOR(IPMI_IOC_MAGIC, 15,struct ipmi_cmdspec)
+#define IPMICTL_SET_GETS_EVENTS_CMD _IOR(IPMI_IOC_MAGIC, 16, int)
+#define IPMICTL_SET_MY_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 17, unsigned int)
+#define IPMICTL_GET_MY_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 18, unsigned int)
+#endif
+
+/* MAINT ioctls used below, but only valid for Linux */
+#define IPMICTL_GET_MAINTENANCE_MODE_CMD _IOR(IPMI_IOC_MAGIC, 30, int)
+#define IPMICTL_SET_MAINTENANCE_MODE_CMD _IOW(IPMI_IOC_MAGIC, 31, int)
+#define IPMICTL_GETMAINT 0x8004691e /*only valid if OpenIPMI >=v39.1 */
+#define IPMICTL_SETMAINT 0x4004691f /*only valid if OpenIPMI >=v39.1 */
+
+#define BMC_SA 0x20
+#define IPMI_BMC_CHANNEL 0xf
+#define IPMI_SYSTEM_INTERFACE_ADDR_TYPE 0x0c
+#define IPMI_IPMB_ADDR_TYPE 0x01
+#define IPMI_IPMB_BROADCAST_ADDR_TYPE 0x41
+/* Broadcast get device id is used as described in IPMI 1.5 section 17.9. */
+#define IPMI_LAN_ADDR_TYPE 0x04
+
+struct ipmi_system_interface_addr
+{
+ int adrtype;
+ short channel;
+ unsigned char lun;
+};
+
+struct ipmi_ipmb_addr
+{
+ int adrtype;
+ short channel;
+ uchar slave_addr;
+ uchar lun;
+};
+
+struct ipmi_lan_addr
+{
+ int adrtype;
+ short channel;
+ unsigned char privilege;
+ unsigned char session_handle;
+ unsigned char remote_SWID;
+ unsigned char local_SWID;
+ unsigned char lun;
+};
+
+static int ipmi_fd = -1;
+static int curr_seq = 0;
+static int fdebugmv = 0;
+static struct ipmi_addr rsp_addr; /*used in getevent_mv, ipmi_rsp_mv*/
+static int rsp_addrlen = 0; /*used in getevent_mv, ipmi_rsp_mv*/
+
+void ipmi_get_mymc(uchar *bus, uchar *sa, uchar *lun, uchar *type);
+
+static void dbgmsg(char *pattn, ...)
+{
+ va_list arglist;
+
+ if (fpdbg == NULL) return;
+ // if (fdebugmv == 0) return;
+ va_start( arglist, pattn );
+ vfprintf( fpdbg, pattn, arglist );
+ va_end( arglist );
+ fflush( fpdbg );
+}
+
+int ipmi_open_mv(char fdebugcmd)
+{
+ char *pdev;
+ uchar bus, sa, lun;
+
+#ifdef ALONE
+ fperr = stderr;
+ fpdbg = stdout;
+#endif
+
+ if (ipmi_fd != -1) return(0); /*already open*/
+ fdebugmv = fdebugcmd;
+ pdev = "/dev/ipmi/0";
+ ipmi_fd = open("/dev/ipmi/0", O_RDWR);
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) dbgmsg("ipmi_open_mv: cannot open %s\n",pdev);
+ pdev = "/dev/ipmi0";
+ ipmi_fd = open(pdev, O_RDWR);
+ }
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) dbgmsg("ipmi_open_mv: cannot open %s\n",pdev);
+ pdev = "/dev/ipmidev0";
+ ipmi_fd = open(pdev, O_RDWR);
+ }
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) dbgmsg("ipmi_open_mv: cannot open %s\n",pdev);
+ pdev = "/dev/ipmidev/0";
+ ipmi_fd = open(pdev, O_RDWR);
+ }
+ if (ipmi_fd == -1) {
+ if (fdebugcmd) dbgmsg("ipmi_open_mv: cannot open %s\n",pdev);
+ return(-1);
+ }
+ ipmi_get_mymc(&bus,&sa,&lun,NULL);
+ if (sa != BMC_SA) { /* user specified my slave address*/
+ int a, rv;
+ a = sa;
+ rv = ioctl(ipmi_fd, IPMICTL_SET_MY_ADDRESS_CMD, &a);
+ if (fdebugcmd) dbgmsg("ipmi_open_mv: set_my_address(%x) rv=%d\n",sa,rv);
+ if (rv < 0) {
+ return(rv);
+ }
+ }
+
+ if (fdebugcmd) {
+ dbgmsg("ipmi_open_mv: successfully opened %s, fd=%d\n",pdev,ipmi_fd);
+ }
+ return(0);
+}
+
+int ipmi_close_mv(void)
+{
+ int rc = 0;
+ if (ipmi_fd != -1) {
+ rc = close(ipmi_fd);
+ ipmi_fd = -1;
+ }
+ return(rc);
+}
+
+int ipmi_rsp_mv(uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, char fdebugcmd)
+{
+ struct ipmi_req req;
+ // struct ipmi_recv rsp;
+ struct ipmi_lan_addr lan_addr;
+ // int i, done;
+ int rv;
+
+ rv = ipmi_open_mv(fdebugcmd);
+ if (rv != 0) return(rv);
+
+ if (rsp_addrlen > 0) {
+ /* rsp_addr was previously saved in getevent_mv */
+ req.addr = (char *)&rsp_addr;
+ req.addr_len = rsp_addrlen;
+ } else { /* try some defaults */
+ lan_addr.adrtype = IPMI_LAN_ADDR_TYPE;
+ lan_addr.channel = bus; /* usu lan_ch == 1 */
+ lan_addr.privilege = 0x04; /*admin*/
+ lan_addr.session_handle = 0x01; /*may vary*/
+ lan_addr.remote_SWID = sa; /*usu 0x81*/
+ lan_addr.local_SWID = 0x81;
+ lan_addr.lun = lun;
+ req.addr = (char *) &lan_addr;
+ req.addr_len = sizeof(lan_addr);
+ }
+ req.msg.cmd = cmd;
+ req.msg.netfn = (netfn | 0x01);
+ req.msgid = curr_seq;
+ req.msg.data = pdata;
+ req.msg.data_len = sdata;
+ rv = ioctl(ipmi_fd, IPMICTL_SEND_COMMAND, &req);
+ curr_seq++;
+ if (rv == -1) {
+ if (fdebugcmd) dbgmsg("mv IPMICTL_SEND_COMMAND errno %d\n",errno);
+ rv = errno;
+ }
+ return(rv);
+}
+
+int ipmicmd_mv(uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int sresp, int *rlen)
+{
+ fd_set readfds;
+ struct timeval tv;
+ struct ipmi_req req;
+ struct ipmi_recv rsp;
+ struct ipmi_addr addr;
+ struct ipmi_ipmb_addr ipmb_addr;
+ struct ipmi_system_interface_addr bmc_addr;
+ static int need_set_events = 1;
+ int i, done;
+ int rv;
+
+ rv = ipmi_open_mv(fdebugmv);
+ if (rv != 0) return(rv);
+
+ if (need_set_events) {
+ i = 1;
+ rv = ioctl(ipmi_fd, IPMICTL_SET_GETS_EVENTS_CMD, &i);
+ if (fdebugmv)
+ dbgmsg("getevent_mv: set_gets_events rv=%d errno=%d, n=%d\n",
+ rv,errno,i);
+ if (rv) { return(errno); }
+ need_set_events = 0;
+ }
+
+ FD_ZERO(&readfds);
+ // FD_SET(0, &readfds); /* dont watch stdin */
+ FD_SET(ipmi_fd, &readfds); /* only watch ipmi_fd for input */
+
+ /* Special handling for ReadEventMsgBuffer, etc. */
+#ifdef TEST_MSG
+ recv.msg.data = data;
+ recv.msg.data_len = sizeof(data);
+ recv.addr = (unsigned char *) &addr;
+ recv.addr_len = sizeof(addr);
+ rv = ioctl(fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv);
+ if (rv == -1) {
+ if (errno == EMSGSIZE) {
+ /* The message was truncated, handle it as such. */
+ data[0] = IPMI_REQUESTED_DATA_LENGTH_EXCEEDED_CC;
+ rv = 0;
+ } else
+ goto out;
+ }
+#endif
+
+ /* Send the IPMI command */
+ if (sa == BMC_SA) {
+ i = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+ bmc_addr.adrtype = i;
+ bmc_addr.channel = IPMI_BMC_CHANNEL;
+ bmc_addr.lun = lun; /* usu BMC_LUN = 0 */
+ req.addr = (char *) &bmc_addr;
+ req.addr_len = sizeof(bmc_addr);
+ } else {
+ i = IPMI_IPMB_ADDR_TYPE;
+ ipmb_addr.adrtype = i;
+ ipmb_addr.channel = bus; /* usu PUBLIC_BUS = 0 */
+ ipmb_addr.slave_addr = sa;
+ ipmb_addr.lun = lun;
+ req.addr = (char *) &ipmb_addr;
+ req.addr_len = sizeof(ipmb_addr);
+ }
+ if (fdebugmv)
+ dbgmsg("mv cmd=%02x netfn=%02x mc=%02x;%02x;%02x adrtype=%x\n",
+ cmd,netfn,bus,sa,lun,i);
+ req.msg.cmd = cmd;
+ req.msg.netfn = netfn;
+ req.msgid = curr_seq;
+ req.msg.data = pdata;
+ req.msg.data_len = sdata;
+ rv = ioctl(ipmi_fd, IPMICTL_SEND_COMMAND, &req);
+ curr_seq++;
+ if (rv == -1) {
+ if (fdebugmv) dbgmsg("mv IPMICTL_SEND_COMMAND errno %d\n",errno);
+ rv = errno;
+ }
+
+ if (netfn & 0x01) done = 1; /*sending response only*/
+ else done = 0; /*normal request/response*/
+
+ if (rv == 0) while (!done) {
+ done = 1;
+ tv.tv_sec=ipmi_timeout_mv;
+ tv.tv_usec=0;
+ rv = select(ipmi_fd+1, &readfds, NULL, NULL, &tv);
+ /* expect select rv = 1 here */
+ if (rv <= 0) { /* no data within 5 seconds */
+ if (fdebugmv)
+ fprintf(fperr,"mv select timeout, fd = %d, isset = %d, rv = %d, errno = %d\n",
+ ipmi_fd,FD_ISSET(ipmi_fd, &readfds),rv,errno);
+ if (rv == 0) rv = -3;
+ else rv = errno;
+ } else {
+ /* receive the IPMI response */
+ rsp.addr = (char *) &addr;
+ rsp.addr_len = sizeof(addr);
+ rsp.msg.data = presp;
+ rsp.msg.data_len = sresp;
+ rv = ioctl(ipmi_fd, IPMICTL_RECEIVE_MSG_TRUNC, &rsp);
+ if (rv == -1) {
+ if ((errno == EMSGSIZE) && (rsp.msg.data_len == sresp))
+ rv = 0; /* errno 90 is ok */
+ else {
+ rv = errno;
+ fprintf(fperr,"mv rcv_trunc errno = %d, len = %d\n",
+ errno, rsp.msg.data_len);
+ }
+ } else rv = 0;
+ /* Driver should ensure matching req.msgid and rsp.msgid */
+ /* Skip & retry if async events, only listen for those in
+ * getevent_mv() below. */
+ // if (rsp.recv_type == IPMI_ASYNC_EVENT_RECV_TYPE)
+ if (rsp.recv_type != IPMI_RESPONSE_RECV_TYPE) {
+ if (fdebugmv)
+ dbgmsg("mv cmd=%02x netfn=%02x, got recv_type %d\n",
+ cmd,netfn,rsp.recv_type);
+ done = 0;
+ }
+ *rlen = rsp.msg.data_len;
+ }
+ } /*endif send ok, while select/recv*/
+
+ /* ipmi_close_mv(); * rely on the app calling ipmi_close */
+ return(rv);
+}
+
+int ipmi_cmdraw_mv(uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus,
+ uchar *pdata, int sdata, uchar *presp, int *sresp,
+ uchar *pcc, char fdebugcmd)
+{
+ uchar buf[MV_BUFFER_SIZE];
+ int rc, szbuf;
+ int rlen = 0;
+ uchar cc;
+
+ if (fdebugcmd) {
+ dbgmsg("mv cmd=%02x netfn=%02x lun=%02x sdata=%d sresp=%d\n",
+ cmd,netfn,lun,sdata,*sresp);
+ dump_buf("mv cmd data",pdata,sdata,0);
+ }
+ szbuf = sizeof(buf);
+ if (*sresp < 2) ; /*just completion code*/
+ else if (*sresp < szbuf) szbuf = *sresp + 1;
+ else if (fdebugcmd)
+ dbgmsg("mv sresp %d >= szbuf %d, truncated\n",*sresp,szbuf);
+ rc = ipmicmd_mv(cmd,netfn,lun,sa, bus, pdata,sdata, buf,szbuf,&rlen);
+ cc = buf[0];
+ if (fdebugcmd) {
+ dbgmsg("ipmi_cmdraw_mv: status=%d ccode=%x rlen=%d\n",
+ (uint)rc,cc,rlen);
+ if (rc == 0) dump_buf("mv rsp data",buf,rlen,0);
+ }
+ if (rlen > 0) { /* copy data, except first byte */
+ rlen -= 1;
+ if (rlen > *sresp) rlen = *sresp;
+ memcpy(presp,&buf[1],rlen);
+ }
+ *pcc = cc;
+ *sresp = rlen;
+ return(rc);
+}
+
+#ifdef ALONE
+void ipmi_get_mymc(uchar *bus, uchar *sa, uchar *lun, uchar *type)
+{
+ if (bus != NULL) *bus = 0; //PUBLIC_BUS;
+ if (sa != NULL) *sa = BMC_SA;
+ if (lun != NULL) *lun = 0; //BMC_LUN;
+ if (type != NULL) *type = 1; //ADDR_SMI;
+}
+#else
+int ipmi_cmd_mv(ushort cmd, uchar *pdata, int sdata, uchar *presp,
+ int *sresp, uchar *pcc, char fdebugcmd)
+{
+ uchar buf[MV_BUFFER_SIZE];
+ int rc, i, szbuf;
+ uchar cc;
+ int rlen = 0;
+ int xlen, j;
+ uchar sa, lun, bus, mtype;
+
+ for (i = 0; i < NCMDS; i++) {
+ if (ipmi_cmds[i].cmdtyp == cmd) break;
+ }
+ if (i >= NCMDS) {
+ fprintf(fperr, "ipmi_cmd_mv: Unknown command %x\n",cmd);
+ return(-1);
+ }
+ if (cmd >= CMDMASK) cmd = cmd & CMDMASK; /* unmask it */
+
+ if (fdebugcmd) {
+ dbgmsg( "mv cmd=%02x netfn=%02x lun=%02x sdata=%d sresp=%d\n",
+ cmd,ipmi_cmds[i].netfn,ipmi_cmds[i].lun,sdata, *sresp);
+ dump_buf("mv cmd data",pdata,sdata,0);
+ }
+ szbuf = sizeof(buf);
+ if (*sresp < szbuf && *sresp >= 2) szbuf = *sresp + 1;
+ else if (fdebugcmd)
+ dbgmsg("mv sresp %d >= szbuf %d, truncated\n",*sresp,szbuf);
+ // ipmi_cmds[i].lun, ipmi_cmds[i].sa, ipmi_cmds[i].bus,
+ ipmi_get_mc(&bus, &sa, &lun, &mtype);
+ rc = ipmicmd_mv(cmd,ipmi_cmds[i].netfn, lun, sa, bus,
+ pdata,sdata,buf,szbuf,&rlen);
+ // if (rc == -1) dbgmsg("ipmi_cmd_mv: cannot open /dev/ipmi0\n");
+ cc = buf[0];
+ if (fdebugcmd) {
+ dbgmsg("ipmi_cmd_mv: ipmicmd_mv status=%x, ccode=%x\n",
+ (uint)rc, cc);
+ if (rc == ACCESS_OK) {
+ uchar * pc; int sz;
+ sz = rlen;
+ pc = (uchar *)buf;
+ dbgmsg("ipmi_cmd_mv: response (len=%d): ",sz);
+ for (j = 0; j < sz; j++) dbgmsg("%02x ",pc[j]);
+ dbgmsg("\n");
+ }
+ }
+ xlen = ipmi_cmds[i].rslen + 1;
+ if ((ipmi_cmds[i].cmdtyp == GET_SEL_ENTRY) &&
+ (rlen < xlen) && (rc == 0) && (cc != 0) &&
+ (i > 0) && (rlen > 1)) /*not temp slot, have data*/
+ {
+ /* Detect/Handle MV driver SEL bug returning missing bytes */
+ if (fdebugcmd) {
+ dbgmsg("ipmi_cmd_mv[%d] BUG: returned %d, expected %d\n",
+ i,rlen,xlen);
+ }
+ cc = 0x80; /*flag as busy, retry*/
+ j = xlen - rlen;
+ j--; /* omit cc */
+ for (i = 0; i < j; i++) presp[i] = 0xff;
+ if ((rlen+j) > *sresp) rlen = *sresp - j;
+ memcpy(&presp[j],&buf[0],rlen);
+ rlen += j;
+ }
+ if (rlen > 0) {
+ /* copy data, except first byte */
+ rlen -= 1;
+ if (rlen > *sresp) rlen = *sresp;
+ memcpy(presp,&buf[1],rlen);
+ }
+ *pcc = cc;
+ *sresp = rlen;
+
+ return(rc);
+} /*end ipmi_cmd_mv*/
+#endif
+
+int setmaint_mv(uchar mode, uchar *cc)
+{
+ int data[2];
+ int rv;
+ /*
+ * Normally OpenIPMI driver issues ReadEventMessageBuffer cmds
+ * every 1 second. Maint mode disables that polling in
+ * driver v39.1 and greater.
+ * maintenance mode values:
+ * 2 = turn on maint mode
+ * 1 = turn off maint mode
+ * 0 = automatic maint mode (on for 30 sec if reset or fw request)
+ */
+
+ /* should have called ipmi_open_mv in a previous call */
+ rv = ioctl(ipmi_fd, IPMICTL_GETMAINT, &data);
+ if (rv == -1) {
+ if (errno != 0) *cc = errno;
+ } else *cc = 0;
+ if (fdebugmv) dbgmsg("getmaint: rv=%d mode=%d\n",rv,data[0]);
+
+ data[0] = mode;
+ rv = ioctl(ipmi_fd, IPMICTL_SETMAINT, &data);
+ if (rv == -1) {
+ if (errno != 0) *cc = errno;
+ } else *cc = 0;
+ return(rv);
+}
+
+int register_async_mv(uchar cmd, uchar netfn)
+{
+ uchar data[2];
+ int rv;
+
+ data[0] = netfn;
+ data[1] = cmd;
+ rv = ioctl(ipmi_fd, IPMICTL_REGISTER_FOR_CMD, &data);
+ if (fdebugmv) dbgmsg("register_async_mv(%x,%x) rv=%d\n",cmd,netfn,rv);
+ return(rv);
+}
+
+int unregister_async_mv(uchar cmd, uchar netfn)
+{
+ uchar data[2];
+ int rv;
+
+ data[0] = netfn;
+ data[1] = cmd;
+ rv = ioctl(ipmi_fd, IPMICTL_UNREGISTER_FOR_CMD, &data);
+ if (fdebugmv) dbgmsg("unregister_async_mv(%x,%x) rv=%d\n",cmd,netfn,rv);
+ return(rv);
+}
+
+int getevent_mv(uchar *evt_data, int *evt_len, uchar *cc, int timeout)
+{
+ struct ipmi_recv rsp;
+ uchar data[36]; /* #define MAX_IPMI_DATA_SIZE 36 */
+ struct ipmi_addr addr;
+ static int need_set_events = 1;
+ int rv = 0;
+ int n;
+
+ if (need_set_events) {
+ n = 1;
+ rv = ioctl(ipmi_fd, IPMICTL_SET_GETS_EVENTS_CMD, &n);
+ if (fdebugmv)
+ dbgmsg("getevent_mv: set_gets_events rv=%d errno=%d, n=%d\n",
+ rv,errno,n);
+ need_set_events = 0;
+ }
+
+ /* wait for the mv openipmi driver to provide input to fd */
+ if (timeout == 0)
+ { /*do poll*/
+#if defined(MACOS)
+ /* there is no poll function in MACOS, so skip this. */
+#else
+ struct pollfd myfd;
+ myfd.fd = ipmi_fd;
+ myfd.events = POLLIN;
+ myfd.revents = 0;
+ rv = poll(&myfd,1,-1);
+ if (rv <= 0) {
+ if (fdebugmv) dbgmsg("getevent_mv poll rv=%d\n",rv);
+ return(rv);
+ }
+ /* else have input ready to read (myfd.revents & POLLIN)*/
+ if (fdebugmv) dbgmsg("getevent_mv poll revents %x\n",myfd.revents);
+#endif
+ }
+
+ /* read the message from the ipmi_fd */
+ rsp.msg.data = data;
+ rsp.msg.data_len = sizeof(data);
+ rsp.addr = (unsigned char *) &addr;
+ rsp.addr_len = sizeof(addr);
+ rv = ioctl(ipmi_fd, IPMICTL_RECEIVE_MSG_TRUNC, &rsp);
+ if (rv < 0) {
+ if (fdebugmv) dbgmsg("getevent_mv rv=%d, errno=%d\n",rv,errno);
+ if (errno == EMSGSIZE) { /* The message was truncated */
+ *cc = 0xC8; /*IPMI_REQUESTED_DATA_LENGTH_EXCEEDED_CC;*/
+ rsp.msg.data_len = sizeof(data);
+ rv = 0;
+ }
+ else if (errno == EINTR) { return(EINTR); }
+ } else *cc = 0;
+ if (rv == 0) {
+ n = rsp.msg.data_len;
+ if (fdebugmv) {
+ dbgmsg("getevent_mv: recv_type=%x cmd=%x data_len=%d\n",
+ rsp.recv_type,rsp.msg.cmd,n);
+ // if (n > 0) dump_buf("mv rsp.msg.data",rsp.msg.data, n, 0);
+ // dump_buf("mv rsp.addr",rsp.addr,rsp.addr_len,0);
+ }
+ if (rsp.recv_type == IPMI_CMD_RECV_TYPE) {
+ evt_data[0] = rsp.recv_type;
+ evt_data[1] = rsp.msg.netfn;
+ evt_data[2] = rsp.msg.cmd;
+ if (n > 0)
+ memcpy(&evt_data[3],&data[0],n);
+ n += 3;
+ /* save the response address */
+ memcpy(&rsp_addr,rsp.addr,rsp.addr_len);
+ rsp_addrlen = rsp.addr_len;
+ } else if (rsp.recv_type == IPMI_RESPONSE_RESPONSE_TYPE) {
+ evt_data[0] = rsp.recv_type;
+ evt_data[1] = rsp.msg.netfn;
+ evt_data[2] = rsp.msg.cmd;
+ evt_data[3] = data[0];
+ n += 3;
+ } else { /* rsp.recv_type == IPMI_ASYNC_EVENT_RECV_TYPE */
+ if (n > 0)
+ memcpy(evt_data,&data[0],n);
+ }
+ *evt_len = n;
+ } else if (rv == -1 || rv == -11) {
+ rv = 0x80; /* -EAGAIN, no data, try again */
+ }
+ return(rv);
+}
+
+#ifdef TEST_BIN
+int main(int argc, char *argv[])
+{
+ fd_set readfds;
+ struct timeval tv;
+ uchar data[40];
+ int i, j;
+ int err, rv;
+ int rlen = 0;
+ uchar cc;
+
+ fperr = stderr;
+ fpdbg = stdout;
+ fdebugmv = 1;
+ rlen = sizeof(data);
+ err = ipmi_cmdraw_mv(0x01, 0x06, 0, 0x20, 0, /*get_device_id*/
+ NULL, 0, data, &rlen, &cc, fdebugmv);
+ dbgmsg("ipmi_cmdraw_mv ret=%d, cc=%02x\n",err,cc);
+ rv = err;
+ if (err == 0) {
+ rv = cc;
+ dbgmsg(" ** Return Code: %2.2X\n", cc);
+ dbgmsg(" ** Data[%d]:",rlen);
+ for (i=0; i < rlen; i++)
+ dbgmsg(" %2.2X", (uchar)data[i]);
+ dbgmsg("\n");
+ }
+
+ err = setmaint_mv(2,&cc);
+ dbgmsg("setmaint_mv(2) err=%d cc=%d\n",err,cc);
+ err = setmaint_mv(1,&cc);
+ dbgmsg("setmaint_mv(1) err=%d cc=%d\n",err,cc);
+ err = setmaint_mv(0,&cc);
+ dbgmsg("setmaint_mv(0) err=%d cc=%d\n",err,cc);
+
+ err = register_async_mv(0x10,0x06);
+ dbgmsg("register_async_mv(10,6) rv=%d\n",err);
+ err = register_async_mv(0x01,0x06);
+ dbgmsg("register_async_mv(01,6) rv=%d\n",err);
+ err = unregister_async_mv(0x01,0x06);
+ dbgmsg("unregister_async_mv(01,6) rv=%d\n",err);
+ err = unregister_async_mv(0x10,0x06);
+ dbgmsg("unregister_async_mv(10,6) rv=%d\n",err);
+
+ dbgmsg("\n");
+ ipmi_close_mv();
+ return rv;
+}
+#endif
+
+#endif
diff --git a/util/ipmiutil.c b/util/ipmiutil.c
new file mode 100644
index 0000000..4094cab
--- /dev/null
+++ b/util/ipmiutil.c
@@ -0,0 +1,229 @@
+/***********************************************
+ * ipmiutil.c
+ *
+ * This is a meta-command utility to invoke each of the
+ * other sub-commands in a consolidated interface.
+ * To build this, compile with -DMETACOMMAND.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2006-2007 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 01/03/07 ARCress - created
+ * 01/05/07 ARCress - version 1.0
+ * 01/10/07 ARCress - version 1.1
+ * 02/07/07 ARCress - version 1.3 adding isolconsole
+ * 02/26/07 ARCress - updated sub-command names
+ * 08/31/07 ARCress - added "leds" subcommand
+ *
+ ***********************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2007, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "ipmicmd.h"
+#include "ipmiutil.h"
+
+static char *progname = "ipmiutil";
+static char *progver = "2.93";
+// static char fdebug = 0;
+/*int ipmiutil(int argc, char **argv); */
+
+#define NSUBCMDS 28
+static struct {
+ int idx;
+ char tag[16];
+ int (*rtn)(int argc, char **argv);
+ char desc[64];
+ } subcmds[NSUBCMDS] = {
+ { 0, "alarms", i_alarms, "show/set the front panel alarm LEDs and relays" },
+ { 1, "leds", i_alarms, "show/set the front panel alarm LEDs and relays" },
+ { 2, "discover", i_discover, "discover all IPMI servers on this LAN" },
+ { 3, "cmd", i_cmd , "send a specified raw IPMI command to the BMC" },
+ { 4, "config", i_config, "list/save/restore BMC configuration parameters" },
+ { 26, "dcmi", i_dcmi, "get/set DCMI parameters" },
+ { 5, "ekanalyzer", i_ekanalyzer, "run EKeying analyzer on FRU files (deprecated, see fru)" },
+ { 6, "events", i_events, "decode IPMI events and display them" },
+ { 7, "firewall", i_firewall, "show/set firmware firewall functions" },
+ { 8, "fru", i_fru, "show decoded FRU inventory data, write asset tag"},
+ { 9, "fwum", i_fwum, "OEM firmware update manager extensions" },
+ { 10, "getevt", i_getevt, "get IPMI events and display them, event daemon" },
+ { 11, "getevent", i_getevt, "get IPMI events and display them, event daemon" },
+ { 12, "health", i_health, "check and show the basic health of the IPMI BMC"},
+ { 13, "hpm", i_hpm, "HPM firmware update manager extensions" },
+ { 14, "lan", i_lan, "show/set IPMI LAN parameters and PEF table"},
+ { 15, "picmg", i_picmg, "show/set picmg extended functions" },
+ { 25, "power", i_reset, "issue IPMI reset or power control to the system"},
+ { 16, "reset", i_reset, "issue IPMI reset or power control to the system"},
+ { 17, "sel", i_sel, "show/clear firmware System Event Log records" },
+ { 18, "sensor", i_sensor, "show Sensor Data Records, readings, thresholds" },
+ { 19, "serial", i_serial, "show/set IPMI Serial & Terminal Mode parameters"},
+ { 20, "sol", i_sol, "start/stop an SOL console session" },
+ { 21, "smcoem", i_smcoem, "SuperMicro OEM functions" },
+ { 22, "sunoem", i_sunoem, "Sun OEM functions" },
+ { 23, "delloem",i_delloem, "Dell OEM functions" },
+ { 24, "tsol", i_tsol, "Tyan SOL console start/stop session" },
+ { 27, "wdt", i_wdt, "show/set/reset the watchdog timer" }
+ };
+
+static char usagemsg[] = "Usage: ipmiutil <command> [other options]\n"
+ " where <command> is one of the following:\n";
+static char helpmsg[] = "For help on each command (e.g. 'sel'), enter:\n"
+ " ipmiutil sel -?\n";
+
+static void show_usage()
+{
+ int i;
+ printf("%s", usagemsg);
+ for (i=0; i<NSUBCMDS; i++)
+ printf("\t%s\t%s\n",subcmds[i].tag,subcmds[i].desc);
+ printf(" common IPMI LAN options:\n");
+ print_lan_opt_usage();
+ printf("%s", helpmsg);
+}
+
+#ifdef DOS
+int i_discover(int argc, char **argv)
+{
+ printf("The discover function is not supported in DOS.\n");
+ return(1);
+}
+#endif
+
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+{
+ int ret = 1;
+ int i;
+ char *psubcmd = "";
+
+ printf("%s ver %s\n", progname,progver);
+ if (argc < 2) {
+ show_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+#ifdef TEST_LOOP
+ /* special subcommand processing loop for testing */
+#ifdef WIN32
+ while ( !(( _kbhit() ) && (_getch() == 'q')) )
+#else
+ while ( 1 )
+#endif
+ {
+ for (i = 0; i < NSUBCMDS; i++)
+ {
+ if (strcmp(argv[1],subcmds[i].tag) == 0) {
+ psubcmd = argv[1];
+ argc--;
+ argv++;
+ ret = subcmds[i].rtn(argc,argv);
+
+ argc++; argv--; /*requeue the same subcmd*/
+ os_usleep( 1, 0 ); /*sleep 1 sec*/
+ break;
+ }
+ }
+ }
+#else
+ for (i = 0; i < NSUBCMDS; i++)
+ {
+ if (strcmp(argv[1],subcmds[i].tag) == 0) {
+ psubcmd = argv[1];
+ argc--;
+ argv++;
+ ret = subcmds[i].rtn(argc,argv);
+ break;
+ }
+ }
+#endif
+ if (i >= NSUBCMDS) {
+#ifdef LINUX
+ if ((strcmp(argv[1],"svc") == 0) && (argc >= 3)) {
+ char mycmd[80];
+ char *pfunc;
+ char *psvc;
+ char fchkok;
+ /* undocumented: start a given service, only works locally */
+ psvc = "ipmi_port";
+ if (argc > 2) pfunc = argv[2];
+ else pfunc = "on";
+ ret = system("ls /sbin/chkconfig >/dev/null 2>&1");
+ if (ret == 0) fchkok = 1;
+ else fchkok = 0;
+ if (strcmp(pfunc,"off") == 0) {
+ sprintf(mycmd,"service %s stop\n",psvc);
+ printf("%s\n",mycmd);
+ ret = system(mycmd);
+ if (fchkok) {
+ sprintf(mycmd,"/sbin/chkconfig --del %s\n",psvc);
+ printf("%s\n",mycmd);
+ ret = system(mycmd);
+ }
+ } else {
+ if (fchkok) {
+ sprintf(mycmd,"/sbin/chkconfig --add %s\n",psvc);
+ printf("%s\n",mycmd);
+ ret = system(mycmd);
+ sprintf(mycmd,"/sbin/chkconfig --level 345 %s on\n",psvc);
+ // printf("%s\n",mycmd);
+ ret = system(mycmd);
+ }
+ sprintf(mycmd,"service %s start\n",psvc);
+ printf("%s\n",mycmd);
+ ret = system(mycmd);
+ }
+ } else
+#endif
+ {
+ show_usage();
+ ret = ERR_USAGE;
+ }
+ }
+
+do_exit:
+ {
+ char tag[30];
+ sprintf(tag,"%s %s",progname,psubcmd);
+ show_outcome(tag,ret);
+ }
+ return(ret);
+}
+
+/*end ipmiutil.c*/
diff --git a/util/ipmiutil.h b/util/ipmiutil.h
new file mode 100644
index 0000000..39b5ecb
--- /dev/null
+++ b/util/ipmiutil.h
@@ -0,0 +1,66 @@
+/***********************************************
+ * ipmiutil.h
+ *
+ * Definitions for ipmiutil.c
+ *
+ ***********************************************/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2006, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+#ifndef IPMIUTIL_H_
+#define IPMIUTIL_H_
+
+int i_alarms(int argc, char **argv);
+int i_health(int argc, char **argv);
+int i_fru(int argc, char **argv);
+int i_getevt(int argc, char **argv);
+int i_reset(int argc, char **argv);
+int i_cmd(int argc, char **argv);
+int i_lan(int argc, char **argv);
+int i_serial(int argc, char **argv);
+int i_sensor(int argc, char **argv);
+int i_sel(int argc, char **argv);
+int i_wdt(int argc, char **argv);
+int i_sol(int argc, char **argv);
+int i_discover(int argc, char **argv);
+int i_config(int argc, char **argv);
+int i_events(int argc, char **argv);
+int i_picmg(int argc, char **argv);
+int i_firewall(int argc, char **argv);
+int i_fwum(int argc, char **argv);
+int i_hpm(int argc, char **argv);
+int i_sunoem(int argc, char **argv);
+int i_delloem(int argc, char **argv);
+int i_ekanalyzer(int argc, char **argv);
+int i_tsol(int argc, char **argv);
+int i_dcmi(int argc, char **argv);
+int i_smcoem(int argc, char **argv);
+
+#endif // IPMIUTIL_H_
diff --git a/util/ipmiutil.mak b/util/ipmiutil.mak
new file mode 100644
index 0000000..83a23c1
--- /dev/null
+++ b/util/ipmiutil.mak
@@ -0,0 +1,424 @@
+# This makefile will build the ipmiutil util directory
+#
+# First download getopt.c getopt.h
+# Then download and build openssl for Windows
+#
+LIBC_RT=libcmt.lib /NODEFAULTLIB:"msvcirt.lib"
+# LIBC_RT=msvcrt.lib /NODEFAULTLIB:"msvcirt.lib"
+
+#MARCH=X64
+MARCH=IX86
+# The ipmiutil directory
+SRC_D=.
+LIB_D=..\lib
+L2_D=$(LIB_D)\lanplus
+L3_D=$(LIB_D)\lanplus\inc
+INSTALLTOP=install
+TMP_D=tmp
+INC=/I$(SRC_D) /I$(L2_D) /I$(L3_D)
+CMD_OBJ = getopt.obj ipmicmd.obj imbapi.obj md5.obj md2.obj \
+ ipmilan.obj ipmims.obj subs.obj
+CMD_OBJ = $(CMD_OBJ) ipmilanplus.obj
+# To remove lanplus support use the empty LANPLUS variables
+# L2_OBJ=
+# LF_LANPLUS=
+# CF_LANPLUS=
+L2_OBJ = $(L2_D)\helper.obj $(L2_D)\ipmi_strings.obj $(L2_D)\lanplus.obj \
+ $(L2_D)\lanplus_crypt_impl.obj $(L2_D)\lanplus_dump.obj \
+ $(L2_D)\lanplus_strings.obj $(L2_D)\lanplus_crypt.obj
+LF_LANPLUS=/LIBPATH:$(LIB_D) $(L2_OBJ) ssleay32.lib libeay32.lib
+CF_LANPLUS=/D HAVE_LANPLUS
+
+# Set your compiler options
+# To remove any GPL dependencies, use the CF_EX line with NON_GPL
+# CFLAGS_O=/W3 /O2 /Zi /MD /GF /Gy /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MD /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CF_EX=/DWIN32 $(CF_LANPLUS) $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DHAVE_STRING_H
+CF_SAM=/DWIN32 $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /DHAVE_STRING_H
+CFLAGS=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2
+CFLAGS_M=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2 /DMETACOMMAND
+CFLAGS_SAM=$(CFLAGS_O) $(CF_SAM)
+LFLAGS=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref /debug
+# LFLAGS_D=/nologo /subsystem:console /machine:I386 /opt:ref /dll
+
+# CFLAGS_W=/O2 /D_CONSOLE /D_MBCS /EHsc /ML /W3 /Zi /TP
+CFLAGS_W=/TP /EHsc $(CFLAGS)
+LFLAGS_W=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+LIBS_W=comsuppw.lib wbemuuid.lib
+# gdi32.lib comdlg32.lib shell32.lib uuid.lib
+
+CC=cl
+LINK=link
+MKDIR=-mkdir
+MKLIB=lib
+RM=del
+CP=copy
+
+LIBS_EX = advapi32.lib kernel32.lib wsock32.lib $(LIBS_W) $(LIBC_RT)
+LIBS_PEF = /LIBPATH:$(LIB_D) iphlpapi.lib
+# LIBS_EX+=wsock32.lib user32.lib gdi32.lib
+
+HEADER=ipmicmd.h imb_api.h ipmilan.h ipmidir.h ipmilanplus.h \
+ ipmiutil.h
+
+SHOWSEL = showsel
+TARG_EXE=ievents.exe $(SHOWSEL)msg.dll ipmi_sample.exe ipmi_sample_evt.exe $(SAMP_DLL)
+# alarms.exe ihealth.exe $(SHOWSEL).exe $(SHOWSEL)msg.dll \
+# ireset.exe ifru.exe ilan.exe iserial.exe wdt.exe \
+# getevent.exe sensor.exe icmd.exe isolconsole.exe idiscover.exe \
+# ievents.exe
+SAMP_LIB = ipmiutil.lib
+SAMP_DLL = ipmiutillib.dll
+
+E_EXE=ipmiutil.exe
+E_OBJ=$(TMP_D)\ipmiutil.obj \
+ $(TMP_D)\ialarms.obj $(TMP_D)\ihealth.obj $(TMP_D)\iwdt.obj \
+ $(TMP_D)\ireset.obj $(TMP_D)\ifru.obj $(TMP_D)\ilan.obj \
+ $(TMP_D)\iserial.obj $(TMP_D)\icmd.obj $(TMP_D)\isol.obj \
+ $(TMP_D)\isolwin.obj $(TMP_D)\AnsiTerm.obj $(TMP_D)\idiscover.obj \
+ $(TMP_D)\iconfig.obj $(TMP_D)\igetevent.obj $(TMP_D)\isensor.obj \
+ $(TMP_D)\isel.obj $(TMP_D)\ievents.obj \
+ $(TMP_D)\ipicmg.obj $(TMP_D)\ifirewall.obj \
+ $(TMP_D)\iekanalyzer.obj $(TMP_D)\ifru_picmg.obj \
+ $(TMP_D)\oem_kontron.obj $(TMP_D)\ihpm.obj $(TMP_D)\ifwum.obj \
+ $(TMP_D)\oem_fujitsu.obj $(TMP_D)\oem_intel.obj \
+ $(TMP_D)\oem_sun.obj $(TMP_D)\oem_dell.obj $(TMP_D)\oem_hp.obj \
+ $(TMP_D)\oem_supermicro.obj $(TMP_D)\itsol.obj $(TMP_D)\idcmi.obj \
+ $(TMP_D)\oem_quanta.obj $(TMP_D)\oem_newisys.obj $(CMD_OBJ) mem_if.obj
+
+###################################################################
+all: banner $(TMP_D) exe
+
+banner:
+ @echo Building ipmiutil
+
+$(TMP_D):
+ $(MKDIR) $(TMP_D)
+ @echo created $(TMP_D)
+
+lib: $(L2_OBJ)
+ cd $(LIB_D)
+ nmake /nologo -f ipmilib.mak
+ cd ../util
+
+exe: $(E_EXE) $(TARG_EXE)
+
+install:
+ $(MKDIR) $(INSTALLTOP)
+ $(MKDIR) $(INSTALLTOP)\bin
+ $(CP) $(E_EXE) $(INSTALLTOP)\bin
+ xcopy $(TARG_EXE) $(INSTALLTOP)\bin
+ xcopy *.dll $(INSTALLTOP)\bin
+
+clean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ -$(RM) $(TMP_D)\*.obj 2>NUL
+
+distclean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ -$(RM) $(TMP_D)\*.* 2>NUL
+ rmdir $(TMP_D) 2>NUL
+ $(RM) *.rc 2>NUL
+ $(RM) *.bin 2>NUL
+ $(RM) *.RES 2>NUL
+ $(RM) getopt.* 2>NUL
+
+getopt.obj: getopt.c
+ $(CC) /c $(CFLAGS) getopt.c
+
+imbapi.obj: imbapi.c
+ $(CC) /c $(CFLAGS_M) imbapi.c
+
+ipmicmd.obj: ipmicmd.c
+ $(CC) /c $(CFLAGS) ipmicmd.c
+
+ipmilan.obj: ipmilan.c
+ $(CC) /c $(CFLAGS) ipmilan.c
+
+ipmilanplus.obj: ipmilanplus.c
+ $(CC) /c $(CFLAGS_M) ipmilanplus.c
+
+md5.obj: md5.c
+ $(CC) /c $(CFLAGS) md5.c
+
+md2.obj: md2.c
+ $(CC) /c $(CFLAGS) md2.c
+
+ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS) ievents.c
+
+ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS) ialarms.c
+
+ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS) ihealth.c
+
+igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS) igetevent.c
+
+mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) mem_if.c
+
+ipmims.obj: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) ipmims.cpp
+
+isel.obj: isel.c
+ $(CC) /c $(CFLAGS) isel.c
+
+ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS) ireset.c
+
+ireset.exe: ireset.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ireset.exe ireset.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS) ifru.c
+
+ifru.exe: ifru.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ifru.exe ifru.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS) ilan.c
+
+ilan.exe: ilan.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ilan.exe ilan.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS) iserial.c
+
+iserial.exe: iserial.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iserial.exe iserial.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS) isensor.c
+
+isensor.exe: isensor.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isensor.exe isensor.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS) iwdt.c
+
+iwdt.exe: iwdt.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iwdt.exe iwdt.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isol.obj: isol.c
+ $(CC) /c $(CFLAGS) isol.c
+
+isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS) isolwin.c
+
+isol.exe: isol.obj isolwin.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isol.exe isol.obj isolwin.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS) icmd.c
+
+icmd.exe: icmd.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:icmd.exe icmd.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS) idiscover.c
+
+idiscover.exe: idiscover.obj getopt.obj
+ $(LINK) $(LFLAGS) /OUT:idiscover.exe idiscover.obj getopt.obj \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ialarms.exe: ialarms.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ialarms.exe ialarms.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ihealth.exe: ihealth.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ihealth.exe ihealth.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+igetevent.exe: igetevent.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:igetevent.exe igetevent.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+isel.exe: isel.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isel.exe isel.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+$(SHOWSEL).mc:
+ $(CP) ..\scripts\$(SHOWSEL).mc .
+
+$(SHOWSEL)msg.dll: $(SHOWSEL).mc
+ mc -U $(SHOWSEL).mc
+ rc -r $(SHOWSEL).rc
+ $(LINK) /machine:$(MARCH) -dll -noentry -out:$(SHOWSEL)msg.dll $(SHOWSEL).res
+
+mem_if.exe: $(TMP_D)\mem_if.obj
+ $(LINK) $(LFLAGS_W) /OUT:mem_if.exe $(TMP_D)\mem_if.obj $(LIBS_EX)
+
+$(TMP_D)\mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) /DCOMP_BIN /Fo$(TMP_D)\mem_if.obj mem_if.c
+
+ievents.exe: ievents.c
+ $(CC) /c $(CFLAGS) /DALONE ievents.c
+ $(LINK) $(LFLAGS) /OUT:ievents.exe ievents.obj $(LIBS_EX)
+ $(RM) ievents.obj
+
+ipmims.exe: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) /DALONE /DTEST_BIN ipmims.cpp
+ $(LINK) $(LFLAGS_W) /OUT:ipmims.exe ipmims.obj $(LIBS_EX)
+ $(RM) ipmims.obj
+
+$(TMP_D)\ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ievents.obj ievents.c
+
+$(TMP_D)\ipmiutil.obj: ipmiutil.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipmiutil.obj ipmiutil.c
+
+$(TMP_D)\ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ialarms.obj ialarms.c
+
+$(TMP_D)\ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihealth.obj ihealth.c
+
+$(TMP_D)\iconfig.obj: iconfig.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iconfig.obj iconfig.c
+
+$(TMP_D)\ipicmg.obj: ipicmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipicmg.obj ipicmg.c
+
+$(TMP_D)\ifirewall.obj: ifirewall.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifirewall.obj ifirewall.c
+
+$(TMP_D)\ifwum.obj: ifwum.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifwum.obj ifwum.c
+
+$(TMP_D)\ihpm.obj: ihpm.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihpm.obj ihpm.c
+
+$(TMP_D)\idcmi.obj: idcmi.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idcmi.obj idcmi.c
+
+$(TMP_D)\oem_fujitsu.obj: oem_fujitsu.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_fujitsu.obj oem_fujitsu.c
+
+$(TMP_D)\oem_kontron.obj: oem_kontron.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_kontron.obj oem_kontron.c
+
+$(TMP_D)\oem_intel.obj: oem_intel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_intel.obj oem_intel.c
+
+$(TMP_D)\oem_sun.obj: oem_sun.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_sun.obj oem_sun.c
+
+$(TMP_D)\oem_dell.obj: oem_dell.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_dell.obj oem_dell.c
+
+$(TMP_D)\oem_hp.obj: oem_hp.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_hp.obj oem_hp.c
+
+$(TMP_D)\oem_supermicro.obj: oem_supermicro.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_supermicro.obj oem_supermicro.c
+
+$(TMP_D)\oem_quanta.obj: oem_quanta.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_quanta.obj oem_quanta.c
+
+$(TMP_D)\oem_newisys.obj: oem_newisys.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_newisys.obj oem_newisys.c
+
+$(TMP_D)\iekanalyzer.obj: iekanalyzer.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iekanalyzer.obj iekanalyzer.c
+
+$(TMP_D)\ifru_picmg.obj: ifru_picmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru_picmg.obj ifru_picmg.c
+
+$(TMP_D)\ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru.obj ifru.c
+
+$(TMP_D)\ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ireset.obj ireset.c
+
+$(TMP_D)\ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ilan.obj ilan.c
+
+$(TMP_D)\iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iserial.obj iserial.c
+
+$(TMP_D)\isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isensor.obj isensor.c
+
+$(TMP_D)\icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\icmd.obj icmd.c
+
+$(TMP_D)\igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\igetevent.obj igetevent.c
+
+$(TMP_D)\isel.obj: isel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isel.obj isel.c
+
+$(TMP_D)\isol.obj: isol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isol.obj isol.c
+
+$(TMP_D)\isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isolwin.obj isolwin.c
+
+$(TMP_D)\itsol.obj: itsol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\itsol.obj itsol.c
+
+$(TMP_D)\AnsiTerm.obj: AnsiTerm.cpp
+ $(CC) /c $(CFLAGS_W) /Fo$(TMP_D)\AnsiTerm.obj AnsiTerm.cpp
+
+$(TMP_D)\idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idiscover.obj idiscover.c
+
+$(TMP_D)\iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iwdt.obj iwdt.c
+
+$(E_EXE): $(E_OBJ)
+ $(LINK) $(LFLAGS) /OUT:$(E_EXE) $(E_OBJ) $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample.obj: ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+
+$(SAMP_LIB): $(CMD_OBJ) mem_if.obj
+ $(CC) /c $(CFLAGS_SAM) ipmilanplus.c
+ $(MKLIB) /OUT:$(SAMP_LIB) /nologo $(CMD_OBJ) mem_if.obj
+ del ipmilanplus.obj
+
+$(SAMP_DLL): $(CMD_OBJ) mem_if.obj
+ $(CC) /D_WINDLL /D_USRDLL /c $(CFLAGS_SAM) ipmilanplus.c
+ $(LINK) /DLL $(LFLAGS) /OUT:$(SAMP_DLL) /def:ipmiutillib.def $(CMD_OBJ) mem_if.obj $(LIBS_PEF) $(LIBS_EX)
+ del ipmilanplus.obj
+
+ipmi_sample.exe: $(SAMP_LIB) ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample.exe ipmi_sample.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample2.exe: $(SAMP_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) /c $(CFLAGS_SAM) /DGET_SENSORS ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) isensor.c
+ $(CC) /c $(CFLAGS_SAM) ievents.c
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample2.exe ipmi_sample.obj isensor.obj ievents.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+ del isensor.obj ievents.obj
+
+ipmi_sample_evt.obj: ipmi_sample_evt.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample_evt.c
+
+isensor2.obj: isensor.c isensor.h $(HEADER)
+ $(CC) /c /Foisensor2.obj $(CFLAGS_SAM) isensor.c
+
+ievents2.obj: ievents.c ievents.h $(HEADER)
+ $(CC) /c /Foievents2.obj $(CFLAGS_SAM) /DSENSORS_OK ievents.c
+
+ipmi_sample_evt.exe: $(SAMP_LIB) ipmi_sample_evt.obj ievents2.obj isensor2.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample_evt.exe ipmi_sample_evt.obj ievents2.obj isensor2.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
diff --git a/util/ipmiutil2-64.mak b/util/ipmiutil2-64.mak
new file mode 100644
index 0000000..6289e06
--- /dev/null
+++ b/util/ipmiutil2-64.mak
@@ -0,0 +1,425 @@
+# This makefile will build the ipmiutil util directory (x64 without lanplus)
+#
+# First download getopt.c getopt.h
+# Then download and build openssl for Windows
+#
+LIBC_RT=libcmt.lib /NODEFAULTLIB:"msvcirt.lib"
+# LIBC_RT=msvcrt.lib /NODEFAULTLIB:"msvcirt.lib"
+
+MARCH=X64
+#MARCH=IX86
+# The ipmiutil directory
+SRC_D=.
+LIB_D=..\lib
+L2_D=$(LIB_D)\lanplus
+L3_D=$(LIB_D)\lanplus\inc
+INSTALLTOP=install
+TMP_D=tmp
+INC=/I$(SRC_D) /I$(L2_D) /I$(L3_D)
+CMD_OBJ = getopt.obj ipmicmd.obj imbapi.obj md5.obj md2.obj \
+ ipmilan.obj ipmims.obj subs.obj
+CMD_OBJ = $(CMD_OBJ) ipmilanplus.obj
+# To remove lanplus support use the empty LANPLUS variables
+L2_OBJ=
+L2_LIB=
+LF_LANPLUS=
+CF_LANPLUS=
+#L2_OBJ = $(L2_D)\helper.obj $(L2_D)\ipmi_strings.obj $(L2_D)\lanplus.obj \
+# $(L2_D)\lanplus_crypt_impl.obj $(L2_D)\lanplus_dump.obj \
+# $(L2_D)\lanplus_strings.obj $(L2_D)\lanplus_crypt.obj
+#L2_LIB=lanplus.lib
+#LF_LANPLUS=/LIBPATH:$(LIB_D) $(L2_OBJ) ssleay32.lib libeay32.lib
+#CF_LANPLUS=/D HAVE_LANPLUS
+
+# Set your compiler options
+# To remove any GPL dependencies, use the CF_EX line with NON_GPL
+# CFLAGS_O=/W3 /O2 /Zi /MD /GF /Gy /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MD /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CF_EX=/DWIN32 $(CF_LANPLUS) $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DHAVE_STRING_H
+CF_SAM=/DWIN32 $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /DHAVE_STRING_H
+CFLAGS=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2
+CFLAGS_M=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2 /DMETACOMMAND
+CFLAGS_SAM=$(CFLAGS_O) $(CF_SAM)
+LFLAGS=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref /debug
+# LFLAGS_D=/nologo /subsystem:console /machine:I386 /opt:ref /dll
+
+# CFLAGS_W=/O2 /D_CONSOLE /D_MBCS /EHsc /ML /W3 /Zi /TP
+CFLAGS_W=/TP /EHsc $(CFLAGS)
+LFLAGS_W=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+LIBS_W=comsuppw.lib wbemuuid.lib
+# gdi32.lib comdlg32.lib shell32.lib uuid.lib
+
+CC=cl
+LINK=link
+MKDIR=-mkdir
+MKLIB=lib
+RM=del
+CP=copy
+
+LIBS_EX = advapi32.lib kernel32.lib wsock32.lib ws2_32.lib $(LIBS_W) $(LIBC_RT)
+LIBS_PEF = /LIBPATH:$(LIB_D) iphlpapi.lib
+# LIBS_EX+=wsock32.lib user32.lib gdi32.lib
+
+HEADER=ipmicmd.h imb_api.h ipmilan.h ipmidir.h ipmilanplus.h \
+ ipmiutil.h
+
+SHOWSEL = showsel
+TARG_EXE=ievents.exe $(SHOWSEL)msg.dll ipmi_sample.exe ipmi_sample_evt.exe $(SAMP_DLL)
+# alarms.exe ihealth.exe $(SHOWSEL).exe $(SHOWSEL)msg.dll \
+# ireset.exe ifru.exe ilan.exe iserial.exe wdt.exe \
+# getevent.exe sensor.exe icmd.exe isolconsole.exe idiscover.exe \
+# ievents.exe
+SAMP_LIB = ipmiutil.lib
+SAMP_DLL = ipmiutillib.dll
+
+E_EXE=ipmiutil.exe
+E_OBJ=$(TMP_D)\ipmiutil.obj \
+ $(TMP_D)\ialarms.obj $(TMP_D)\ihealth.obj $(TMP_D)\iwdt.obj \
+ $(TMP_D)\ireset.obj $(TMP_D)\ifru.obj $(TMP_D)\ilan.obj \
+ $(TMP_D)\iserial.obj $(TMP_D)\icmd.obj $(TMP_D)\isol.obj \
+ $(TMP_D)\isolwin.obj $(TMP_D)\AnsiTerm.obj $(TMP_D)\idiscover.obj \
+ $(TMP_D)\iconfig.obj $(TMP_D)\igetevent.obj $(TMP_D)\isensor.obj \
+ $(TMP_D)\isel.obj $(TMP_D)\ievents.obj \
+ $(TMP_D)\ipicmg.obj $(TMP_D)\ifirewall.obj \
+ $(TMP_D)\iekanalyzer.obj $(TMP_D)\ifru_picmg.obj \
+ $(TMP_D)\oem_kontron.obj $(TMP_D)\ihpm.obj $(TMP_D)\ifwum.obj \
+ $(TMP_D)\oem_fujitsu.obj $(TMP_D)\oem_intel.obj \
+ $(TMP_D)\oem_sun.obj $(TMP_D)\oem_dell.obj $(TMP_D)\oem_hp.obj \
+ $(TMP_D)\oem_supermicro.obj $(TMP_D)\itsol.obj $(TMP_D)\idcmi.obj \
+ $(TMP_D)\oem_quanta.obj $(TMP_D)\oem_newisys.obj $(CMD_OBJ) mem_if.obj
+
+###################################################################
+all: banner $(TMP_D) exe
+
+banner:
+ @echo Building ipmiutil
+
+$(TMP_D):
+ $(MKDIR) $(TMP_D)
+ @echo created $(TMP_D)
+
+lib: $(L2_OBJ)
+ cd $(LIB_D)
+ nmake /nologo -f ipmilib.mak
+ cd ../util
+
+exe: $(E_EXE) $(TARG_EXE)
+
+install:
+ $(MKDIR) $(INSTALLTOP)
+ $(MKDIR) $(INSTALLTOP)\bin
+ $(CP) $(E_EXE) $(INSTALLTOP)\bin
+ xcopy $(TARG_EXE) $(INSTALLTOP)\bin
+ xcopy *.dll $(INSTALLTOP)\bin
+
+clean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ $(RM) $(TMP_D)\*.obj 2>NUL
+
+distclean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ $(RM) $(TMP_D)\*.* 2>NUL
+ rmdir $(TMP_D) 2>NUL
+ $(RM) *.rc 2>NUL
+ $(RM) *.bin 2>NUL
+ $(RM) *.RES 2>NUL
+ $(RM) getopt.* 2>NUL
+
+getopt.obj: getopt.c
+ $(CC) /c $(CFLAGS) getopt.c
+
+imbapi.obj: imbapi.c
+ $(CC) /c $(CFLAGS_M) imbapi.c
+
+ipmicmd.obj: ipmicmd.c
+ $(CC) /c $(CFLAGS) ipmicmd.c
+
+ipmilan.obj: ipmilan.c
+ $(CC) /c $(CFLAGS) ipmilan.c
+
+ipmilanplus.obj: ipmilanplus.c
+ $(CC) /c $(CFLAGS_M) ipmilanplus.c
+
+md5.obj: md5.c
+ $(CC) /c $(CFLAGS) md5.c
+
+md2.obj: md2.c
+ $(CC) /c $(CFLAGS) md2.c
+
+ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS) ievents.c
+
+ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS) ialarms.c
+
+ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS) ihealth.c
+
+igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS) igetevent.c
+
+mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) mem_if.c
+
+ipmims.obj: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) ipmims.cpp
+
+isel.obj: isel.c
+ $(CC) /c $(CFLAGS) isel.c
+
+ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS) ireset.c
+
+ireset.exe: ireset.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ireset.exe ireset.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS) ifru.c
+
+ifru.exe: ifru.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ifru.exe ifru.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS) ilan.c
+
+ilan.exe: ilan.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ilan.exe ilan.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS) iserial.c
+
+iserial.exe: iserial.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iserial.exe iserial.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS) isensor.c
+
+isensor.exe: isensor.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isensor.exe isensor.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS) iwdt.c
+
+iwdt.exe: iwdt.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iwdt.exe iwdt.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isol.obj: isol.c
+ $(CC) /c $(CFLAGS) isol.c
+
+isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS) isolwin.c
+
+isol.exe: isol.obj isolwin.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isol.exe isol.obj isolwin.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS) icmd.c
+
+icmd.exe: icmd.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:icmd.exe icmd.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS) idiscover.c
+
+idiscover.exe: idiscover.obj getopt.obj
+ $(LINK) $(LFLAGS) /OUT:idiscover.exe idiscover.obj getopt.obj \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ialarms.exe: ialarms.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ialarms.exe ialarms.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ihealth.exe: ihealth.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ihealth.exe ihealth.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+igetevent.exe: igetevent.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:igetevent.exe igetevent.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+isel.exe: isel.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isel.exe isel.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+$(SHOWSEL).mc:
+ $(CP) ..\scripts\$(SHOWSEL).mc .
+
+$(SHOWSEL)msg.dll: $(SHOWSEL).mc
+ mc -U $(SHOWSEL).mc
+ rc -r $(SHOWSEL).rc
+ $(LINK) /machine:$(MARCH) -dll -noentry -out:$(SHOWSEL)msg.dll $(SHOWSEL).res
+
+mem_if.exe: $(TMP_D)\mem_if.obj
+ $(LINK) $(LFLAGS_W) /OUT:mem_if.exe $(TMP_D)\mem_if.obj $(LIBS_EX)
+
+$(TMP_D)\mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) /DCOMP_BIN /Fo$(TMP_D)\mem_if.obj mem_if.c
+
+ievents.exe: ievents.c
+ $(CC) /c $(CFLAGS) /DALONE ievents.c
+ $(LINK) $(LFLAGS) /OUT:ievents.exe ievents.obj $(LIBS_EX)
+ $(RM) ievents.obj
+
+ipmims.exe: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) /DALONE /DTEST_BIN ipmims.cpp
+ $(LINK) $(LFLAGS_W) /OUT:ipmims.exe ipmims.obj $(LIBS_EX)
+ $(RM) ipmims.obj
+
+$(TMP_D)\ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ievents.obj ievents.c
+
+$(TMP_D)\ipmiutil.obj: ipmiutil.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipmiutil.obj ipmiutil.c
+
+$(TMP_D)\ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ialarms.obj ialarms.c
+
+$(TMP_D)\ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihealth.obj ihealth.c
+
+$(TMP_D)\iconfig.obj: iconfig.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iconfig.obj iconfig.c
+
+$(TMP_D)\ipicmg.obj: ipicmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipicmg.obj ipicmg.c
+
+$(TMP_D)\ifirewall.obj: ifirewall.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifirewall.obj ifirewall.c
+
+$(TMP_D)\ifwum.obj: ifwum.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifwum.obj ifwum.c
+
+$(TMP_D)\ihpm.obj: ihpm.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihpm.obj ihpm.c
+
+$(TMP_D)\idcmi.obj: idcmi.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idcmi.obj idcmi.c
+
+$(TMP_D)\oem_fujitsu.obj: oem_fujitsu.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_fujitsu.obj oem_fujitsu.c
+
+$(TMP_D)\oem_kontron.obj: oem_kontron.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_kontron.obj oem_kontron.c
+
+$(TMP_D)\oem_intel.obj: oem_intel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_intel.obj oem_intel.c
+
+$(TMP_D)\oem_sun.obj: oem_sun.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_sun.obj oem_sun.c
+
+$(TMP_D)\oem_dell.obj: oem_dell.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_dell.obj oem_dell.c
+
+$(TMP_D)\oem_hp.obj: oem_hp.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_hp.obj oem_hp.c
+
+$(TMP_D)\oem_supermicro.obj: oem_supermicro.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_supermicro.obj oem_supermicro.c
+
+$(TMP_D)\oem_quanta.obj: oem_quanta.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_quanta.obj oem_quanta.c
+
+$(TMP_D)\oem_newisys.obj: oem_newisys.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_newisys.obj oem_newisys.c
+
+$(TMP_D)\iekanalyzer.obj: iekanalyzer.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iekanalyzer.obj iekanalyzer.c
+
+$(TMP_D)\ifru_picmg.obj: ifru_picmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru_picmg.obj ifru_picmg.c
+
+$(TMP_D)\ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru.obj ifru.c
+
+$(TMP_D)\ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ireset.obj ireset.c
+
+$(TMP_D)\ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ilan.obj ilan.c
+
+$(TMP_D)\iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iserial.obj iserial.c
+
+$(TMP_D)\isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isensor.obj isensor.c
+
+$(TMP_D)\icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\icmd.obj icmd.c
+
+$(TMP_D)\igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\igetevent.obj igetevent.c
+
+$(TMP_D)\isel.obj: isel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isel.obj isel.c
+
+$(TMP_D)\isol.obj: isol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isol.obj isol.c
+
+$(TMP_D)\isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isolwin.obj isolwin.c
+
+$(TMP_D)\itsol.obj: itsol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\itsol.obj itsol.c
+
+$(TMP_D)\AnsiTerm.obj: AnsiTerm.cpp
+ $(CC) /c $(CFLAGS_W) /Fo$(TMP_D)\AnsiTerm.obj AnsiTerm.cpp
+
+$(TMP_D)\idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idiscover.obj idiscover.c
+
+$(TMP_D)\iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iwdt.obj iwdt.c
+
+$(E_EXE): $(E_OBJ)
+ $(LINK) $(LFLAGS) /OUT:$(E_EXE) $(E_OBJ) $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample.obj: ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+
+$(SAMP_LIB): $(CMD_OBJ) mem_if.obj
+ $(CC) /c $(CFLAGS_SAM) ipmilanplus.c
+ $(MKLIB) /OUT:$(SAMP_LIB) /nologo $(CMD_OBJ) mem_if.obj
+ del ipmilanplus.obj
+
+$(SAMP_DLL): $(CMD_OBJ) mem_if.obj
+ $(CC) /D_WINDLL /D_USRDLL /c $(CFLAGS_SAM) ipmilanplus.c
+ $(LINK) /DLL $(LFLAGS) /OUT:$(SAMP_DLL) /def:ipmiutillib.def $(CMD_OBJ) mem_if.obj $(LIBS_PEF) $(LIBS_EX)
+ del ipmilanplus.obj
+
+ipmi_sample.exe: $(SAMP_LIB) ipmi_sample.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample.exe ipmi_sample.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample2.exe: $(SAMP_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) /c $(CFLAGS_SAM) /DGET_SENSORS ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) isensor.c
+ $(CC) /c $(CFLAGS_SAM) ievents.c
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample2.exe ipmi_sample.obj isensor.obj ievents.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+ del isensor.obj ievents.obj
+
+ipmi_sample_evt.obj: ipmi_sample_evt.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample_evt.c
+
+isensor2.obj: isensor.c isensor.h $(HEADER)
+ $(CC) /c /Foisensor2.obj $(CFLAGS_SAM) isensor.c
+
+ievents2.obj: ievents.c ievents.h $(HEADER)
+ $(CC) /c /Foievents2.obj $(CFLAGS_SAM) /DSENSORS_OK ievents.c
+
+ipmi_sample_evt.exe: $(SAMP_LIB) ipmi_sample_evt.obj ievents2.obj isensor2.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample_evt.exe ipmi_sample_evt.obj ievents2.obj isensor2.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
diff --git a/util/ipmiutil2.mak b/util/ipmiutil2.mak
new file mode 100644
index 0000000..8ed0155
--- /dev/null
+++ b/util/ipmiutil2.mak
@@ -0,0 +1,425 @@
+# This makefile will build the ipmiutil util directory (without lanplus)
+#
+# First download getopt.c getopt.h
+# Then download and build openssl for Windows
+#
+LIBC_RT=libcmt.lib /NODEFAULTLIB:"msvcirt.lib"
+# LIBC_RT=msvcrt.lib /NODEFAULTLIB:"msvcirt.lib"
+
+MARCH=IX86
+#MARCH=IX86
+# The ipmiutil directory
+SRC_D=.
+LIB_D=..\lib
+L2_D=$(LIB_D)\lanplus
+L3_D=$(LIB_D)\lanplus\inc
+INSTALLTOP=install
+TMP_D=tmp
+INC=/I$(SRC_D) /I$(L2_D) /I$(L3_D)
+CMD_OBJ = getopt.obj ipmicmd.obj imbapi.obj md5.obj md2.obj \
+ ipmilan.obj ipmims.obj subs.obj
+CMD_OBJ = $(CMD_OBJ) ipmilanplus.obj
+# To remove lanplus support use the empty LANPLUS variables
+L2_OBJ=
+L2_LIB=
+LF_LANPLUS=
+CF_LANPLUS=
+#L2_OBJ = $(L2_D)\helper.obj $(L2_D)\ipmi_strings.obj $(L2_D)\lanplus.obj \
+# $(L2_D)\lanplus_crypt_impl.obj $(L2_D)\lanplus_dump.obj \
+# $(L2_D)\lanplus_strings.obj $(L2_D)\lanplus_crypt.obj
+#L2_LIB=lanplus.lib
+#LF_LANPLUS=/LIBPATH:$(LIB_D) $(L2_OBJ) ssleay32.lib libeay32.lib
+#CF_LANPLUS=/D HAVE_LANPLUS
+
+# Set your compiler options
+# To remove any GPL dependencies, use the CF_EX line with NON_GPL
+# CFLAGS_O=/W3 /O2 /Zi /MD /GF /Gy /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MD /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CF_EX=/DWIN32 $(CF_LANPLUS) $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DHAVE_STRING_H
+CF_SAM=/DWIN32 $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /DHAVE_STRING_H
+CFLAGS=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2
+CFLAGS_M=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2 /DMETACOMMAND
+CFLAGS_SAM=$(CFLAGS_O) $(CF_SAM)
+LFLAGS=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref /debug
+# LFLAGS_D=/nologo /subsystem:console /machine:I386 /opt:ref /dll
+
+# CFLAGS_W=/O2 /D_CONSOLE /D_MBCS /EHsc /ML /W3 /Zi /TP
+CFLAGS_W=/TP /EHsc $(CFLAGS)
+LFLAGS_W=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+LIBS_W=comsuppw.lib wbemuuid.lib
+# gdi32.lib comdlg32.lib shell32.lib uuid.lib
+
+CC=cl
+LINK=link
+MKDIR=-mkdir
+MKLIB=lib
+RM=del
+CP=copy
+
+LIBS_EX = advapi32.lib kernel32.lib wsock32.lib ws2_32.lib $(LIBS_W) $(LIBC_RT)
+LIBS_PEF = /LIBPATH:$(LIB_D) iphlpapi.lib
+# LIBS_EX+=wsock32.lib user32.lib gdi32.lib
+
+HEADER=ipmicmd.h imb_api.h ipmilan.h ipmidir.h ipmilanplus.h \
+ ipmiutil.h
+
+SHOWSEL = showsel
+TARG_EXE=ievents.exe $(SHOWSEL)msg.dll ipmi_sample.exe ipmi_sample_evt.exe $(SAMP_DLL)
+# alarms.exe ihealth.exe $(SHOWSEL).exe $(SHOWSEL)msg.dll \
+# ireset.exe ifru.exe ilan.exe iserial.exe wdt.exe \
+# getevent.exe sensor.exe icmd.exe isolconsole.exe idiscover.exe \
+# ievents.exe
+SAMP_LIB = ipmiutil.lib
+SAMP_DLL = ipmiutillib.dll
+
+E_EXE=ipmiutil.exe
+E_OBJ=$(TMP_D)\ipmiutil.obj \
+ $(TMP_D)\ialarms.obj $(TMP_D)\ihealth.obj $(TMP_D)\iwdt.obj \
+ $(TMP_D)\ireset.obj $(TMP_D)\ifru.obj $(TMP_D)\ilan.obj \
+ $(TMP_D)\iserial.obj $(TMP_D)\icmd.obj $(TMP_D)\isol.obj \
+ $(TMP_D)\isolwin.obj $(TMP_D)\AnsiTerm.obj $(TMP_D)\idiscover.obj \
+ $(TMP_D)\iconfig.obj $(TMP_D)\igetevent.obj $(TMP_D)\isensor.obj \
+ $(TMP_D)\isel.obj $(TMP_D)\ievents.obj \
+ $(TMP_D)\ipicmg.obj $(TMP_D)\ifirewall.obj \
+ $(TMP_D)\iekanalyzer.obj $(TMP_D)\ifru_picmg.obj \
+ $(TMP_D)\oem_kontron.obj $(TMP_D)\ihpm.obj $(TMP_D)\ifwum.obj \
+ $(TMP_D)\oem_fujitsu.obj $(TMP_D)\oem_intel.obj \
+ $(TMP_D)\oem_sun.obj $(TMP_D)\oem_dell.obj $(TMP_D)\oem_hp.obj \
+ $(TMP_D)\oem_supermicro.obj $(TMP_D)\itsol.obj $(TMP_D)\idcmi.obj \
+ $(TMP_D)\oem_quanta.obj $(TMP_D)\oem_newisys.obj $(CMD_OBJ) mem_if.obj
+
+###################################################################
+all: banner $(TMP_D) exe
+
+banner:
+ @echo Building ipmiutil
+
+$(TMP_D):
+ $(MKDIR) $(TMP_D)
+ @echo created $(TMP_D)
+
+lib: $(L2_OBJ)
+ cd $(LIB_D)
+ nmake /nologo -f ipmilib.mak
+ cd ../util
+
+exe: $(E_EXE) $(TARG_EXE)
+
+install:
+ $(MKDIR) $(INSTALLTOP)
+ $(MKDIR) $(INSTALLTOP)\bin
+ $(CP) $(E_EXE) $(INSTALLTOP)\bin
+ xcopy $(TARG_EXE) $(INSTALLTOP)\bin
+ xcopy *.dll $(INSTALLTOP)\bin
+
+clean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ $(RM) $(TMP_D)\*.obj 2>NUL
+
+distclean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ $(RM) $(TMP_D)\*.* 2>NUL
+ rmdir $(TMP_D) 2>NUL
+ $(RM) *.rc 2>NUL
+ $(RM) *.bin 2>NUL
+ $(RM) *.RES 2>NUL
+ $(RM) getopt.* 2>NUL
+
+getopt.obj: getopt.c
+ $(CC) /c $(CFLAGS) getopt.c
+
+imbapi.obj: imbapi.c
+ $(CC) /c $(CFLAGS_M) imbapi.c
+
+ipmicmd.obj: ipmicmd.c
+ $(CC) /c $(CFLAGS) ipmicmd.c
+
+ipmilan.obj: ipmilan.c
+ $(CC) /c $(CFLAGS) ipmilan.c
+
+ipmilanplus.obj: ipmilanplus.c
+ $(CC) /c $(CFLAGS_M) ipmilanplus.c
+
+md5.obj: md5.c
+ $(CC) /c $(CFLAGS) md5.c
+
+md2.obj: md2.c
+ $(CC) /c $(CFLAGS) md2.c
+
+ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS) ievents.c
+
+ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS) ialarms.c
+
+ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS) ihealth.c
+
+igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS) igetevent.c
+
+mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) mem_if.c
+
+ipmims.obj: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) ipmims.cpp
+
+isel.obj: isel.c
+ $(CC) /c $(CFLAGS) isel.c
+
+ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS) ireset.c
+
+ireset.exe: ireset.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ireset.exe ireset.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS) ifru.c
+
+ifru.exe: ifru.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ifru.exe ifru.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS) ilan.c
+
+ilan.exe: ilan.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ilan.exe ilan.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS) iserial.c
+
+iserial.exe: iserial.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iserial.exe iserial.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS) isensor.c
+
+isensor.exe: isensor.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isensor.exe isensor.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS) iwdt.c
+
+iwdt.exe: iwdt.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iwdt.exe iwdt.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isol.obj: isol.c
+ $(CC) /c $(CFLAGS) isol.c
+
+isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS) isolwin.c
+
+isol.exe: isol.obj isolwin.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isol.exe isol.obj isolwin.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS) icmd.c
+
+icmd.exe: icmd.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:icmd.exe icmd.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS) idiscover.c
+
+idiscover.exe: idiscover.obj getopt.obj
+ $(LINK) $(LFLAGS) /OUT:idiscover.exe idiscover.obj getopt.obj \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ialarms.exe: ialarms.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ialarms.exe ialarms.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ihealth.exe: ihealth.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ihealth.exe ihealth.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+igetevent.exe: igetevent.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:igetevent.exe igetevent.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+isel.exe: isel.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isel.exe isel.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+$(SHOWSEL).mc:
+ $(CP) ..\scripts\$(SHOWSEL).mc .
+
+$(SHOWSEL)msg.dll: $(SHOWSEL).mc
+ mc -U $(SHOWSEL).mc
+ rc -r $(SHOWSEL).rc
+ $(LINK) /machine:$(MARCH) -dll -noentry -out:$(SHOWSEL)msg.dll $(SHOWSEL).res
+
+mem_if.exe: $(TMP_D)\mem_if.obj
+ $(LINK) $(LFLAGS_W) /OUT:mem_if.exe $(TMP_D)\mem_if.obj $(LIBS_EX)
+
+$(TMP_D)\mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) /DCOMP_BIN /Fo$(TMP_D)\mem_if.obj mem_if.c
+
+ievents.exe: ievents.c
+ $(CC) /c $(CFLAGS) /DALONE ievents.c
+ $(LINK) $(LFLAGS) /OUT:ievents.exe ievents.obj $(LIBS_EX)
+ $(RM) ievents.obj
+
+ipmims.exe: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) /DALONE /DTEST_BIN ipmims.cpp
+ $(LINK) $(LFLAGS_W) /OUT:ipmims.exe ipmims.obj $(LIBS_EX)
+ $(RM) ipmims.obj
+
+$(TMP_D)\ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ievents.obj ievents.c
+
+$(TMP_D)\ipmiutil.obj: ipmiutil.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipmiutil.obj ipmiutil.c
+
+$(TMP_D)\ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ialarms.obj ialarms.c
+
+$(TMP_D)\ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihealth.obj ihealth.c
+
+$(TMP_D)\iconfig.obj: iconfig.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iconfig.obj iconfig.c
+
+$(TMP_D)\ipicmg.obj: ipicmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipicmg.obj ipicmg.c
+
+$(TMP_D)\ifirewall.obj: ifirewall.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifirewall.obj ifirewall.c
+
+$(TMP_D)\ifwum.obj: ifwum.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifwum.obj ifwum.c
+
+$(TMP_D)\ihpm.obj: ihpm.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihpm.obj ihpm.c
+
+$(TMP_D)\idcmi.obj: idcmi.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idcmi.obj idcmi.c
+
+$(TMP_D)\oem_fujitsu.obj: oem_fujitsu.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_fujitsu.obj oem_fujitsu.c
+
+$(TMP_D)\oem_kontron.obj: oem_kontron.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_kontron.obj oem_kontron.c
+
+$(TMP_D)\oem_intel.obj: oem_intel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_intel.obj oem_intel.c
+
+$(TMP_D)\oem_sun.obj: oem_sun.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_sun.obj oem_sun.c
+
+$(TMP_D)\oem_dell.obj: oem_dell.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_dell.obj oem_dell.c
+
+$(TMP_D)\oem_hp.obj: oem_hp.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_hp.obj oem_hp.c
+
+$(TMP_D)\oem_supermicro.obj: oem_supermicro.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_supermicro.obj oem_supermicro.c
+
+$(TMP_D)\oem_quanta.obj: oem_quanta.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_quanta.obj oem_quanta.c
+
+$(TMP_D)\oem_newisys.obj: oem_newisys.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_newisys.obj oem_newisys.c
+
+$(TMP_D)\iekanalyzer.obj: iekanalyzer.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iekanalyzer.obj iekanalyzer.c
+
+$(TMP_D)\ifru_picmg.obj: ifru_picmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru_picmg.obj ifru_picmg.c
+
+$(TMP_D)\ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru.obj ifru.c
+
+$(TMP_D)\ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ireset.obj ireset.c
+
+$(TMP_D)\ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ilan.obj ilan.c
+
+$(TMP_D)\iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iserial.obj iserial.c
+
+$(TMP_D)\isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isensor.obj isensor.c
+
+$(TMP_D)\icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\icmd.obj icmd.c
+
+$(TMP_D)\igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\igetevent.obj igetevent.c
+
+$(TMP_D)\isel.obj: isel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isel.obj isel.c
+
+$(TMP_D)\isol.obj: isol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isol.obj isol.c
+
+$(TMP_D)\isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isolwin.obj isolwin.c
+
+$(TMP_D)\itsol.obj: itsol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\itsol.obj itsol.c
+
+$(TMP_D)\AnsiTerm.obj: AnsiTerm.cpp
+ $(CC) /c $(CFLAGS_W) /Fo$(TMP_D)\AnsiTerm.obj AnsiTerm.cpp
+
+$(TMP_D)\idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idiscover.obj idiscover.c
+
+$(TMP_D)\iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iwdt.obj iwdt.c
+
+$(E_EXE): $(E_OBJ)
+ $(LINK) $(LFLAGS) /OUT:$(E_EXE) $(E_OBJ) $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample.obj: ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+
+$(SAMP_LIB): $(CMD_OBJ) mem_if.obj
+ $(CC) /c $(CFLAGS_SAM) ipmilanplus.c
+ $(MKLIB) /OUT:$(SAMP_LIB) /nologo $(CMD_OBJ) mem_if.obj
+ del ipmilanplus.obj
+
+$(SAMP_DLL): $(CMD_OBJ) mem_if.obj
+ $(CC) /D_WINDLL /D_USRDLL /c $(CFLAGS_SAM) ipmilanplus.c
+ $(LINK) /DLL $(LFLAGS) /OUT:$(SAMP_DLL) /def:ipmiutillib.def $(CMD_OBJ) mem_if.obj $(LIBS_PEF) $(LIBS_EX)
+ del ipmilanplus.obj
+
+ipmi_sample.exe: $(SAMP_LIB) ipmi_sample.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample.exe ipmi_sample.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample2.exe: $(SAMP_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) /c $(CFLAGS_SAM) /DGET_SENSORS ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) isensor.c
+ $(CC) /c $(CFLAGS_SAM) ievents.c
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample2.exe ipmi_sample.obj isensor.obj ievents.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+ del isensor.obj ievents.obj
+
+ipmi_sample_evt.obj: ipmi_sample_evt.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample_evt.c
+
+isensor2.obj: isensor.c isensor.h $(HEADER)
+ $(CC) /c /Foisensor2.obj $(CFLAGS_SAM) isensor.c
+
+ievents2.obj: ievents.c ievents.h $(HEADER)
+ $(CC) /c /Foievents2.obj $(CFLAGS_SAM) /DSENSORS_OK ievents.c
+
+ipmi_sample_evt.exe: $(SAMP_LIB) ipmi_sample_evt.obj ievents2.obj isensor2.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample_evt.exe ipmi_sample_evt.obj ievents2.obj isensor2.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
diff --git a/util/ipmiutil64.mak b/util/ipmiutil64.mak
new file mode 100644
index 0000000..4c7b315
--- /dev/null
+++ b/util/ipmiutil64.mak
@@ -0,0 +1,423 @@
+# This makefile will build the ipmiutil util directory (x64)
+#
+# First download getopt.c getopt.h
+# Then download and build openssl for Windows
+#
+LIBC_RT=libcmt.lib /NODEFAULTLIB:"msvcirt.lib"
+# LIBC_RT=msvcrt.lib /NODEFAULTLIB:"msvcirt.lib"
+
+#MARCH=IX86
+MARCH=X64
+# The ipmiutil directory
+SRC_D=.
+LIB_D=..\lib
+L2_D=$(LIB_D)\lanplus
+L3_D=$(LIB_D)\lanplus\inc
+INSTALLTOP=install
+TMP_D=tmp
+INC=/I$(SRC_D) /I$(L2_D) /I$(L3_D)
+CMD_OBJ = getopt.obj ipmicmd.obj imbapi.obj md5.obj md2.obj \
+ ipmilan.obj ipmims.obj subs.obj
+CMD_OBJ = $(CMD_OBJ) ipmilanplus.obj
+# To remove lanplus support use the empty LANPLUS variables
+# L2_OBJ=
+# LF_LANPLUS=
+# CF_LANPLUS=
+L2_OBJ = $(L2_D)\helper.obj $(L2_D)\ipmi_strings.obj $(L2_D)\lanplus.obj \
+ $(L2_D)\lanplus_crypt_impl.obj $(L2_D)\lanplus_dump.obj \
+ $(L2_D)\lanplus_strings.obj $(L2_D)\lanplus_crypt.obj
+LF_LANPLUS=/LIBPATH:$(LIB_D) $(L2_OBJ) ssleay32.lib libeay32.lib
+CF_LANPLUS=/D HAVE_LANPLUS
+
+# Set your compiler options
+# To remove any GPL dependencies, use the CF_EX line with NON_GPL
+# CFLAGS_O=/W3 /O2 /Zi /MD /GF /Gy /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MD /nologo
+# CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CFLAGS_O=/W3 /O2 /Zi /MT /nologo
+CF_EX=/DWIN32 $(CF_LANPLUS) $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DHAVE_STRING_H
+CF_SAM=/DWIN32 $(INC) /D_CONSOLE /D_CRT_SECURE_NO_DEPRECATE /DHAVE_STRING_H
+CFLAGS=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2
+CFLAGS_M=$(CFLAGS_O) $(CF_EX) /DSKIP_MD2 /DMETACOMMAND
+CFLAGS_SAM=$(CFLAGS_O) $(CF_SAM)
+LFLAGS=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref
+#LFLAGS=/nologo /subsystem:console /machine:IX86 /opt:ref /debug
+# LFLAGS_D=/nologo /subsystem:console /machine:I386 /opt:ref /dll
+
+# CFLAGS_W=/O2 /D_CONSOLE /D_MBCS /EHsc /ML /W3 /Zi /TP
+CFLAGS_W=/TP /EHsc $(CFLAGS)
+LFLAGS_W=/nologo /subsystem:console /machine:$(MARCH) /opt:ref
+LIBS_W=comsuppw.lib wbemuuid.lib
+# gdi32.lib comdlg32.lib shell32.lib uuid.lib
+
+CC=cl
+LINK=link
+MKDIR=-mkdir
+MKLIB=lib
+RM=del
+CP=copy
+
+LIBS_EX = advapi32.lib kernel32.lib wsock32.lib ws2_32.lib $(LIBS_W) $(LIBC_RT)
+LIBS_PEF = /LIBPATH:$(LIB_D) iphlpapi.lib
+# LIBS_EX+=wsock32.lib user32.lib gdi32.lib
+
+HEADER=ipmicmd.h imb_api.h ipmilan.h ipmidir.h ipmilanplus.h \
+ ipmiutil.h
+
+SHOWSEL = showsel
+TARG_EXE=ievents.exe $(SHOWSEL)msg.dll ipmi_sample.exe ipmi_sample2.exe ipmi_sample_evt.exe $(SAMP_DLL)
+# alarms.exe ihealth.exe $(SHOWSEL).exe $(SHOWSEL)msg.dll \
+# ireset.exe ifru.exe ilan.exe iserial.exe wdt.exe \
+# getevent.exe sensor.exe icmd.exe isolconsole.exe idiscover.exe \
+# ievents.exe
+SAMP_LIB = ipmiutil.lib
+SAMP_DLL = ipmiutillib.dll
+
+E_EXE=ipmiutil.exe
+E_OBJ=$(TMP_D)\ipmiutil.obj \
+ $(TMP_D)\ialarms.obj $(TMP_D)\ihealth.obj $(TMP_D)\iwdt.obj \
+ $(TMP_D)\ireset.obj $(TMP_D)\ifru.obj $(TMP_D)\ilan.obj \
+ $(TMP_D)\iserial.obj $(TMP_D)\icmd.obj $(TMP_D)\isol.obj \
+ $(TMP_D)\isolwin.obj $(TMP_D)\AnsiTerm.obj $(TMP_D)\idiscover.obj \
+ $(TMP_D)\iconfig.obj $(TMP_D)\igetevent.obj $(TMP_D)\isensor.obj \
+ $(TMP_D)\isel.obj $(TMP_D)\ievents.obj \
+ $(TMP_D)\ipicmg.obj $(TMP_D)\ifirewall.obj \
+ $(TMP_D)\iekanalyzer.obj $(TMP_D)\ifru_picmg.obj \
+ $(TMP_D)\oem_kontron.obj $(TMP_D)\ihpm.obj $(TMP_D)\ifwum.obj \
+ $(TMP_D)\oem_fujitsu.obj $(TMP_D)\oem_intel.obj \
+ $(TMP_D)\oem_sun.obj $(TMP_D)\oem_dell.obj $(TMP_D)\oem_hp.obj \
+ $(TMP_D)\oem_supermicro.obj $(TMP_D)\itsol.obj $(TMP_D)\idcmi.obj \
+ $(TMP_D)\oem_quanta.obj $(TMP_D)\oem_newisys.obj $(CMD_OBJ) mem_if.obj
+
+###################################################################
+all: banner $(TMP_D) exe
+
+banner:
+ @echo Building ipmiutil
+
+$(TMP_D):
+ $(MKDIR) $(TMP_D)
+ @echo created $(TMP_D)
+
+lib: $(L2_OBJ)
+ cd $(LIB_D)
+ nmake /nologo -f ipmilib.mak
+ cd ../util
+
+exe: $(E_EXE) $(TARG_EXE)
+
+install:
+ $(MKDIR) $(INSTALLTOP)
+ $(MKDIR) $(INSTALLTOP)\bin
+ $(CP) $(E_EXE) $(INSTALLTOP)\bin
+ xcopy $(TARG_EXE) $(INSTALLTOP)\bin
+ xcopy *.dll $(INSTALLTOP)\bin
+
+clean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ -$(RM) $(TMP_D)\*.obj 2>NUL
+
+distclean:
+ $(RM) *.obj 2>NUL
+ $(RM) $(TARG_EXE) 2>NUL
+ $(RM) *.exe 2>NUL
+ -$(RM) $(TMP_D)\*.* 2>NUL
+ rmdir $(TMP_D) 2>NUL
+ $(RM) *.rc 2>NUL
+ $(RM) *.bin 2>NUL
+ $(RM) *.RES 2>NUL
+ $(RM) getopt.* 2>NUL
+
+getopt.obj: getopt.c
+ $(CC) /c $(CFLAGS) getopt.c
+
+imbapi.obj: imbapi.c
+ $(CC) /c $(CFLAGS_M) imbapi.c
+
+ipmicmd.obj: ipmicmd.c
+ $(CC) /c $(CFLAGS) ipmicmd.c
+
+ipmilan.obj: ipmilan.c
+ $(CC) /c $(CFLAGS) ipmilan.c
+
+ipmilanplus.obj: ipmilanplus.c
+ $(CC) /c $(CFLAGS_M) ipmilanplus.c
+
+md5.obj: md5.c
+ $(CC) /c $(CFLAGS) md5.c
+
+md2.obj: md2.c
+ $(CC) /c $(CFLAGS) md2.c
+
+ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS) ievents.c
+
+ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS) ialarms.c
+
+ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS) ihealth.c
+
+igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS) igetevent.c
+
+mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) mem_if.c
+
+ipmims.obj: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) ipmims.cpp
+
+isel.obj: isel.c
+ $(CC) /c $(CFLAGS) isel.c
+
+ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS) ireset.c
+
+ireset.exe: ireset.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ireset.exe ireset.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS) ifru.c
+
+ifru.exe: ifru.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ifru.exe ifru.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS) ilan.c
+
+ilan.exe: ilan.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ilan.exe ilan.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS) iserial.c
+
+iserial.exe: iserial.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iserial.exe iserial.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS) isensor.c
+
+isensor.exe: isensor.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isensor.exe isensor.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS) iwdt.c
+
+iwdt.exe: iwdt.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:iwdt.exe iwdt.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+isol.obj: isol.c
+ $(CC) /c $(CFLAGS) isol.c
+
+isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS) isolwin.c
+
+isol.exe: isol.obj isolwin.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isol.exe isol.obj isolwin.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS) icmd.c
+
+icmd.exe: icmd.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:icmd.exe icmd.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS) idiscover.c
+
+idiscover.exe: idiscover.obj getopt.obj
+ $(LINK) $(LFLAGS) /OUT:idiscover.exe idiscover.obj getopt.obj \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ialarms.exe: ialarms.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ialarms.exe ialarms.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+ihealth.exe: ihealth.obj mem_if.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:ihealth.exe ihealth.obj mem_if.obj $(CMD_OBJ) \
+ $(LF_LANPLUS) $(LIBS_EX)
+
+igetevent.exe: igetevent.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:igetevent.exe igetevent.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+isel.exe: isel.obj ievents.obj $(CMD_OBJ)
+ $(LINK) $(LFLAGS) /OUT:isel.exe isel.obj ievents.obj \
+ $(CMD_OBJ) $(LF_LANPLUS) $(LIBS_EX)
+
+$(SHOWSEL).mc:
+ $(CP) ..\scripts\$(SHOWSEL).mc .
+
+$(SHOWSEL)msg.dll: $(SHOWSEL).mc
+ mc -U $(SHOWSEL).mc
+ rc -r $(SHOWSEL).rc
+ $(LINK) /machine:$(MARCH) -dll -noentry -out:$(SHOWSEL)msg.dll $(SHOWSEL).res
+
+mem_if.exe: $(TMP_D)\mem_if.obj
+ $(LINK) $(LFLAGS_W) /OUT:mem_if.exe $(TMP_D)\mem_if.obj $(LIBS_EX)
+
+$(TMP_D)\mem_if.obj: mem_if.c
+ $(CC) /c $(CFLAGS_W) /DCOMP_BIN /Fo$(TMP_D)\mem_if.obj mem_if.c
+
+ievents.exe: ievents.c
+ $(CC) /c $(CFLAGS) /DALONE ievents.c
+ $(LINK) $(LFLAGS) /OUT:ievents.exe ievents.obj $(LIBS_EX)
+ $(RM) ievents.obj
+
+ipmims.exe: ipmims.cpp
+ $(CC) /c $(CFLAGS_W) /DALONE /DTEST_BIN ipmims.cpp
+ $(LINK) $(LFLAGS_W) /OUT:ipmims.exe ipmims.obj $(LIBS_EX)
+ $(RM) ipmims.obj
+
+$(TMP_D)\ievents.obj: ievents.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ievents.obj ievents.c
+
+$(TMP_D)\ipmiutil.obj: ipmiutil.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipmiutil.obj ipmiutil.c
+
+$(TMP_D)\ialarms.obj: ialarms.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ialarms.obj ialarms.c
+
+$(TMP_D)\ihealth.obj: ihealth.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihealth.obj ihealth.c
+
+$(TMP_D)\iconfig.obj: iconfig.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iconfig.obj iconfig.c
+
+$(TMP_D)\ipicmg.obj: ipicmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ipicmg.obj ipicmg.c
+
+$(TMP_D)\ifirewall.obj: ifirewall.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifirewall.obj ifirewall.c
+
+$(TMP_D)\ifwum.obj: ifwum.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifwum.obj ifwum.c
+
+$(TMP_D)\ihpm.obj: ihpm.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ihpm.obj ihpm.c
+
+$(TMP_D)\idcmi.obj: idcmi.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idcmi.obj idcmi.c
+
+$(TMP_D)\oem_fujitsu.obj: oem_fujitsu.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_fujitsu.obj oem_fujitsu.c
+
+$(TMP_D)\oem_kontron.obj: oem_kontron.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_kontron.obj oem_kontron.c
+
+$(TMP_D)\oem_intel.obj: oem_intel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_intel.obj oem_intel.c
+
+$(TMP_D)\oem_sun.obj: oem_sun.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_sun.obj oem_sun.c
+
+$(TMP_D)\oem_dell.obj: oem_dell.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_dell.obj oem_dell.c
+
+$(TMP_D)\oem_hp.obj: oem_hp.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_hp.obj oem_hp.c
+
+$(TMP_D)\oem_supermicro.obj: oem_supermicro.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_supermicro.obj oem_supermicro.c
+
+$(TMP_D)\oem_quanta.obj: oem_quanta.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_quanta.obj oem_quanta.c
+
+$(TMP_D)\oem_newisys.obj: oem_newisys.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\oem_newisys.obj oem_newisys.c
+
+$(TMP_D)\iekanalyzer.obj: iekanalyzer.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iekanalyzer.obj iekanalyzer.c
+
+$(TMP_D)\ifru_picmg.obj: ifru_picmg.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru_picmg.obj ifru_picmg.c
+
+$(TMP_D)\ifru.obj: ifru.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ifru.obj ifru.c
+
+$(TMP_D)\ireset.obj: ireset.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ireset.obj ireset.c
+
+$(TMP_D)\ilan.obj: ilan.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\ilan.obj ilan.c
+
+$(TMP_D)\iserial.obj: iserial.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iserial.obj iserial.c
+
+$(TMP_D)\isensor.obj: isensor.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isensor.obj isensor.c
+
+$(TMP_D)\icmd.obj: icmd.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\icmd.obj icmd.c
+
+$(TMP_D)\igetevent.obj: igetevent.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\igetevent.obj igetevent.c
+
+$(TMP_D)\isel.obj: isel.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isel.obj isel.c
+
+$(TMP_D)\isol.obj: isol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isol.obj isol.c
+
+$(TMP_D)\isolwin.obj: isolwin.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\isolwin.obj isolwin.c
+
+$(TMP_D)\itsol.obj: itsol.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\itsol.obj itsol.c
+
+$(TMP_D)\AnsiTerm.obj: AnsiTerm.cpp
+ $(CC) /c $(CFLAGS_W) /Fo$(TMP_D)\AnsiTerm.obj AnsiTerm.cpp
+
+$(TMP_D)\idiscover.obj: idiscover.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\idiscover.obj idiscover.c
+
+$(TMP_D)\iwdt.obj: iwdt.c
+ $(CC) /c $(CFLAGS_M) /Fo$(TMP_D)\iwdt.obj iwdt.c
+
+$(E_EXE): $(E_OBJ)
+ $(LINK) $(LFLAGS) /OUT:$(E_EXE) $(E_OBJ) $(LF_LANPLUS) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample.obj: ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample.c
+
+$(SAMP_LIB): $(CMD_OBJ) mem_if.obj
+ $(CC) /c $(CFLAGS_SAM) ipmilanplus.c
+ $(MKLIB) /OUT:$(SAMP_LIB) /nologo $(CMD_OBJ) mem_if.obj
+ del ipmilanplus.obj
+
+$(SAMP_DLL): $(CMD_OBJ) mem_if.obj
+ $(CC) /D_WINDLL /D_USRDLL /c $(CFLAGS_SAM) ipmilanplus.c
+ $(LINK) /DLL $(LFLAGS) /OUT:$(SAMP_DLL) /def:ipmiutillib.def $(CMD_OBJ) mem_if.obj $(LIBS_PEF) $(LIBS_EX)
+ del ipmilanplus.obj
+
+ipmi_sample.exe: $(SAMP_LIB) ipmi_sample.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample.exe ipmi_sample.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+
+ipmi_sample2.exe: $(SAMP_LIB) ipmi_sample.c isensor.c ievents.c
+ $(CC) /c $(CFLAGS_SAM) /DGET_SENSORS ipmi_sample.c
+ $(CC) /c $(CFLAGS_SAM) isensor.c
+ $(CC) /c $(CFLAGS_SAM) ievents.c
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample2.exe ipmi_sample.obj isensor.obj ievents.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
+ del isensor.obj ievents.obj
+
+ipmi_sample_evt.obj: ipmi_sample_evt.c $(HEADER)
+ $(CC) /c $(CFLAGS_SAM) ipmi_sample_evt.c
+
+isensor2.obj: isensor.c isensor.h $(HEADER)
+ $(CC) /c /Foisensor2.obj $(CFLAGS_SAM) isensor.c
+
+ievents2.obj: ievents.c ievents.h $(HEADER)
+ $(CC) /c /Foievents2.obj $(CFLAGS_SAM) /DSENSORS_OK ievents.c
+
+ipmi_sample_evt.exe: $(SAMP_LIB) ipmi_sample_evt.obj ievents2.obj isensor2.obj
+ $(LINK) $(LFLAGS) /OUT:ipmi_sample_evt.exe ipmi_sample_evt.obj ievents2.obj isensor2.obj $(SAMP_LIB) $(LIBS_PEF) $(LIBS_EX)
diff --git a/util/ipmiutillib.def b/util/ipmiutillib.def
new file mode 100644
index 0000000..57f3dc1
--- /dev/null
+++ b/util/ipmiutillib.def
@@ -0,0 +1,31 @@
+LIBRARY ipmiutillib
+EXPORTS
+ ipmi_cmd
+ ipmi_cmdraw
+ ipmi_close_
+ ipmi_set_mc
+ ipmi_get_mc
+ ipmi_restore_mc
+ ipmi_cmd_mc
+ ipmi_cmdraw_mc
+ parse_lan_options
+ print_lan_opt_usage
+ set_lan_options
+ get_lan_options
+ set_max_kcs_loops
+ get_driver_type
+ set_driver_type
+ get_nodename
+ nodeislocal
+ is_remote
+ ipmi_getdeviceid
+ show_devid
+ show_outcome
+ dump_buf
+ decode_rv
+ decode_cc
+ str_icmp
+ strdup_
+ htoi
+ os_usleep
+ write_syslog
diff --git a/util/ireset.c b/util/ireset.c
new file mode 100644
index 0000000..8116b7d
--- /dev/null
+++ b/util/ireset.c
@@ -0,0 +1,751 @@
+/*
+ * ireset.c (was hwreset.c)
+ *
+ * This tool power cycles (or powers off) the IPMI system.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2009 Kontron America, Inc.
+ * Copyright (c) 2002-2008 Intel Corporation
+ *
+ * 01/08/02 Andy Cress - created
+ * 01/31/02 Andy Cress - converted to use ipmi_cmd_ia,
+ * added more user options
+ * 02/06/02 Andy Cress - added ipmi_cmd_va
+ * 02/22/02 Andy Cress - added -s to reboot to service partition
+ * 07/02/02 Andy Cress v1.3 added more Usage text
+ * 08/02/02 Andy Cress v1.4 moved common ipmi_cmd() code to ipmicmd.c
+ * 09/24/02 Andy Cress - stubbed in OS shutdown option
+ * 01/29/03 Andy Cress v1.5 added MV OpenIPMI support
+ * 04/08/03 Andy Cress v1.6 added OS shutdown option (-o)
+ * 05/02/03 Andy Cress v1.7 leave console redir alone in SET_BOOT_OPTIONS
+ * 05/05/04 Andy Cress v1.8 call ipmi_close before exit, did WIN32 port.
+ * 08/09/04 Andy Cress v1.9 make sure to show error if ccode != 0, and
+ * detect Langley platforms to do special
+ * watchdog method for -o option.
+ * 11/01/04 Andy Cress 1.10 add -N / -R for remote nodes
+ * 11/16/04 Andy Cress 1.11 add -U for remote username
+ * 11/30/04 Andy Cress 1.12 fix bug 1075550 with -o -N, skip -o if not local.
+ * 03/28/05 Andy Cress 1.13 add netapp_reset commands for platforms that
+ * use this instead of chassis_reset.
+ * 05/16/05 Andy Cress 1.14 add -u option for power up
+ * 03/31/06 Andy Cress 1.15 add -e -p -m options
+ * 09/18/06 Andy Cress 1.20 allow more platforms to do soft reset, and
+ * if Tyan, ignore set boot options errors.
+ * 01/10/07 Andy Cress 1.25 added reset_str(), modify initchar (6) if -o.
+ */
+/*M*
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(EFI)
+ // EFI: defined (EFI32) || defined (EFI64) || defined(EFIX64)
+ // also would define ALONE (not METACOMMAND) to minimize externals
+ #ifndef NULL
+ #define NULL 0
+ #endif
+ #include <types.h>
+ #include <libdbg.h>
+ #include <unistd.h>
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include "ipmicmd.h"
+#include "oem_intel.h" /* for is_romley*/
+
+#define platIntel 1 /*Intel Sahalee servers, use alt soft-shutdown.*/
+#define platMBMC 2 /*mini-BMC platforms */
+#define platS5500 3 /*Intel S5500 platforms */
+#define platOther 4 /*Other platforms */
+#define GET_POWER_STATE 0x07
+#define INIT_VAL 0xff
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "ireset";
+static uchar ipmi_maj;
+static uchar ipmi_min;
+static uchar sms_sa = 0x81;
+static char fdebug = 0;
+static char fipmilan = 0;
+static char fignore_opterr = 0;
+static char fwait = 0;
+static char fpersist = 0;
+static char platform = 0; /* platform type: MBMC or TSR */
+static int shuttime = 60; /* shutdown timeout in seconds */
+#define MAX_INIT 77 /* 80 minus 3 for IANA */
+static char * initstr = NULL; /* boot initiator mailbox string */
+static uchar iana[3] = { 0x00, 0x00, 0x00 }; /*default to devid, see -j */
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static uchar gbootparm = 0x48; //verbose disply, bypass pswd, same console redir
+
+#if defined(EFI)
+int getopt(int argc, char **argv, const char *opts)
+{ /*very simple getopt */
+ int c = EOF;
+ static int iopt = 0;
+ iopt++;
+ if ((argc <= iopt) || (argv[iopt] == NULL)) return c;
+ if (argv[iopt][0] == '-') c = argv[iopt][1];
+ return(c);
+}
+#endif
+#if defined(ALONE)
+int is_romley(int vend, int prod)
+{
+ int ret = 0;
+ if (vend != VENDOR_INTEL) return(ret);
+ if (prod >= 0x0048 && prod <= 0x005e) ret = 1;
+ return(ret);
+}
+int write_syslog(char *msg) { return(0); } /*stub*/
+#else
+/*extern*/ int write_syslog(char *msg); /*from showsel.c*/
+#endif
+
+static void show_error(char *tag, int rv, uchar cc)
+{
+ if (rv > 0 && cc == 0) cc = (uchar)rv;
+ printf("%s: error %d ccode = %x %s\n",
+ tag,rv,cc,decode_cc((ushort)0,cc));
+ return;
+}
+
+static int set_wdt(uchar val, uchar act)
+{
+ uchar idata[6];
+ uchar rdata[16];
+ int rlen = 8;
+ uchar ccode;
+ int ret, t;
+
+ t = val * 10; /* val is in sec, make timeout in 100msec */
+ if ((ipmi_maj > 1) || /* IPMI 1.5 or greater */
+ (ipmi_maj == 1 && ipmi_min >= 5))
+ idata[0] = 0x44; /* DontLog=0, DontStop=1 & use SMS/OS */
+ else idata[0] = 0x04; /* IPMI 1.0 or less */
+ idata[1] = act;
+ /* 0x01; * action: no pretimeout, hard reset action */
+ /* 0x02; * action value for power down instead */
+ idata[2] = 0; /* pretimeout: 30 sec (but disabled) */
+ idata[3] = 0x10; /* clear SMS/OS when done */
+ idata[4] = t & 0x00ff; /*timeout in 100msec: 0x4B0 = 1200. */
+ idata[5] = (t & 0xff00) >> 8;
+ ret = ipmi_cmd_mc(WATCHDOG_SET, idata, 6, rdata, &rlen, &ccode, fdebug);
+ if (fdebug) printf("set_wdt: wd set(%d,%d) rv=%d cc=%x\n",
+ val,act,ret,ccode);
+ if (ret == 0 && ccode != 0) ret = ccode;
+
+ if (ret == 0) { /* Start the timer by issuing a watchdog reset */
+ ret = ipmi_cmd_mc(WATCHDOG_RESET,idata,0,rdata,&rlen, &ccode,fdebug);
+ if (fdebug) printf("set_wdt: wd reset rv=%d cc=%x\n",ret,ccode);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ }
+ return(ret);
+} /*end set_wdt()*/
+
+char *reset_str(uchar breset, uchar bopt)
+{
+ char *str;
+ switch(breset) {
+ case 0: str = "powering down"; break;
+ case 1: str = "powering up"; break;
+ case 2: str = "power cycling"; break;
+ case 3: str = "resetting"; break; /* -r, etc.*/
+ case 4: str = "sending NMI"; break;
+ case 5: str = "shutdown/reset"; break;
+ case 6: str = "shutdown/power_off"; break; /*via agent*/
+ case 7: str = "cold reset"; break;
+ default: str = "resetting"; break;
+ }
+ if (bopt > 0)
+ switch(bopt) {
+ case 1: str = "resetting to Svc partition"; break;
+ case 2: str = "resetting to EFI"; break;
+ case 3: str = "resetting to PXE"; break;
+ case 4: str = "resetting to CDROM"; break;
+ case 5: str = "resetting to hard disk"; break;
+ case 6: str = "resetting to BIOS Setup"; break;
+ case 7: str = "resetting to floppy"; break;
+ default: str = "resetting"; break;
+ }
+ return(str);
+}
+
+int set_boot_init_string(char *istr)
+{
+ int rv = 0;
+ uchar idata[20]; /*need 17 bytes*/
+ uchar rdata[MAX_BUFFER_SIZE];
+ uchar cc;
+ int i, n, len, rlen;
+
+ /* set param 7 for boot initiator mailbox */
+ len = (int)strlen(istr);
+ n = 0;
+ for (i = 0; n < len; i++)
+ {
+ memset(idata,0,18);
+ idata[0] = 0x07; /* param, 7 = boot init mailbox */
+ idata[1] = i; /* set selector */
+ if (i == 0) { /* insert IANA */
+ idata[2] = iana[0];
+ idata[3] = iana[1];
+ idata[4] = iana[2];
+ strncpy(&idata[5],&istr[n],13);
+ n += 13;
+ } else {
+ strncpy(&idata[2],&istr[n],16);
+ n += 16;
+ }
+ rlen = MAX_BUFFER_SIZE;
+ rv = ipmi_cmd_mc(SET_BOOT_OPTIONS, idata, 18, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv != 0) break;
+ }
+ return(rv);
+}
+
+static int IPMI_Reset(uchar bpower, uchar bootopt)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar completionCode;
+ uchar inputData[20];
+ char initmsg[80];
+ int status = 0;
+ uchar cmd;
+
+ /* May want to GetSystemBootOptions first to show existing. */
+
+ /* if (bootopt != 0) then set param 3 to not clear boot valid flag */
+ if (bootopt != 0)
+ {
+ inputData[0] = 0x03; // param, 3 = boot clear
+ if (fpersist)
+ inputData[1] = 0x1F; // persist all available conditions
+ else inputData[1] = 0x00; // clear after next boot
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd_mc(SET_BOOT_OPTIONS, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == 0) status = completionCode;
+ if (status != 0) {
+ if (fdebug || !fignore_opterr)
+ printf("set_boot_options ccode %x, resp[0] = %x, resp[1] = %x\n",
+ completionCode, responseData[0], responseData[1]);
+ if (!fignore_opterr)
+ return(status); /* abort if the boot options can't be set */
+ }
+
+ inputData[0] = 0x05; // param, 5 = boot flags
+ if (fpersist)
+ inputData[1] = 0xC0; // valid flags, persistent
+ else inputData[1] = 0x80; // valid flags, next boot only
+ if (bootopt == 2) inputData[1] |= 0x20; // add boot to EFI
+ if (bootopt == 1) inputData[2] = 0x10; // boot to svc partition
+ else if (bootopt == 3) inputData[2] = 0x04; // boot to PXE
+ else if (bootopt == 4) inputData[2] = 0x14; // boot to CDROM
+ else if (bootopt == 5) inputData[2] = 0x08; // boot to Hard Disk
+ else if (bootopt == 6) inputData[2] = 0x18; // boot to BIOS Setup
+ else if (bootopt == 7) inputData[2] = 0x3C; // boot to Floppy/Remov
+ else if (bootopt == 8) inputData[2] = 0x0C; // boot to HardDisk/Safe
+ else inputData[2] = 0x00; // normal boot
+ inputData[3] = gbootparm;
+ inputData[4] = 0x00; //no overrides
+ inputData[5] = 0x00; //
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd_mc(SET_BOOT_OPTIONS, inputData, 6, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (status == 0) status = completionCode;
+ if (status != 0) {
+ if (fdebug || !fignore_opterr)
+ printf("set_boot_options ccode %x, resp[0] = %x, resp[1] = %x\n",
+ completionCode, responseData[0], responseData[1]);
+ if (!fignore_opterr)
+ return(status); /* abort if the boot options can't be set */
+ }
+ if (initstr != NULL) {
+ status = set_boot_init_string(initstr);
+ if (fdebug) printf("set_boot_init_string(%s) status = %d\n",
+ initstr,status);
+ if (status != 0) {
+ if (!fignore_opterr) return(status);
+ else status = 0;
+ }
+ }
+ }
+
+ /*
+ * fshutdown (bpower >= 5) for Intel:
+ * Since we are in user mode, we can't wait for it to fully
+ * shut down and then issue the IPMI Chassis Reset.
+ * IPMI can trigger this by emulating an overtemp event.
+ * There is also a watchdog/init0 method used by platIntel.
+ * bpower was set by caller to 5 or 6
+ */
+ if ((bpower >= 5) && (platform == platIntel))
+ { /*Intel os shutdown requested*/
+ if (fipmilan) {
+#ifdef EXPERIMENTAL
+ int rv;
+ /*Try remote shutdown via Bridged SMS */
+ inputData[0] = 5; /* chassis ctl soft shutdown option */
+ responseLength = MAX_BUFFER_SIZE;
+ rv = ipmi_cmdraw( CHASSIS_CTL,
+ NETFN_APP,BMC_SA,PUBLIC_BUS, SMS_LUN,
+ inputData,1,responseData,&responseLength,
+ &completionCode, fdebug);
+ printf("Remote soft shutdown initiated (%d,%d).\n",status,rv);
+#else
+ /* abort if call this with fipmi_lan, platIntel. */
+ /* should have invoked remote agent method before this. */
+ return(LAN_ERR_NOTSUPPORT);
+#endif
+ } else { /* do local shutdown with wdt*/
+ uchar action;
+ char initcmd[16];
+ char initchar, shutchar;
+
+ /*
+ * Special OS shutdown method for CG Servers
+ * Set up a watchdog event to do reset after timeout.
+ * Valid on other platforms too if they support watchdog.
+ * Note that the "init 0" only makes sense if local.
+ */
+ if (bpower == 6) { action = 0x02; /*do power_down*/
+ initchar = '0';
+ shutchar = 's';
+ } else { action = 0x01; /*do hard_reset*/
+ initchar = '6';
+ shutchar = 'r';
+ }
+ status = set_wdt((uchar)shuttime, action);
+ if (status == 0)
+ { /*local shutdown */
+ sprintf(initmsg,"%s: soft shutdown -%c initiated\n",progname,shutchar);
+ write_syslog(initmsg);
+#ifdef WIN32
+ sprintf(initcmd,"shutdown -%c -c %s",shutchar,progname);
+ status = system(initcmd); /* do the OS shutdown */
+ printf("Windows soft shutdown initiated (%s).\n",initcmd);
+#else
+ sprintf(initcmd,"init %c",initchar);
+ status = system(initcmd); /* do the OS shutdown */
+ printf("Linux soft shutdown initiated (%s).\n",initcmd);
+#endif
+ }
+ /*
+ * Note that this can generate a Watchdog 2 event in the SEL.
+ * If the init 0/6 is successful within the 60 second timeout,
+ * BIOS will stop the watchdog.
+ */
+ return(status);
+ } /*endif local*/
+ } /*endif Intel os shutdown*/
+
+ /* 0 = power down, 1 = power up, 2 = power cycle, 3 = hard reset */
+ /* 4 = NMI interrupt, 5 = soft shutdown OS via ACPI */
+ if (bpower > 5) bpower = 5; /* if invalid, try shutdown */
+ if (!fipmilan) { /*only write to syslog if local*/
+ sprintf(initmsg,"%s: chassis %s\n",progname,reset_str(bpower,bootopt));
+ write_syslog(initmsg);
+ }
+ inputData[0] = bpower; // chassis control reset
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmd_mc(CHASSIS_CTL, inputData, 1, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (fdebug) {
+ printf("Chassis_Ctl(%x) ccode=%x, resp[0]=%x, resp[1]=%x\n",
+ bpower, completionCode,
+ responseData[0], responseData[1]);
+ }
+ if (status == ACCESS_OK && completionCode == 0) {
+ printf("chassis_reset ok\n");
+ //successful, done
+ return(0);
+ } else if (fipmilan && (status < 0)) {
+ /* Remote IPMI LAN reset could not connect,
+ * no point in continuing. */
+ return(status);
+ } else {
+ if (bpower == 5 && completionCode == 0xcc) {
+ /* See IPMI spec 22.3 Chassis Control, Table 22-4 */
+ printf("Optional soft-shutdown mode not supported\n");
+ /* If get here, need to use method like platIntel above. */
+ } else {
+ show_error("chassis_reset",status,completionCode);
+ // status = -1;
+
+ /* Try net_app warm/cold reset commands instead */
+ if (bpower == 2) cmd = 2; /* cold reset */
+ else cmd = 3; /* warm reset */
+ responseLength = MAX_BUFFER_SIZE;
+ status = ipmi_cmdraw( cmd,NETFN_APP, g_sa, g_bus, g_lun,
+ inputData,0,responseData,&responseLength,
+ &completionCode, fdebug);
+ if (status == ACCESS_OK && completionCode == 0) {
+ printf("netapp_reset ok\n");
+ } else {
+ show_error("netapp_reset",status,completionCode);
+ if (status == 0) status = completionCode;
+ }
+ }
+ } /*end else*/
+ return(status);
+} /*end IPMI_Reset()*/
+
+static void wait_ready(void)
+{
+ int i, c;
+ uchar devrec[16];
+ /* wait for BMC ready again */
+ os_usleep(1,0); /*delay 1 sec*/
+ for (i = 0; i < 15; i++) {
+ os_usleep(1,0); /*delay 1 sec*/
+ c = ipmi_getdeviceid(devrec,16,fdebug);
+ if (c == 0) break;
+ else { /* expect LAN_ERR_RECV_FAIL if BMC not ready */
+ if (fdebug) printf("after reset, try%d ret = %d\n",i,c);
+ if (c != LAN_ERR_RECV_FAIL) break;
+ }
+ } /*end-for*/
+}
+
+static void show_usage(void)
+{
+ printf("Usage: %s [-bcdDefhkmnoprsuwxy -N node -U user -P/-R pswd -EFTVY]\n",
+ progname);
+ printf(" where -c power Cycles the system\n");
+ printf(" -d powers Down the system\n");
+ printf(" -D soft-shutdown OS and power down\n");
+ printf(" -k do Cold Reset of the BMC firmware\n");
+ printf(" -i<str> set boot Initiator mailbox string\n");
+ printf(" -j<num> set IANA number for boot Initiator\n");
+ printf(" -n sends NMI to the system\n");
+ printf(" -o soft-shutdown OS and reset\n");
+ printf(" -r hard Resets the system\n");
+ printf(" -u powers Up the system\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -b reboots to BIOS Setup\n");
+ printf(" -e reboots to EFI\n");
+ printf(" -f reboots to Floppy/Removable\n");
+ printf(" -h reboots to Hard Disk\n");
+ printf(" -p reboots to PXE via network\n");
+ printf(" -s reboots to Service Partition\n");
+ printf(" -v reboots to DVD/CDROM Media\n");
+ printf(" -w Wait for BMC ready after reset\n");
+ printf(" -x show eXtra debug messages\n");
+ printf(" -y Yes, persist boot options [-befhpms]\n");
+ print_lan_opt_usage();
+}
+
+#ifdef METACOMMAND
+int i_reset(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret;
+ int c;
+ uchar breset;
+ uchar bopt;
+ uchar fshutdown = 0;
+ uchar devrec[16];
+ int rlen;
+ uchar rqdata[10];
+ uchar rsdata[32];
+ int rslen;
+ int mfg = 0;
+ uchar cc;
+ char *s1;
+
+#if defined (EFI)
+ InitializeLib(_LIBC_EFIImageHandle, _LIBC_EFISystemTable);
+#endif
+ // progname = argv[0];
+ printf("%s ver %s\n", progname,progver);
+ breset = INIT_VAL; /* invalid as default, require an option */
+ bopt = 0; /* Boot Options default */
+ /* Request admin privilege by default, since power control requires it. */
+ parse_lan_options('V',"4",0);
+
+ while ((c = getopt(argc,argv,"bcdDefhi:j:km:noprsuvwyT:V:J:YEF:N:P:R:U:Z:x?")) != EOF)
+ switch(c) {
+ case 'd': breset = 0; break; /* power down */
+ case 'u': breset = 1; break; /* power up */
+ case 'c': breset = 2; break; /* power cycle */
+ case 'o': breset = 5; fshutdown = 1; break; /*soft shutdown,reset*/
+ case 'D': breset = 6; fshutdown = 1; break; /*soft shutdown,pwrdown*/
+ case 'n': breset = 4; break; /* interrupt (NMI) */
+ case 'r': breset = 3; break; /* hard reset */
+ case 's': breset = 3; bopt = 1; break; /* hard reset to svc part */
+ case 'e': breset = 3; bopt = 2; break; /* hard reset to EFI */
+ case 'p': breset = 3; bopt = 3; break; /* hard reset to PXE */
+ case 'v': breset = 3; bopt = 4; break; /* hard reset to DVD/CD Media*/
+ case 'h': breset = 3; bopt = 5; break; /* hard reset to Hard Disk */
+ case 'b': breset = 3; bopt = 6; break; /* hard reset to BIOS Setup */
+ case 'f': breset = 3; bopt = 7; break; /* hard reset to floppy/remov*/
+ case 'i': if (strlen(optarg) < MAX_INIT) initstr = optarg; break;
+ case 'j': mfg = atoi(optarg); /*IANA number*/
+ iana[0] = ((mfg & 0xFF0000) >> 16);
+ iana[1] = ((mfg & 0x00FF00) >> 8);
+ iana[2] = (mfg & 0x0000FF);
+ break;
+ case 'k': breset = 7; break; /* cold reset */
+ case 'w': fwait = 1; break; /* wait for ready */
+ case 'y': fpersist = 1; break; /* yes, persist boot options */
+ case 'm': /* specific MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case 'x': fdebug = 1; break; /* debug messages */
+ default:
+ show_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ if (breset == INIT_VAL) {
+ show_usage();
+ printf("An option is required\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+
+ fipmilan = is_remote();
+ /*
+ * Check the Device ID to determine the platform type.
+ */
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ ipmi_close_();
+ goto do_exit;
+ } else {
+ char *pstr;
+ int vendid;
+ ushort prodid;
+ uchar j;
+
+ if (fdebug) {
+ printf("devid: ");
+ for (j = 0; j < 16; j++) printf("%02x ",devrec[j]);
+ printf("\n");
+ }
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ vendid = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ if (mfg == 0) memcpy(iana,&devrec[6],3); /*not set, use default*/
+ prodid = devrec[9] + (devrec[10] << 8);
+ pstr = "BMC";
+ if (fdebug) printf("vendor = %06x, product_id = %04x\n",vendid,prodid);
+ if (vendid == VENDOR_NSC) { /* NSC mBMC */
+ pstr = "mBMC";
+ platform = platMBMC;
+ } else if (vendid == VENDOR_HP) { /* HP */
+ platform = platOther; /* other platform types */
+ gbootparm = 0x00;
+ fignore_opterr = 1; /* ignore boot options errors */
+ } else if (vendid == VENDOR_TYAN) { /* Tyan */
+ platform = platOther; /* other platform types */
+ fignore_opterr = 1; /* ignore boot options errors */
+ } else if (vendid == VENDOR_INTEL) { /* Intel */
+ if (prodid != 0x0100) /* ia64 Itanium2 is different */
+ platform = platIntel; /* else handle as Intel Sahalee */
+ if (is_romley(vendid,prodid) || (prodid == 0x003E)) {
+ /* Romley or Thurley/S5520UR */
+ platform = platS5500; /* not like Intel Sahalee */
+ set_max_kcs_loops(URNLOOPS); /*longer KCS timeout*/
+ }
+ } else if (vendid == VENDOR_KONTRON) { /* Kontron */
+ fignore_opterr = 1; /* ignore boot options errors */
+ /* supports Chassis Soft Power command 0x05, so not platIntel */
+ platform = platOther; /* handle like other platforms */
+ } else { /* other vendors */
+ platform = platOther; /* other platform types */
+ }
+ printf("-- %s version %x.%x, IPMI version %d.%d \n",
+ pstr, devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+
+ { /* show current power state */
+ char *pstr;
+ uchar pstate;
+ rlen = sizeof(devrec);
+ ret = ipmi_cmdraw( GET_POWER_STATE, NETFN_APP,
+ g_sa, g_bus, g_lun,
+ NULL,0, devrec,&rlen,&cc, fdebug);
+ if (ret == 0) {
+ pstate = devrec[0] & 0x7f;
+ switch(pstate) {
+ case 0x00: pstr = "S0: working"; break;
+ case 0x01: pstr = "S1: clock stopped, context ok"; break;
+ case 0x02: pstr = "S2: clock stopped, context lost"; break;
+ case 0x03: pstr = "S3: suspend-to-RAM"; break;
+ case 0x04: pstr = "S4: suspend-to-Disk"; break;
+ case 0x05: pstr = "S5: soft off"; break;
+ case 0x06: pstr = "S4/S5: soft off, either S4 or S5"; break;
+ case 0x07: pstr = "G3: mechanical off"; break;
+ case 0x08: pstr = "S1-S3: sleeping"; break;
+ case 0x09: pstr = "S1-S4: sleeping"; break;
+ case 0x0A: pstr = "S5/o: soft off by override"; break;
+ case 0x20: pstr = "legacy on"; break;
+ case 0x21: pstr = "legacy soft-off"; break;
+ default: pstr = "unknown"; break;
+ }
+ if (cc == 0)
+ printf("Power State = %02x (%s)\n",pstate,pstr);
+ }
+ }
+
+ if (breset == 7) { /*do Cold Reset */
+ printf("%s: %s ...\n",progname,reset_str(breset,bopt));
+ rslen = sizeof(rsdata);
+ ret = ipmi_cmdraw( 0x02, NETFN_APP, g_sa, g_bus, g_lun,
+ rqdata,0, rsdata, &rslen, &cc, fdebug);
+ if (fdebug)
+ printf("cold_reset(%02x) ret=%d cc=%x, rslen=%d\n",g_sa,ret,cc,rslen);
+ if (ret == 0) ret = cc;
+ if (ret == 0)
+ printf("%s: Cold_Reset ok\n",progname);
+ else
+ printf("%s: Cold_Reset error %d\n",progname,ret);
+ ipmi_close_();
+
+ } else if (fshutdown && fipmilan && (platform == platIntel)) { /*soft reset*/
+ int fdaemonok = 0;
+ /* Either do special remote soft-shutdown, or
+ * handle it within IPMI_Reset. */
+ /* Special remote soft-shutdown, requires a service to
+ * be running on the target node.
+ * GET_SOFTWARE_ID == 0x00
+ * SMS_OS_REQUEST == 0x10 : (down=0, reset=1)
+ * BRIDGE_REQUEST == 0x20 : (down=0, reset=1)
+ * SMS_SA == 0x81
+ */
+ rslen = sizeof(rsdata);
+ ret = ipmi_cmdraw( 0x00, NETFN_APP,sms_sa,PUBLIC_BUS, SMS_LUN,
+ rqdata,0, rsdata, &rslen, &cc, fdebug);
+ if (fdebug)
+ printf("ipmilan getswid ret=%d cc=%x, rslen=%d\n",ret,cc,rslen);
+ if (ret == 0 && cc == 0) {
+ ushort v,x;
+ v = (rsdata[6] << 16) + (rsdata[7] << 8) + rsdata[8];
+ x = (rsdata[9] << 8) + rsdata[10];
+ if (fdebug) printf("swid v: %06x x: %04x\n",v,x);
+ if (v == 0x000157 && x == 0x0001) fdaemonok = 1;
+ }
+ if (fdaemonok) {
+ /* os_usleep(0,50000); *delay 50 ms, not needed*/
+ if (breset == 0 || breset == 6)
+ rqdata[0] = 0x01; /* shutdown & power down */
+ else rqdata[0] = 0x02; /* shutdown & reset */
+ if (fdebug) printf("ipmilan shutdown action=%x\n",rqdata[0]);
+ rslen = sizeof(rsdata);
+ ret = ipmi_cmdraw( SMS_OS_REQUEST, NETFN_APP,sms_sa,PUBLIC_BUS,SMS_LUN,
+ rqdata,1, rsdata, &rslen, &cc, fdebug);
+ printf("ipmilan shutdown request: ret = %d, cc = %x\n", ret,cc);
+ if (fipmilan && fwait) {
+ ipmi_close_(); /* to try new connection */
+ wait_ready();
+ }
+ }
+ else printf("ipmilan async bridge agent not present\n");
+ ipmi_close_();
+ } else {
+ printf("%s: %s ...\n",progname,reset_str(breset,bopt));
+ ret = IPMI_Reset(breset,bopt);
+ if (ret == 0) { /* if ok */
+ printf("%s: IPMI_Reset ok\n",progname);
+ /* It starts resetting by this point, so do not close. */
+ if (breset == 4) ipmi_close_(); /*NMI, so close*/
+ if (fipmilan && fwait) {
+ ipmi_close_(); /* to try new connection */
+ wait_ready();
+ ipmi_close_();
+ }
+ } else {
+ printf("%s: IPMI_Reset error %d\n",progname,ret);
+ ipmi_close_();
+ }
+ }
+do_exit:
+ // show_outcome(progname,ret);
+ return(ret);
+} /* end main()*/
+
+/* end ireset.c */
diff --git a/util/isel.c b/util/isel.c
new file mode 100644
index 0000000..c974b24
--- /dev/null
+++ b/util/isel.c
@@ -0,0 +1,884 @@
+/*
+ * isel.c (was showsel.c)
+ *
+ * This tool reads the firmware System Event Log records via IPMI commands.
+ * It can use either the Intel /dev/imb driver or VALinux /dev/ipmikcs.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * Copyright (c) 2001-2005 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ * Copyright (c) 2013 Andy Cress <arcress at users.sourceforge.net>
+ *
+ * 10/16/01 Andy Cress - created
+ * 10/19/01 Andy Cress - added text for Sensor Types from Table 36-3
+ * 10/24/01 Andy Cress - added panic string display for OS Crit Stop
+ * 11/01/01 Andy Cress - added logic to write SEL records to syslog
+ * 11/15/01 Andy Cress - added logic for more description strings
+ * 01/31/02 Andy Cress - isolated dependencies on /dev/imb to ipmi_cmd_ia(),
+ * added ipmi_cmd_va() for va ipmi driver also,
+ * added posterrs array for more descriptions.
+ * 02/06/02 Andy Cress - fixed bug 279 (extra debug msg at EOF).
+ * 03/25/02 Andy Cress - show free space, add -c to clear SEL.
+ * 04/11/02 Andy Cress - decode timestamp into readable form
+ * 06/14/02 Andy Cress - also show status error in ClearSEL
+ * 07/02/02 Andy Cress v1.3 add more Usage text
+ * 08/02/02 Andy Cress v1.4 moved common ipmi_cmd() code to ipmicmd.c
+ * 10/07/02 Andy Cress v1.5 added -v option with BMC version too
+ * 01/16/03 Andy Cress v1.6 Handle new OS crit stop format with die code
+ * 01/29/03 Andy Cress v1.7 added MV OpenIPMI support
+ * 02/05/03 Andy Cress v1.8 show better message if empty SEL (cc=0xCB),
+ * show an additional warning if free space is low.
+ * 02/18/03 Andy Cress v1.9 trim out some fields so it fits on 1 line,
+ * decode Boot Event subcodes
+ * 02/27/03 Andy Cress v1.10 change OS Crit Stop decoding to handle new types
+ * 03/20/03 Andy Cress v1.11 for -w, save id also, so we don't have to start
+ * over at the beginning each time.
+ * 04/30/03 Andy Cress v1.12 changed display ordering.
+ * 06/23/03 Andy Cress v1.13 fix -w if log gets cleared
+ * 08/19/03 Andy Cress v1.14 handle OEM/other record types
+ * 09/16/03 Andy Cress v1.15 added more sens_desc strings
+ * 10/03/03 Andy Cress v1.16 added more sens_desc strings (for boot)
+ * 01/19/04 Andy Cress v1.17 added more sens_desc for Fans
+ * 01/30/04 Andy Cress v1.18 added WIN32 flags, and sens_desc for Voltage
+ * 03/12/04 Andy Cress v1.19 ClockSync description changed
+ * 03/29/04 Andy Cress v1.20 change pattern matching for thresholds,
+ * added sens_desc for ID Button
+ * check either time or record_id if fwritesel
+ * show warning if <20% free also
+ * added sens_desc for System Events, HSC, Power, Int
+ * 04/13/04 Andy Cress v1.21 added threshold OK descriptions,
+ * change header (time is local, not GMT)
+ * 05/05/04 Andy Cress v1.22 call ipmi_close before exit,
+ * include ReportEvent code for WIN32
+ * 06/10/04 Andy Cress v1.23 use gmtime instead of localtime for WIN32
+ * 08/16/04 Andy Cress v1.24 added more decoding for Power events
+ * 09/20/04 Andy Cress v1.25 added 2 event descriptors for ia64 platforms
+ * 11/01/04 Andy Cress v1.26 add -N / -R for remote nodes
+ * 11/16/04 Andy Cress v1.27 add -U for username,
+ * added more decoding for mBMC watchdog events
+ * 11/19/04 Andy Cress v1.28 added more decoding for crit_int, slots, etc.
+ * changed firmware error decoding.
+ * 02/17/05 Andy Cress v1.29 made decode_sel_entry() a subroutine,
+ * added logic for OEM 0xc0 record types.
+ * 05/24/05 Andy Cress v1.30 fixed SegFault with StartWriting/fscanf
+ * 05/26/05 Andy Cress v1.31 moved decode_sel_entry to events.c
+ * 08/01/05 Andy Cress v1.32 updated events.c for PowerUnit & Battery
+ * 09/12/05 Andy Cress v1.33 dont check superuser for fipmi_lan
+ * 06/29/06 Andy Cress v1.34 added -l option
+ * 02/06/08 Andy Cress v2.8 make sure savid for -w is unsigned
+ */
+/*M*
+Copyright (c) 2002-2005, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#ifdef WIN32
+#include <windows.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <syslog.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <time.h>
+
+#include "ipmicmd.h"
+
+#define SELprintf printf
+#define ETYPE_CRITSTOP 0x20
+#define RTYPE_OEM2 0xe0 /* 2nd OEM type (range) */
+
+#pragma pack(1)
+typedef struct
+{
+ ushort record_id;
+ uchar record_type;
+ uint timestamp;
+ ushort generator_id; /*slave_addr/channel*/
+ uchar evm_rev; //event message revision
+ uchar sensor_type;
+ uchar sensor_number;
+ uchar event_trigger;
+ uchar event_data1;
+ uchar event_data2;
+ uchar event_data3;
+} SEL_RECORD;
+#pragma pack()
+
+#define MIN_FREE 128 /*=8*16, minimal bytes of free SEL space */
+#define REC_SIZE 16 /*SEL Record Size, see IPMI 1.5 Table 26-1 */
+#define RECORD_BASE 2 //base value to the SEL record in IMB resp data
+#define RID_OFFSET 0 //byte offset to the record id
+#define RTYPE_OFFSET 2 //byte offset to the record type
+#define RTS_OFFSET 3 //byte offset to the record timestamp
+#define RGID_OFFSET 7 //byte offset to the record generator id
+#define REREV_OFFSET 9 //byte offset to the record event message rev
+#define RSTYPE_OFFSET 10 //byte offset to the record sensor type
+#define RSN_OFFSET 11 //byte offset to the record sensor number
+#define RET_OFFSET 12 //byte offset to the record event trigger
+#define RDATA_OFFSET 13 //byte offset to the record event data
+
+static char *progname = "isel";
+static char *progver = "2.93";
+#ifdef WIN32
+#define IDXFILE "sel.idx"
+static char idxfile[80] = IDXFILE;
+static char idxfile2[80] = "%ipmiutildir%\\sel.idx";
+#else
+static char idxfile[80] = "/var/lib/ipmiutil/sel.idx";
+static char idxfile2[80] = "/usr/share/ipmiutil/sel.idx"; /*old location*/
+#endif
+static char fdebug = 0;
+static char fall = 1;
+static char futc = 0;
+static char fwritesel = 0;
+static char fshowraw = 0;
+static char fdecoderaw = 0;
+static char fdecodebin = 0;
+static char fclearsel = 0;
+static char faddsel = 0;
+static char fonlyver = 0;
+static char flastrecs = 0;
+static char fremote = 0;
+static char fsensdesc = 0;
+static char fcanonical = 0;
+static char fset_mc = 0;
+static uchar min_sev = 0; /*only show sev >= this value [0,1,2,3]*/
+static char *addstr = NULL;
+static char *addhex = NULL;
+static uint savtime = 0;
+static ushort savid = 0;
+static int nlast = 20;
+static ushort idinc = REC_SIZE;
+static char *rawfile = NULL;
+static int vend_id, prod_id;
+static uchar *sdrs = NULL;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+/*------------------------------------------------------------------------
+ * decode_sel_entry
+ * Parse and decode the SEL record into readable format.
+ * See ievents.c
+ *------------------------------------------------------------------------*/
+extern char *evt_hdr;
+extern char *evt_hdr2;
+extern int decode_sel_entry( uchar *psel, char *outbuf, int sz);
+extern int decode_raw_sel( char *raw_file, int mode);
+extern void set_sel_opts(int sensdsc, int canon, void *sdrs, char fdbg, char u);
+extern int get_sdr_cache( uchar **sdrs);
+extern void free_sdr_cache( uchar *sdrs);
+extern uchar find_msg_sev(char *msgbuf); /* subs.c*/
+extern int OpenSyslog(char *tag); /*see subs.c*/
+extern void CloseSyslog(void); /*see subs.c*/
+extern void WriteSyslog(char *msgbuf); /*see subs.c*/
+extern int write_syslog(char *msg); /*see subs.c*/
+
+/*F*
+////////////////////////////////////////////////////////////////////////////////
+// GetSelEntry
+////////////////////////////////////////////////////////////////////////////////
+// Name : GetSelEntry
+//
+// Purpose : This routine gets the next SEL record
+//
+// Parameters :
+// pRecordID : input/output pointer to next Record ID
+// selRecord : output pointer to the sel record
+//
+// Returns : 0 if success
+// -1 if last record.
+// -2 if completion code error.
+// -3 if null buffer on input.
+// -4 if record id mismatch.
+//
+// Notes : uses ipmi_cmd()
+//
+*F*/
+int GetSelEntry(ushort *pRecordID, SEL_RECORD *selRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[6];
+ uchar completionCode;
+ char* cpRecordID; //for next record id
+ ushort inRecordID; //save the input record id
+
+ inRecordID = *pRecordID;
+ if (!selRecord)
+ {
+ if (fdebug)
+ SELprintf("GetSelEntry: error, output buffer is NULL\n");
+ return -3;
+ }
+
+ //set the reservation id to zero
+ inputData[0] = 0;
+ inputData[1] = 0;
+
+ //set the record id to get
+ cpRecordID = (char*) pRecordID;
+ inputData[2] = cpRecordID[0];
+ inputData[3] = cpRecordID[1];
+
+ //set the offset to the record to value zero
+ inputData[4] = 0;
+
+ //set the number of byte to read. 0xFF means read the entire record
+ inputData[5] = (char) 0xFF;
+
+ status = ipmi_cmd(GET_SEL_ENTRY, inputData, 6, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (completionCode == 0xCB && inRecordID == 0)
+ SELprintf("Firmware Log (SEL) is empty\n");
+ else
+ SELprintf("GetSelEntry[%x]: completion code=%x\n",
+ inRecordID,completionCode); // responseData[0]);
+ } else {
+ //successful, done
+
+ //save the next SEL record id
+ cpRecordID[0] = responseData[0];
+ cpRecordID[1] = responseData[1];
+
+ //save the SEL record content
+ //(note that selRecord structure must be pragma_pack'd)
+ memcpy(selRecord,&responseData[RECORD_BASE],16);
+
+ if (inRecordID == 0 || inRecordID == selRecord->record_id)
+ {
+ /* We return success if the input record is
+ begin-of-SEL (value 0), or
+ input and output record id matches.
+ */
+ return 0;
+ }
+ else
+ {
+ /* If last record, inRecordID will be -1 from
+ response data, so return -1 as normal EOF.
+ (fix to bug 279)
+ */
+ if (inRecordID == 0xFFFF) return(-1);
+ /* If not last record, this is an error. */
+ if (fdebug)
+ SELprintf("GetSelEntry: input id %d != output id %d \n", inRecordID, selRecord->record_id);
+ *pRecordID = inRecordID; //restore the input record id
+ return -4;
+ }
+ }
+ }
+
+ // we are here because after the retry, completionCode is not COMPLETION_CODE_OK
+
+ if (fdebug)
+ SELprintf("GetSelEntry: ipmi_cmd error %d completion code, code=%d\n", status,completionCode);
+ return -2;
+
+} /* end GetSelEntry() */
+
+int AddSelEntry(uchar *selrec, int ilen)
+{
+ uchar rdata[MAX_BUFFER_SIZE];
+ int rlen = MAX_BUFFER_SIZE;
+ uchar idata[16];
+ uchar ccode;
+ int rv;
+
+ /* Do not use AddSelEntry unless there is a legitimate
+ hardware-related event. */
+ memset(idata,0,16);
+ if (ilen > 16) ilen = 16;
+ memcpy(idata,selrec,ilen);
+ rv = ipmi_cmdraw(0x44, NETFN_STOR, g_sa, g_bus, g_lun,
+ idata, 16, rdata, &rlen, &ccode, fdebug);
+ return (rv);
+}
+
+int get_sel_time_utc_offset(short *offset)
+{
+ uchar rdata[MAX_BUFFER_SIZE];
+ int rlen = MAX_BUFFER_SIZE;
+ uchar idata[16];
+ uchar ccode;
+ int rv;
+
+ if (offset == NULL) return(-1);
+ *offset = 0;
+ rv = ipmi_cmdraw(0x5C, NETFN_STOR, g_sa, g_bus, g_lun,
+ idata, 0, rdata, &rlen, &ccode, fdebug);
+ if (rv == 0) rv = ccode;
+ if (rv == 0) *offset = rdata[0] + (rdata[1] << 8);
+ return (rv);
+}
+
+void StartWriting(uint *plasttime, ushort *plastid)
+{
+ FILE *fd;
+ uint lasttime;
+ uint lastid;
+ int ret = -1;
+
+ lasttime = 0;
+ lastid = 0;
+ // Open the index file
+ fd = fopen(idxfile,"r");
+ if (fd == NULL) fd = fopen(idxfile2,"r");
+ if (fd != NULL) {
+ // Read the file, get savtime & savid
+ ret = fscanf(fd,"%x %x",&lasttime,&lastid);
+ fclose(fd);
+ }
+ else printf("StartWriting: cannot open %s\n",idxfile);
+ if (fdebug) printf("StartWriting: idx fd=%p, savtime=%x, savid=%x\n",
+ fd,lasttime,(ushort)lastid);
+ *plasttime = lasttime;
+ *plastid = (ushort)lastid;
+
+ ret = OpenSyslog("SEL");
+ if (fdebug) printf("StartWriting: ret = %d\n",ret);
+ return;
+}
+
+void StopWriting(uint lasttime, ushort lastid)
+{
+ FILE *fd;
+ // Rewrite the saved time & record id
+ fd = fopen(idxfile,"w");
+ if (fd != NULL) {
+ fprintf(fd,"%x %x\n",lasttime,lastid);
+ fclose(fd);
+ }
+ else printf("StopWriting: cannot open %s\n",idxfile);
+ CloseSyslog();
+ return;
+}
+
+int ClearSEL(void)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[6];
+ uchar completionCode;
+ ushort cmd;
+
+ cmd = RESERVE_SEL; /*0x0A42*/
+ status = ipmi_cmd(cmd, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK && completionCode == 0) {
+ cmd = CLEAR_SEL; /*0x0A47*/
+ inputData[0] = responseData[0]; /*Reservation ID [0]*/
+ inputData[1] = responseData[1]; /*Reservation ID [1]*/
+ inputData[2] = 'C';
+ inputData[3] = 'L';
+ inputData[4] = 'R';
+ inputData[5] = 0xAA; /* initiate erase */
+ status = ipmi_cmd(cmd, inputData, 6, responseData,
+ &responseLength, &completionCode, fdebug);
+ /* The reservation is cancelled by the CLEAR_SEL cmd */
+ }
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("ClearSEL: cmd = %x, completion code=%x\n",
+ cmd,completionCode);
+ status = completionCode;
+ } else {
+ /* Successful, done. */
+ SELprintf("ClearSEL: Log Cleared successfully\n");
+ }
+ } else {
+ SELprintf("ClearSEL: cmd = %x, error status = %d\n",
+ cmd,status);
+ }
+ if (fwritesel) { /* this won't always be enough, but try */
+ StartWriting(&savtime,&savid);
+ savid = 0;
+ StopWriting(savtime,savid);
+ }
+ return(status);
+} /* ClearSEL()*/
+
+
+void ReadSEL(uchar mytype, char fwriteit)
+{
+ ushort RecordID = 0; /* 0 = first record, 0xFFFF = end */
+ SEL_RECORD selRecord;
+ SEL_RECORD *pSelRecord = &selRecord;
+ char output[160];
+ int rc = 0;
+ int ilast = 0;
+ short recid0;
+ uchar *bsel;
+ uchar sev;
+ char fskipit = 0;
+
+ if (fwriteit) {
+ StartWriting(&savtime,&savid);
+ RecordID = savid;
+ }
+ memset(pSelRecord, 0, sizeof(SEL_RECORD));
+ if (flastrecs) {
+ /* read the first two records to get the record id increment */
+ RecordID = 0;
+ rc = GetSelEntry( &RecordID, pSelRecord);
+ recid0 = pSelRecord->record_id;
+ rc = GetSelEntry( &RecordID, pSelRecord);
+ if (rc == 0) idinc = pSelRecord->record_id - recid0;
+ else { idinc = recid0; rc = 0; }
+ RecordID = 0xFFFF; /* -1=0xFFFF; * get last record */
+ if (fdebug) printf("recid inc = 0x%02x (%x - %x)\n",idinc,
+ pSelRecord->record_id,recid0);
+ }
+ set_sel_opts(fsensdesc, fcanonical, sdrs, fdebug,futc);
+ if (futc) { /*Try to get the UTC offset*/
+ short utc_off;
+ printf("Showing SEL Time as UTC\n");
+ rc = get_sel_time_utc_offset(&utc_off);
+ if (rc == 0) {
+ printf("SEL Time UTC Offset = %d\n",utc_off);
+ } else rc = 0; /*may fail if not supported, but ok*/
+ }
+ /* show header for the SEL records */
+ if (fcanonical)
+ printf("%s",evt_hdr2); /*RecId | Date/Time */
+ else printf("%s",evt_hdr); /*RecId Date/Time_______ */
+ while( rc == 0 ) {
+ rc = GetSelEntry( &RecordID, pSelRecord);
+ if (fwriteit && (rc != 0) && (RecordID == savid)) {
+ /* If here, log was probably cleared, so try
+ * again from the log start. */
+ RecordID = 0;
+ rc = GetSelEntry( &RecordID, pSelRecord);
+ }
+ if (fdebug) printf("rc = %d, recid = %04x, next = %04x\n",
+ rc, pSelRecord->record_id, RecordID);
+ if (flastrecs && (ilast == 0) && (rc == -1)) rc = 0;
+ if (rc != 0) { /* EOF or error */ break; }
+
+ if (fshowraw) {
+ bsel = (uchar *)&selRecord;
+ sprintf(output,"%02x %02x %02x %02x %02x %02x %02x %02x "
+ "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+ bsel[0], bsel[1], bsel[2], bsel[3],
+ bsel[4], bsel[5], bsel[6], bsel[7],
+ bsel[8], bsel[9], bsel[10], bsel[11],
+ bsel[12], bsel[13], bsel[14], bsel[15]);
+ printf("%s", output);
+ } else {
+ if (mytype == 0xff || pSelRecord->sensor_type == mytype) {
+ /* show all records, or type matches */
+ decode_sel_entry((uchar *)pSelRecord,output, sizeof(output));
+ fskipit = 0;
+ if (min_sev > 0) {
+ sev = find_msg_sev(output);
+ if (fdebug) printf("min_sev=%d, sev=%d\n",min_sev,sev);
+ if (sev < min_sev) fskipit = 1;
+ }
+ if (!fskipit) printf("%s", output);
+ } else if ((mytype == ETYPE_CRITSTOP) &&
+ (pSelRecord->record_type >= RTYPE_OEM2)) {
+ /* if showing panics only, also show its oem records */
+ decode_sel_entry((uchar *)pSelRecord,output,sizeof(output));
+ printf("%s", output);
+ } else {
+ if (fdebug) printf("decoding error, mytype = %d\n",mytype);
+ output[0] = 0;
+ }
+ }
+
+ if (fwriteit) {
+ /* Only write newer records to syslog */
+ if (pSelRecord->record_type == 0x02) {
+ if ((pSelRecord->timestamp > savtime) ||
+ (pSelRecord->record_id > savid)) {
+ WriteSyslog(output);
+ savid = pSelRecord->record_id;
+ savtime = pSelRecord->timestamp;
+ }
+ } else { /* no timestamp */
+ if (pSelRecord->record_id > savid) {
+ WriteSyslog(output);
+ savid = pSelRecord->record_id;
+ }
+ }
+ } /*endif writeit*/
+ if( pSelRecord->record_id == 0xFFFF )
+ break;
+ if( RecordID == pSelRecord->record_id )
+ break;
+ if (flastrecs) {
+ ++ilast;
+ if (fdebug) printf("ilast = %d, next = %x, id = %x\n",
+ ilast,RecordID,pSelRecord->record_id);
+ if (ilast >= nlast) break;
+ RecordID = pSelRecord->record_id - idinc;
+ if (RecordID > pSelRecord->record_id) break;
+ if (RecordID == 0) break;
+ }
+ memset(pSelRecord, 0, sizeof(SEL_RECORD));
+ } /*endwhile*/
+ if (fwriteit) StopWriting(savtime,savid);
+} /* end ReadSEL()*/
+
+static uint vfree = 0;
+static uint vused = 0;
+static uint vtotal = 0;
+static uint vsize = REC_SIZE;
+
+static int ReadSELinfo()
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar completionCode;
+ uchar inputData[6];
+ uchar b;
+ char *strb;
+
+ status = ipmi_cmd(GET_SEL_INFO, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+ if (fdebug) printf("GetSelInfo status = %x, cc = %x\n",
+ status,completionCode);
+
+ if ((status == ACCESS_OK) && (completionCode == 0)) {
+ vfree = responseData[3] + (responseData[4] << 8); // in Bytes
+ vused = responseData[1] + (responseData[2] << 8); // in Entries/Allocation Units
+ vtotal = vused + (vfree/vsize); // vsize from AllocationInfo
+ b = responseData[13];
+ if (b & 0x80) strb = " overflow"; /*SEL overflow occurred*/
+ else strb = "";
+ if (b & 0x1) { // Get SEL Allocation Info supported
+ status = ipmi_cmd(GET_SEL_ALLOCATION_INFO, inputData, 0,
+ responseData, &responseLength,
+ &completionCode, fdebug);
+ if (fdebug) printf("GetSelInfo status = %x, cc = %x\n",
+ status,completionCode);
+ if ((status == ACCESS_OK) && (completionCode == 0)) {
+ vsize = responseData[2] + (responseData[3] << 8);
+ if (vsize == 0) vsize = REC_SIZE;
+ vtotal = responseData[0] + (responseData[1] << 8);
+ }
+ }
+
+ if (fcanonical)
+ SELprintf("SEL %s Size = %d records (Used=%d, Free=%d)\n",
+ strb, vtotal, vused, vfree/vsize );
+ else
+ SELprintf("SEL Ver %x Support %02x%s, Size = %d records (Used=%d, Free=%d)\n",
+ responseData[0],
+ b, strb,
+ vtotal,
+ vused,
+ vfree/vsize );
+ //successful, done
+ return(0);
+ } else {
+ vfree = MIN_FREE * 2; /*sane values to avoid SEL full warning*/
+ vused = 0;
+ vtotal = vused + (vfree/vsize);
+ return(1);
+ }
+
+} /*end ReadSELinfo()*/
+
+
+#ifdef ALONE
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#else
+/* METACOMMAND */
+int i_sel(int argc, char **argv)
+#endif
+{
+ int ret = -1;
+ char DevRecord[16];
+ int c;
+ char *s1;
+
+ printf("%s: version %s\n",progname,progver);
+ while ((c = getopt(argc,argv,"a:b:cdef:h:l:m:nprs:uwvx:T:V:J:EYF:P:N:U:R:Z:?")) != EOF)
+ switch(c) {
+ case 'a': faddsel = 1; /*undocumented option, to prevent misuse*/
+ addstr = optarg; /*text string, max 13 bytes*/
+ break;
+ case 'h': faddsel = 1; /*undocumented option, to prevent misuse*/
+ addhex = optarg; /*string of 16 hex characters, no spaces*/
+ break;
+ case 'b': fdecodebin = 1;
+ rawfile = optarg;
+ break;
+ case 'd': fclearsel = 1; break; /*delete/clear SEL*/
+ case 'e': fsensdesc = 1; break; /*extended sensor descriptions*/
+ case 'f': fdecoderaw = 1;
+ rawfile = optarg;
+ break;
+ case 'l': flastrecs = 1;
+ nlast = atoi(optarg);
+ break;
+ case 'm': /* specific MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'c':
+ case 'n': fcanonical = 1; /*parse easier, canonical*/
+ fsensdesc = 1; /*extended sensor descriptions*/
+ /* Note that this option does not show event data bytes */
+ break;
+ case 'p': fall = 0; break; /*crit stop (panic) only*/
+ case 'r': fshowraw = 1; break;
+ case 's': min_sev = atob(optarg); break; /*show sev >= value*/
+ case 'u': futc = 1; break;
+ case 'v': fonlyver = 1; break;
+ case 'w': fwritesel = 1; break;
+ case 'x': fdebug = 1; break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-bcdefmnprsuvwx] [-l 5] [-NUPREFTVY]\n",
+ progname);
+ printf(" -b interpret Binary file with raw SEL data\n");
+ printf(" -c Show canonical output with delimiters\n");
+ printf(" -d Delete, Clears all SEL records\n");
+ printf(" -e shows Extended sensor description if run locally\n");
+ printf(" -f interpret File with ascii hex SEL data\n");
+ printf(" -l5 Show last 5 SEL records (reverse order)\n");
+ printf(" -r Show uninterpreted raw SEL records in ascii hex\n");
+ printf(" -n Show nominal/canonical output (same as -c)\n");
+ printf(" -p Show only Panic/Critical Stop records\n");
+ printf(" -s1 Show only Severity >= value (0,1,2,3)\n");
+ printf(" -u use raw UTC time\n");
+ printf(" -v Only show version information\n");
+ printf(" -w Writes new SEL records to syslog\n");
+ printf(" -x Display extra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+ if (fwritesel && flastrecs) {
+ printf("Error: Options -l and -w are incompatible\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+
+ /* Handle simple decoding options -f, -b */
+ if (fdecoderaw) { /* -f */
+ ret = decode_raw_sel(rawfile,1);
+ goto do_exit;
+ } else if (fdecodebin) { /* -b */
+ ret = decode_raw_sel(rawfile,2);
+ goto do_exit;
+ }
+
+ // if (fwrite) fall = 1; // would we ever set fwrite without fall??
+#ifdef WIN32
+ fremote = is_remote();
+ if (fwritesel) { /*resolve path of idxfile*/
+ char *ipath;
+ ipath = getenv("ipmiutildir"); /*ipmiutil directory path*/
+ if (ipath != NULL) {
+ if (strlen(ipath)+8 < sizeof(idxfile)) {
+ sprintf(idxfile,"%s\\%s",ipath,"\\",IDXFILE);
+ }
+ }
+ }
+#elif defined(DOS)
+ fremote = 0;
+#else
+ /* Linux, BSD, Solaris */
+ fremote = is_remote();
+ if (fremote == 0) {
+ //uchar guid[16];
+ //char gstr[36];
+ /* only run this as superuser */
+ ret = geteuid();
+ if (ret > 1) {
+ printf("Not superuser (%d)\n", ret);
+ ret = ERR_NOT_ALLOWED;
+ goto do_exit;
+ }
+ }
+#endif
+ if (fremote) { /*remote, ipmi lan, any OS*/
+ char *node;
+ node = get_nodename();
+ strcat(idxfile,"-");
+ strcat(idxfile,node);
+ strcat(idxfile2,"-");
+ strcat(idxfile2,node);
+ }
+#ifdef REMOVABLE
+ else {
+ // if removable media, may need to add uniqueness to local file.
+ ret = get_SystemGuid(guid);
+ if (ret == 0) {
+ sprintf(gstr,"%02X%02X%02X%02X%02X%02X%02X%02X",
+ guid[8], guid[9], guid[10], guid[11],
+ guid[12], guid[13], guid[14], guid[15]);
+ strcat(idxfile,"-");
+ strcat(idxfile,gstr);
+ strcat(idxfile2,"-");
+ strcat(idxfile2,gstr);
+ }
+ }
+#endif
+ if (fremote) {
+ if (faddsel || fclearsel)
+ parse_lan_options('V',"4",0); /*admin priv to clear*/
+ }
+
+ if (faddsel) { /* -a, Add a custom SEL record */
+ /* use this sparingly, only for hardware-related events. */
+ char buf[16];
+ int i, len = 0;
+ buf[0] = 0;
+ buf[1] = 0;
+ if (addstr != NULL) { /*ASCII text string*/
+ buf[2] = 0xf1; /*use SEL type OEM 0xF1*/
+ len = strlen_(addstr);
+ if (len > 13) len = 13;
+ if (len <= 0) ret = LAN_ERR_TOO_SHORT;
+ else memcpy(&buf[3],addstr,len);
+ len += 3;
+ }
+ if (addhex != NULL) { /*string of hex characters, no spaces*/
+ len = strlen_(addhex);
+ if (len < 32) ret = LAN_ERR_TOO_SHORT;
+ else {
+ for (i=2; i<16; i++)
+ buf[i] = htoi(&addhex[i*2]);
+ }
+ len = 16;
+ }
+ if (fdebug) {
+ printf("Ready to AddSelEntry: ");
+ for (i=0; i<16; i++) printf("%02x ",buf[i]);
+ printf("\n");
+ }
+ if (ret == 0)
+ ret = AddSelEntry(buf, len);
+ printf("AddSelEntry ret = %d\n",ret);
+ goto do_exit;
+ }
+
+ ret = ipmi_getdeviceid( DevRecord, sizeof(DevRecord),fdebug);
+ if (ret == 0) {
+ uchar ipmi_maj, ipmi_min;
+ ipmi_maj = DevRecord[4] & 0x0f;
+ ipmi_min = DevRecord[4] >> 4;
+ show_devid( DevRecord[2], DevRecord[3], ipmi_maj, ipmi_min);
+ prod_id = DevRecord[9] + (DevRecord[10] << 8);
+ vend_id = DevRecord[6] + (DevRecord[7] << 8) + (DevRecord[8] << 16);
+ if (vend_id == VENDOR_INTEL) {
+ if (prod_id == 0x003E) /*Urbanna NSN2U or CG2100*/
+ set_max_kcs_loops(URNLOOPS); /*longer KCS timeout*/
+ }
+ } else {
+ goto do_exit;
+ }
+
+ ret = ReadSELinfo();
+ if (ret == 0 && !fonlyver) {
+ if (fclearsel) {
+ ret = ClearSEL();
+ } else {
+ if (fsensdesc) {
+ if (fdebug) printf("%s: fetching SDRs ...\n",progname);
+ ret = get_sdr_cache(&sdrs);
+ if (fdebug) printf("%s: get_sdr_cache ret = %d\n",progname,ret);
+ ret = 0; /*if error, keep going anyway*/
+ }
+ if (fdebug) printf("%s: starting ReadSEL ...\n",progname);
+ if (fall) ReadSEL(0xff,fwritesel); /* show all SEL records */
+ else ReadSEL(ETYPE_CRITSTOP,fwritesel); /* only show OS Crit Stops*/
+ /* PEF alerts and other log messages fail if low free space,
+ so show a warning. */
+ if (vfree < MIN_FREE) {
+ printf("WARNING: free space is very low (=%d), need to clear with -c\n",
+ vfree);
+ } else if ((vfree/vsize) < ((vtotal * 20)/100)) {
+ printf("WARNING: free space is low (=%d), need to clear with -c\n",
+ vfree);
+ }
+ }
+ }
+do_exit:
+ free_sdr_cache(sdrs);
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return(ret);
+}
+
+/* end isel.c */
diff --git a/util/iseltime.c b/util/iseltime.c
new file mode 100644
index 0000000..2562202
--- /dev/null
+++ b/util/iseltime.c
@@ -0,0 +1,260 @@
+/*
+ * iseltime.c
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ *
+ * 05/11/09 Andy Cress v1.0 - created
+ * 07/23/10 Andy Cress v1.1 - always show System time also
+ * 08/20/10 Andy Cress v1.2 - show/set RTC time also if Linux
+ */
+/*M*
+Copyright (c) 2013, Andy Cress
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include "getopt.h"
+#elif defined(EFI)
+ // EFI: defined (EFI32) || defined (EFI64) || defined(EFIX64)
+ #ifndef NULL
+ #define NULL 0
+ #endif
+ #include <types.h>
+ #include <libdbg.h>
+ #include <unistd.h>
+ #include <errno.h>
+#elif defined(DOS)
+ #include <dos.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "getopt.h"
+#else
+/* Linux, Solaris, BSD */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <time.h>
+#include <string.h>
+#include "ipmicmd.h"
+
+#define GET_SELTIME 0x48
+#define SET_SELTIME 0x49
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "iseltime";
+static char fdebug = 0;
+static char fset = 0;
+static uchar ipmi_maj = 0;
+static uchar ipmi_min = 0;
+
+static int get_sel_time(uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+ ret = ipmi_cmdraw(GET_SELTIME, NETFN_STOR, BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, 0, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_sel_time()*/
+
+static int set_sel_time(time_t newtime)
+{
+ uchar idata[4];
+ uchar rdata[16];
+ int rlen = 8;
+ int ret;
+ uchar ccode;
+
+ idata[0] = (uchar)(newtime & 0x00ff);
+ idata[1] = (uchar)((newtime >> 8) & 0x00ff);
+ idata[2] = (uchar)((newtime >> 16) & 0x00ff);
+ idata[3] = (uchar)((newtime >> 24) & 0x00ff);
+ ret = ipmi_cmdraw(SET_SELTIME, NETFN_STOR, BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, 4, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end set_sel_time()*/
+
+time_t utc2local(time_t t)
+{
+ struct tm * tm_tmp;
+ int gt_year,gt_yday,gt_hour,lt_year,lt_yday,lt_hour;
+ int delta_hour;
+ time_t lt;
+
+ //modify UTC time to local time expressed in number of seconds from 1/1/70 0:0:0 1970 GMT
+ // check for dst?
+ tm_tmp=gmtime(&t);
+ gt_year=tm_tmp->tm_year;
+ gt_yday=tm_tmp->tm_yday;
+ gt_hour=tm_tmp->tm_hour;
+ tm_tmp=localtime(&t);
+ lt_year=tm_tmp->tm_year;
+ lt_yday=tm_tmp->tm_yday;
+ lt_hour=tm_tmp->tm_hour;
+ delta_hour=lt_hour - gt_hour;
+ if ( (lt_year > gt_year) || ((lt_year == gt_year) && (lt_yday > gt_yday)) )
+ delta_hour += 24;
+ if ( (lt_year < gt_year) || ((lt_year == gt_year) && (lt_yday < gt_yday)) )
+ delta_hour -= 24;
+ if (fdebug) printf("utc2local: delta_hour = %d\n",delta_hour);
+ lt = t + (delta_hour * 60 * 60);
+ return(lt);
+}
+
+#define TIMESTR_SZ 30
+void show_time(time_t etime)
+{
+ char buf[TIMESTR_SZ];
+ int bufsz = TIMESTR_SZ;
+ time_t t;
+
+ strcpy(buf,"00/00/00 00:00:00");
+ t = utc2local(etime);
+ strftime(buf,bufsz, "%x %H:%M:%S", gmtime(&t)); /*or "%x %T"*/
+ printf("%s\n",buf);
+ return;
+}
+
+#ifdef METACOMMAND
+int i_iseltime(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rv = 0;
+ uchar devrec[20];
+ uchar timebuf[4];
+ time_t ltime1, ltime2, ltime3;
+ int c;
+
+#if defined (EFI)
+ InitializeLib(_LIBC_EFIImageHandle, _LIBC_EFISystemTable);
+#else
+ printf("%s ver %s\n", progname,progver);
+#endif
+
+ while ( (c = getopt( argc, argv,"sT:V:J:EYF:P:N:R:U:x?")) != EOF )
+ switch(c) {
+ case 's': fset = 1; break; /* read only */
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-sx -NUPRETVF]\n", progname);
+ printf(" where -s Set SEL time (usually once a day)\n");
+ printf(" -x show eXtra debug messages\n");
+ print_lan_opt_usage();
+ exit(1);
+ }
+
+ rv = ipmi_getdeviceid(devrec,16,fdebug);
+ if (rv != 0) {
+ show_outcome(progname,rv);
+ ipmi_close_();
+ exit(rv);
+ } else {
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+#ifndef EFI
+ printf("-- BMC version %x.%x, IPMI version %d.%d \n",
+ devrec[2], devrec[3], ipmi_maj, ipmi_min);
+#endif
+ }
+
+ rv = get_sel_time(&timebuf[0],4);
+ if (rv != 0) {
+ printf("get_sel_time error: ret = %x\n",rv);
+ ipmi_close_();
+ exit(1);
+ }
+ time(&ltime2);
+ printf("Current System time: "); show_time(ltime2);
+ ltime1 = timebuf[0] + (timebuf[1] << 8) + (timebuf[2] << 16) +
+ (timebuf[3] << 24);
+ printf("Current SEL time: "); show_time(ltime1);
+
+ // if (fdebug) ltime3 = utc2local(ltime1);
+
+ if (fset == 1) {
+ /* get current time */
+ time(&ltime2);
+ rv = set_sel_time(ltime2);
+ printf("Setting SEL time to System Time: ret = %x\n",rv);
+ if (rv != 0) printf("set_sel_time error: ret = %x\n",rv);
+ else { /*successful*/
+ rv = get_sel_time(timebuf,8);
+ if (rv != 0) printf("get_sel_time error: ret = %x\n",rv);
+ else {
+ ltime3 = timebuf[0] + (timebuf[1] << 8) + (timebuf[2] << 16) +
+ (timebuf[3] << 24);
+ printf("New SEL time: "); show_time(ltime3);
+ }
+ }
+ }
+#ifdef LINUX
+ if (is_remote() == 0) {
+ c = system("echo \"Current RTC time: `hwclock`\"");
+ if (fset == 1) {
+ c = system("hwclock --systohc");
+ printf("Copying System Time to RTC: ret = %d\n",c);
+ }
+ }
+#endif
+ ipmi_close_();
+ show_outcome(progname,rv);
+ exit (rv);
+} /* end main()*/
+
+/* end iseltime.c */
diff --git a/util/isensor.c b/util/isensor.c
new file mode 100644
index 0000000..ac93411
--- /dev/null
+++ b/util/isensor.c
@@ -0,0 +1,3680 @@
+/*
+ * isensor.c
+ *
+ * This tool reads the SDR records to return sensor information.
+ * It can use either the Intel /dev/imb driver or VALinux /dev/ipmikcs.
+ *
+ * Author: arcress at users.sourceforge.net
+ * Copyright (c) 2002-2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 07/25/02 Andy Cress created
+ * 10/09/02 Andy Cress v1.1 added decodeValue(RawToFloat) routine
+ * 10/11/02 Andy Cress v1.2 added expon routine
+ * 10/30/02 Andy Cress v1.3 added SDR types 08 & 14
+ * 12/04/02 Andy Cress v1.4 changed dstatus descriptions
+ * 01/29/03 Andy Cress v1.5 added MV OpenIPMI driver support
+ * Hannes Schulz <schulz@schwaar.com>
+ * 1) correct raw readings to floatval
+ * 2) allow extra SDR bytes returned from HP netserver 1000r
+ * Guo Min <guo.min@intel.com>
+ * add -l option for simpler list display
+ * 02/25/03 Andy Cress v1.6 misc cleanup
+ * 05/02/03 Andy Cress v1.7 add PowerOnHours
+ * 07/28/03 Andy Cress v1.8 added -t option for threshold values,
+ * added sample Discovery routine (unfinished),
+ * added ipmi_getdeviceid for completeness.
+ * 09/05/03 Andy Cress v1.9 show SDR OEM subtypes,
+ * fix GetSDR multi-part get for OEM SDRs
+ * stop if SDR Repository is empty
+ * 09/23/03 Andy Cress v1.10 Add options to set thresholds
+ * 10/14/03 Andy Cress v1.11 Fixed sdr offset for ShowThreshold values
+ * 01/15/04 Andy Cress v1.12 Fixed SetThreshold to set hysteresis,
+ * Fixed sens_cap testing in ShowThresh(Full)
+ * 01/30/04 Andy Cress v1.13 Changed field display order, added header,
+ * check for sdr sz below min, added WIN32.
+ * 02/19/04 Andy Cress v1.14 Added SDR type 3 parsing for mBMC
+ * 02/27/04 Andy Cress v1.15 Added check for superuser, more mBMC logic
+ * 03/11/04 Andy Cress v1.16 Added & removed private mBMC code for set
+ * thresholds due to licensing issues
+ * 04/13/04 Andy Cress v1.17 Added -r to show raw SDRs also
+ * 05/05/04 Andy Cress v1.18 call ipmi_close before exit,
+ * fix sresp in GetSDR for WIN32.
+ * 07/07/04 Andy Cress v1.19 Added -a to reArm sensor,
+ * show debug raw reading values only in hex
+ * 08/18/04 Andy Cress v1.20 Added decoding for DIMM status
+ * 11/01/04 Andy Cress v1.21 add -N / -R for remote nodes,
+ * added -U for remote username
+ * 11/19/04 Andy Cress v1.22 added more decoding for compact reading types,
+ * added -w option to wrap thresholds
+ * 11/24/04 ARCress v1.23 added sens_type to display output
+ * 12/10/04 ARCress v1.24 added support for device sdrs also,
+ * fixed sens_cap byte,
+ * 01/10/05 ARCress v1.25 change ShowThresh order, highest to lowest,
+ * change signed exponent type in RawToFloat
+ * 01/13/05 ARCress v1.26 added time display if fwrap
+ * 01/28/05 ARCress v1.27 mod for Power Redundancy SDR status
+ * 02/15/05 ARCress v1.28 added FloatToRaw for -h/-l threshold set funcs,
+ * always take -n sensor_num as hex (like displayed)
+ * 03/07/05 ARCress v1.29 added "LAN Leash Lost" decoding in decode_comp_
+ * added -v to show max/min & hysteresis.
+ * 03/22/05 ARCress v1.30 added OEM subtype 0x60 for BMC TAM
+ * 03/26/05 ARCress v1.31 added battery type to decode_comp_reading
+ * 04/21/05 ARCress v1.32 added error message if -n sensor_num not found,
+ * added more decoding for Power Redund sensor
+ * 06/20/05 ARCress v1.33 if GetSDRRepository cc=0xc1 switch fdevsdrs mode,
+ * also detect fdevsdrs better for ATCA.
+ * 07/28/05 ARCress v1.34 check for Reading init state,
+ * add extra byte to decode_comp_reading()
+ * 09/12/05 ARCress v1.35 don't check superuser for fipmi_lan
+ * 01/26/06 ARCress v1.36 added -i option to only show one sensor index
+ * 03/14/06 ARCress v1.37 added -p option to save persistent thresholds
+ * 04/06/06 ARCress v1.38 show auto/manual rearm
+ * 07/17/06 ARCress v1.39 add -V, add -L, handle RepInfo rc=0xc1
+ * 11/28/06 ARCress v1.46 added -c -m for ATCA child MCs
+ * 08/15/07 ARCress v1.58 filter display if -n sensor_num
+ * 08/29/07 ARCress v1.59 fixed Battery sensor interpretation
+ * 10/31/07 ARCress v2.3 retry GetSDR if cc=0xC5 (lost reservationID)
+ * 01/14/08 ARCress v2.6 add -u param for setting unique thresholds,
+ * always show float when setting thresholds,
+ * fixup in decoding Proc,PS Comp readings
+ * 01/25/08 ARCress v2.7 allow float input with -u thresholds,
+ * add -p persist logic for -u thresholds.
+ */
+/*M*
+Copyright (c) 2002-2006 Intel Corporation.
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h> // for: double pow(double x, double y);
+#include <string.h>
+#include <time.h>
+#ifdef WIN32
+#include <windows.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include "getopt.h"
+#else
+#include <sys/stat.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#if defined(LINUX)
+#include <unistd.h>
+#include <sys/types.h>
+#endif
+#include "ipmicmd.h"
+#include "isensor.h"
+
+#define PICMG_CHILD 1 /* show child MCs if -b */
+#define MIN_SDR_SZ 8
+#define SZCHUNK 16 /* SDR chunksize was 8, now 16 */
+#define INIT_SNUM 0xff
+#define N_SGRP 16
+#define THR_EMPTY 999
+
+extern int get_LastError( void ); /* ipmilan.c */
+extern int use_devsdrs(int picmg); /* ipmicmd.c */
+extern int get_MemDesc(int array, int dimm, char *desc, int *psz); /*mem_if.c*/
+extern char *get_sensor_type_desc(uchar stype); /*ievents.c*/
+#ifdef METACOMMAND
+#include "oem_intel.h"
+/* void show_oemsdr_intel(uchar *sdr); in oem_intel.h */
+/* int decode_sensor_intel(); in oem_intel.h */
+/* int is_romley(int vend, int prod); in oem_intel.h */
+extern int decode_sensor_kontron(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_kontron.c*/
+extern int decode_sensor_fujitsu(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_fujitsu.c*/
+extern int decode_sensor_sun(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_sun.c*/
+extern int decode_sensor_supermicro(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_supermicro.c*/
+extern int decode_sensor_quanta(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_quanta.c*/
+extern int decode_sensor_hp(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_hp.c*/
+extern int decode_sensor_dell(uchar *sdr,uchar *reading,char *pstring,
+ int slen); /*see oem_dell.c*/
+extern void show_oemsdr_hp(uchar *sdr);
+#else
+int is_romley(int vend, int prod) {
+ if ((vend == VENDOR_INTEL) && ((prod >= 0x0048) && (prod <= 0x005e)))
+ return(1);
+ return(0);
+}
+int is_thurley(int vend, int prod) {
+ if ((vend == VENDOR_INTEL) && ((prod >= 0x003A) && (prod <= 0x0040)))
+ return(1);
+ return(0);
+}
+#endif
+#ifdef ALONE
+#define NENTID 53
+static char *entity_id_str[NENTID] = {
+/* 00 */ "unspecified",
+/* 01 */ "other",
+/* 02 */ "unknown",
+/* 03 */ "processor",
+/* 04 */ "disk",
+/* 05 */ "peripheral bay",
+/* 06 */ "management module",
+/* 07 */ "system board",
+/* 08 */ "memory module",
+/* 09 */ "processor module",
+/* 10 */ "power supply",
+/* 11 */ "add-in card",
+/* 12 */ "front panel bd",
+/* 13 */ "back panel board",
+/* 14 */ "power system bd",
+/* 15 */ "drive backplane",
+/* 16 */ "expansion board",
+/* 17 */ "Other system board",
+/* 18 */ "processor board",
+/* 19 */ "power unit",
+/* 20 */ "power module",
+/* 21 */ "power distr board",
+/* 22 */ "chassis back panel bd",
+/* 23 */ "system chassis",
+/* 24 */ "sub-chassis",
+/* 25 */ "Other chassis board",
+/* 26 */ "Disk Drive Bay",
+/* 27 */ "Peripheral Bay",
+/* 28 */ "Device Bay",
+/* 29 */ "fan",
+/* 30 */ "cooling unit",
+/* 31 */ "cable/interconnect",
+/* 32 */ "memory device ",
+/* 33 */ "System Mgt Software",
+/* 34 */ "BIOS",
+/* 35 */ "Operating System",
+/* 36 */ "system bus",
+/* 37 */ "Group",
+/* 38 */ "Remote Mgt Comm Device",
+/* 39 */ "External Environment",
+/* 40 */ "battery",
+/* 41 */ "Processing blade",
+/* 43 */ "Processor/memory module",
+/* 44 */ "I/O module",
+/* 45 */ "Processor/IO module",
+/* 46 */ "Mgt Controller Firmware",
+/* 47 */ "IPMI Channel",
+/* 48 */ "PCI Bus",
+/* 49 */ "PCI Express Bus",
+/* 50 */ "SCSI Bus",
+/* 51 */ "SATA/SAS bus",
+/* 52 */ "Processor FSB"
+};
+char *decode_entity_id(int id) {
+ if (id < NENTID) return ("");
+ else return(entity_id_str[id]); }
+#else
+/* char *decode_entity_id(int id); *isensor.h, from ievents.c*/
+#endif
+/************************
+ * Global Data
+ ************************/
+static char *progname = "isensor";
+static char *progver = "2.93";
+#ifdef WIN32
+static char savefile[] = "%ipmiutildir%\\thresholds.cmd";
+#else
+static char savefile[] = "/var/lib/ipmiutil/thresholds.sh";
+// static char savefile[] = "/usr/share/ipmiutil/thresholds.sh";
+#endif
+extern char fdebug; /*from ipmicmd.c*/
+int sens_verbose = 0; /* =1 show max/min & hysteresis also */
+static int fdevsdrs = 0;
+static int fReserveOK = 1;
+static int fDoReserve = 1;
+static int fsimple = 0; /*=1 simple, canonical output*/
+static int fshowthr = 0; /* =1 show thresholds, =2 show thr in ::: fmt */
+static int fwrap = 0;
+static int frawsdr = 0;
+static int frearm = 0;
+static int fshowidx = 0; /* only show a specific SDR index/range */
+static int fshowgrp = 0; /* =1 show group of sensors by sensor type */
+static int fdoloop = 0; /* =1 if user specified number of loops */
+static int fpicmg = 0;
+static int fchild = 0; /* =1 show child SDRs */
+static int fset_mc = 0; /* =1 -m to set_mc */
+static int fdump = 0;
+static int frestore = 0;
+static int fjumpstart = 0;
+static int fgetmem = 0;
+static int fprivset = 0;
+static char fremote = 0;
+static int nloops = 1; /* num times to show repeated sensor readings */
+static char bdelim = BDELIM; /* delimiter for canonical output */
+static char tmpstr[20]; /* temp string */
+static char *binfile = NULL;
+static int fsetthresh = 0;
+static int fsavethresh = 0;
+static uchar sensor_grps[N_SGRP] = {0, 0}; /*sensor type groups*/
+static ushort sensor_idx1 = 0xffff;
+static ushort sensor_idxN = 0xffff;
+static uchar sensor_num = INIT_SNUM;
+static uchar sensor_hi = 0xff;
+static uchar sensor_lo = 0xff;
+static uchar sensor_thr[6] = {0,0,0,0,0,0};
+static double sensor_thrf[6] = {0,0,0,0,0,0};
+static double sensor_hi_f = 0;
+static double sensor_lo_f = 0;
+static int fmBMC = 0;
+static int fRomley = 0;
+static char chEol = '\n'; /* newline by default, space if option -w */
+static uchar resid[2] = {0,0};
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = 0;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static int vend_id = 0;
+static int prod_id;
+
+/* sensor_dstatus
+ * This is used to decode the sensor reading types and meanings.
+ * Use IPMI Table 36-1 and 36-2 for this.
+ */
+#define N_DSTATUS 82
+#define STR_CUSTOM 58
+#define STR_OEM 71
+#define STR_AC_LOST 76
+#define STR_PS_FAIL 77
+#define STR_PS_CONFIG 78
+#define STR_HSC_OFF 79
+#define STR_REBUILDING 80
+#define STR_OTHER 81
+static char oem_string[50] = "OEM";
+static char *sensor_dstatus[N_DSTATUS] = {
+/* 0 00h */ "OK ",
+/* Threshold event states */
+/* 1 01h */ "Warn-lo", // "Warning-lo",
+/* 2 02h */ "Crit-lo", // "Critical-lo",
+/* 3 04h */ "BelowCrit", // "BelowCrit-lo",
+/* 4 08h */ "Warn-hi", // "Warning-hi",
+/* 5 10h */ "Crit-hi", // "Critical-hi",
+/* 6 20h */ "AboveCrit", // "AboveCrit-hi",
+/* 7 40h */ "Init ", /*in init state, no reading*/
+/* 8 80h */ "OK* ",
+/* Hotswap Controller event states, also Availability */
+/* 9 HSC */ "Present", /*present,inserted*/
+/*10 HSC */ "Absent", /*absent,removed,empty,missing*/
+/*11 HSC */ "Ready",
+/*12 HSC */ "Faulty",
+/* Digital/Discrete event states */
+/*13 D-D */ "Asserted",
+/*14 D-D */ "Deassert",
+/*15 D-D */ "Predict ",
+/* Availability event states */
+/*16 Avl */ "Disabled",
+/*17 Avl */ "Enabled ",
+/*18 Avl */ "Redundant",
+/*19 Avl */ "RedunLost",
+/*20 Avl */ "RedunDegr",
+/* ACPI Device Power States */
+/*21 ACPI*/ "Off ",
+/*22 ACPI*/ "Working",
+/*23 ACPI*/ "Sleeping", /*D2/S2*/
+/*24 ACPI*/ "On",
+/* Critical Interrupt event states */
+/*25 CrI */ "FP_NMI ",
+/*26 CrI */ "Bus_TimOut",
+/*27 CrI */ "IOch_NMI",
+/*28 CrI */ "SW_NMI ",
+/*29 CrI */ "PCI_PERR",
+/*30 CrI */ "PCI_SERR",
+/*31 CrI */ "EISA_TimOut",
+/*32 CrI */ "Bus_Warn ", /*Correctable*/
+/*33 CrI */ "Bus_Error", /*Uncorrectable*/
+/*34 CrI */ "Fatal_NMI",
+/*35 CrI */ "Bus_Fatal", /*0x0A*/
+/*36 CrI */ "Bus_Degraded", /*0x0B*/
+/* Physical Security event states */
+/*37 Phys*/ "LanLeashLost",
+/*38 Phys*/ "ChassisIntrus",
+/* Memory states */
+/*39 Mem */ "ECCerror",
+/*40 Mem */ "ParityErr",
+/* Discrete sensor invalid readings (error or init state) */
+/*41 D-D */ "Unknown",
+/*42 D-D */ "NotAvailable",
+/* Discrete sensor OEM reading states */
+/*43 OEM */ "Enabled ",
+/*44 OEM */ "Disabled",
+/* Session Audit states */
+/*45 OEM */ "Activated ",
+/*46 OEM */ "Deactivated",
+/*47 HSC */ "Unused ",
+/* Processor event states */
+/*48 Proc*/ "IERR",
+/*49 Proc*/ "ThermalTrip",
+/*50 Proc*/ "FRB1Failure",
+/*51 Proc*/ "FRB2Failure",
+/*52 Proc*/ "FRB3Failure",
+/*53 Proc*/ "ConfigError",
+/*54 Proc*/ "SMBIOSError",
+/*55 Proc*/ "ProcPresent",
+/*56 Proc*/ "ProcDisabled",
+/*57 Proc*/ "TermPresent",
+/* Custom data string, 15 bytes */
+/*58 Custom*/ "CustomData12345",
+/* Event Log */
+/*59 EvLog*/ "MemLogDisab",
+/*60 EvLog*/ "TypLogDisab",
+/*61 EvLog*/ "LogCleared",
+/*62 EvLog*/ "AllLogDisab",
+/*63 EvLog*/ "SelFull",
+/*64 EvLog*/ "SelNearFull",
+/* more Digital Discrete */
+/*65 D-D */ "Exceeded",
+/*66 Alert*/ "AlertPage",
+/*67 Alert*/ "AlertLAN",
+/*68 Alert*/ "AlertPET",
+/*69 Alert*/ "AlertSNMP",
+/*70 Alert*/ "None",
+/*71 OEM str*/ &oem_string[0],
+/* Version Change */
+/*72 Change*/ "HW Changed",
+/*73 Change*/ "SW Changed",
+/*74 Change*/ "HW incompatibility",
+/*75 Change*/ "Change Error",
+/* Power Supply event states */
+/*76 PS */ "AC_Lost ",
+/*77 PS */ "PS_Failed",
+/* Power Supply event states */
+/*78 PS */ "Config_Err",
+/*79 HSC */ "Offline",
+/*80 HSC */ "Rebuilding",
+/*81 other*/ " _ "
+};
+
+static char *raid_states[9] = { /*for sensor type 0x0d drive status */
+ "Faulty",
+ "Rebuilding",
+ "InFailedArray",
+ "InCriticalArray",
+ "ParityCheck",
+ "PredictedFault",
+ "Un-configured",
+ "HotSpare",
+ "NoRaid" };
+
+#define NSENSTYPES 0x2a
+#ifdef OLD
+/* see ievents.c */
+static const char *sensor_types[NSENSTYPES] = { /*IPMI 2.0 Table 42-3*/
+/* 00h */ "reserved",
+/* 01h */ "Temperature",
+/* 02h */ "Voltage",
+/* 03h */ "Current",
+/* 04h */ "Fan",
+/* 05h */ "Platform Chassis Intrusion",
+/* 06h */ "Platform Security Violation",
+/* 07h */ "Processor",
+/* 08h */ "Power Supply",
+/* 09h */ "Power Unit",
+/* 0Ah */ "Cooling Device",
+/* 0Bh */ "FRU Sensor",
+/* 0Ch */ "Memory",
+/* 0Dh */ "Drive Slot",
+/* 0Eh */ "POST Memory Resize",
+/* 0Fh */ "System Firmware",
+/* 10h */ "SEL Disabled",
+/* 11h */ "Watchdog 1",
+/* 12h */ "System Event", /* offset 0,1,2 */
+/* 13h */ "Critical Interrupt", /* offset 0,1,2 */
+/* 14h */ "Button", /* offset 0,1,2 */
+/* 15h */ "Board",
+/* 16h */ "Microcontroller",
+/* 17h */ "Add-in Card",
+/* 18h */ "Chassis",
+/* 19h */ "Chip Set",
+/* 1Ah */ "Other FRU",
+/* 1Bh */ "Cable / Interconnect",
+/* 1Ch */ "Terminator",
+/* 1Dh */ "System Boot Initiated",
+/* 1Eh */ "Boot Error",
+/* 1Fh */ "OS Boot",
+/* 20h */ "OS Critical Stop",
+/* 21h */ "Slot / Connector",
+/* 22h */ "ACPI Power State",
+/* 23h */ "Watchdog 2",
+/* 24h */ "Platform Alert",
+/* 25h */ "Entity Presence",
+/* 26h */ "Monitor ASIC",
+/* 27h */ "LAN",
+/* 28h */ "Management Subsystem Health",
+/* 29h */ "Battery",
+};
+#endif
+
+#define NUNITS 30
+static char *unit_types[] = {
+/* 00 */ "unspecified",
+/* 01 */ "degrees C",
+/* 02 */ "degrees F",
+/* 03 */ "degrees K",
+/* 04 */ "Volts",
+/* 05 */ "Amps",
+/* 06 */ "Watts",
+/* 07 */ "Joules",
+/* 08 */ "Coulombs",
+/* 09 */ "VA",
+/* 10 */ "Nits",
+/* 11 */ "lumen",
+/* 12 */ "lux",
+/* 13 */ "Candela",
+/* 14 */ "kPa",
+/* 15 */ "PSI",
+/* 16 */ "Newton",
+/* 17 */ "CFM",
+/* 18 */ "RPM",
+/* 19 */ "Hz",
+/* 20 */ "microseconds",
+/* 21 */ "milliseconds",
+/* 22 */ "seconds",
+/* 23 */ "minutes",
+/* 24 */ "hours",
+/* 25 */ "days",
+/* 26 */ "weeks",
+/* 27 */ "mil",
+/* 28 */ "inches",
+/* 29 */ "feet",
+/* 42 */ "cycles"
+};
+/* 68 * "megabit", */
+/* 72 * "megabyte", */
+/* 90 * "uncorrectable error" (last defined)*/
+static char *unit_types_short[] = {
+/* 00 */ "?", /*unknown, not specified*/
+/* 01 */ "C",
+/* 02 */ "F",
+/* 03 */ "K",
+/* 04 */ "V",
+/* 05 */ "A",
+/* 06 */ "W",
+/* 07 */ "J",
+/* 08 */ "Coul",
+/* 09 */ "VA",
+/* 10 */ "Nits",
+/* 11 */ "lumen",
+/* 12 */ "lux",
+/* 13 */ "Cand",
+/* 14 */ "kPa",
+/* 15 */ "PSI",
+/* 16 */ "Newton",
+/* 17 */ "CFM",
+/* 18 */ "RPM",
+/* 19 */ "Hz",
+/* 20 */ "usec",
+/* 21 */ "msec",
+/* 22 */ "sec",
+/* 23 */ "min",
+/* 24 */ "hrs",
+/* 25 */ "days",
+/* 26 */ "wks",
+/* 27 */ "mil",
+/* 28 */ "in",
+/* 29 */ "ft",
+/* 42 */ "cyc"
+};
+
+ushort parse_idx(char *str)
+{
+ int i, n;
+ char istr[5];
+ if (strncmp(str,"0x",2) == 0) str += 2;
+ n = strlen_(str);
+ if (n == 4) {
+ i = (htoi(str) << 8) + htoi(&str[2]);
+ } else if (n == 3) {
+ istr[0] = '0';
+ memcpy(&istr[1],str,3);
+ i = (htoi(istr) << 8) + htoi(&istr[2]);
+ } else i = htoi(str); /*was atoi()*/
+ printf("idx = 0x%x\n",i);
+ return((ushort)i);
+}
+
+int get_idx_range(char *str)
+{
+ // int i = 0;
+ char *p;
+ p = strchr(str,'-');
+ if (p == NULL) p = strchr(str,',');
+ if (p != NULL) {
+ *p = 0;
+ p++;
+ sensor_idx1 = parse_idx(str);
+ sensor_idxN = parse_idx(p);
+ } else {
+ sensor_idx1 = parse_idx(str);
+ sensor_idxN = sensor_idx1;
+ }
+ return(0);
+}
+
+char *get_unit_type(int iunits, int ibase, int imod, int fshort)
+{
+ char *pstr = NULL;
+ char **punittypes;
+ static char unitstr[32];
+ int jbase, jmod;
+ uchar umod;
+
+ punittypes = unit_types;
+ if (fshort) punittypes = unit_types_short;
+ if (fdebug) printf("get_unit_type(%x,%d,%d,%d)\n",iunits,ibase,imod,fshort);
+ umod = (iunits & 0x06) >> 1;
+ if (ibase < NUNITS) jbase = ibase;
+ else {
+ if (fdebug) printf("units base %02x > %d\n",ibase,NUNITS);
+ if (ibase == 42) jbase = NUNITS; /*"cycles"*/
+ else jbase = 0;
+ }
+ if (imod < NUNITS) jmod = imod;
+ else {
+ if (fdebug) printf("units mod %02x > %d\n",imod,NUNITS);
+ jmod = 0;
+ }
+ switch (umod) {
+ case 2:
+ snprintf(unitstr,sizeof(unitstr),"%s * %s",
+ punittypes[jbase],punittypes[jmod]);
+ pstr = unitstr;
+ break;
+ case 1:
+ snprintf(unitstr,sizeof(unitstr),"%s/%s",
+ punittypes[jbase],punittypes[jmod]);
+ pstr = unitstr;
+ break;
+ case 0:
+ default:
+ pstr = punittypes[jbase];
+ break;
+ }
+ if ((umod == 0) && (iunits > 0)) {
+ /* special cases for other SensorUnits1 bits */
+ if ((iunits & 0x01) != 0) { /*percentage*/
+ if (fshort) pstr = "%";
+ else pstr = "percent";
+ } else if (iunits == 0xC0) { /*no analog reading*/
+ pstr = "na";
+ } else if (iunits == 0x18) {
+ /* For Tyan fans: base=42, units=24.(0x18) -> cycles/hour */
+ snprintf(unitstr,sizeof(unitstr),"%s/hour",punittypes[jbase]);
+ pstr = unitstr;
+ }
+ }
+ return(pstr);
+}
+
+char *decode_capab(uchar c)
+{
+ static char cstr[50];
+ char *arm;
+ char *thr;
+ char *evt;
+ // char *hys;
+ uchar b;
+ /* decode sens_capab bits */
+ if ((c & 0x40) == 0) arm = "man"; /*manual rearm*/
+ else arm = "auto"; /*automatic rearm*/
+ /* skip hysteresis bits (0x30) */
+ b = ((c & 0x0c) >> 2);
+ switch(b) {
+ case 0x00: thr = "none"; break; /*no thresholds*/
+ case 0x01: thr = "read"; break;
+ case 0x02: thr = "write"; break; /*read & write*/
+ case 0x03:
+ default: thr = "fixed"; break;
+ }
+ b = (c & 0x03) ;
+ switch(b) {
+ case 0x00: evt = "state"; break; /*threshold or discrete state*/
+ case 0x01: evt = "entire"; break; /*entire sensor only*/
+ case 0x02: evt = "disab"; break; /*global disable only*/
+ case 0x03:
+ default: evt = "none"; break; /*no events*/
+ }
+ sprintf(cstr,"arm=%s thr=%s evts=%s",arm,thr,evt);
+ return(cstr);
+}
+
+
+int get_group_id(char *pstr)
+{
+ int i, j, n, sz, len;
+ char *p;
+ int rv = -1;
+
+ sz = strlen_(pstr);
+ p = &pstr[0];
+ n = 0;
+ for (i = 0; i <= sz; i++) {
+ if (n >= N_SGRP) break;
+ switch(pstr[i]) {
+ case ',': /*delimiter*/
+ case '\n':
+ case '\0':
+ pstr[i] = 0; /*stringify this word*/
+ len = strlen_(p);
+ for (j = 0; j < NSENSTYPES; j++) {
+ if (strncasecmp(get_sensor_type_desc(j),p,len) == 0) {
+ sensor_grps[n++] = (uchar)j;
+ rv = 0;
+ break;
+ }
+ } /*endfor(j)*/
+ if (i+1 < sz) p = &pstr[i+1]; /*set p for next word*/
+ if (j >= NSENSTYPES) { /* sensor type not found */
+ rv = -1;
+ i = sz; /*exit loop*/
+ }
+ break;
+ default:
+ break;
+ } /*end switch*/
+ } /*end for(i)*/
+ if (rv == 0) rv = n;
+ else rv = -1;
+ return(rv);
+}
+
+static int validate_thresholds(void *pthrs, char flag, uchar *sdr)
+{
+ double *thrf;
+ uchar *thr;
+ int rv = 0;
+ uchar bits;
+
+ if (sdr == NULL) bits = 0xff; /*assume all are used*/
+ else bits = sdr[18]; /*18=indicates which are readable/used */
+
+ if (bits == 0) {
+ printf("No threshold values can be set for this sensor.\n");
+ return(3);
+ }
+ if (flag == 1) { /*float*/
+ thrf = (double *)pthrs;
+ if (fdebug)
+ printf("validate_thresh: bits=%02x, values: %f>=%f>=%f, %f<=%f<=%f\n",
+ bits, thrf[0],thrf[1],thrf[2], thrf[3],thrf[4],thrf[5]);
+ if ((bits & 0x02) != 0) { /*thrf[1] lo-crit is valid*/
+ if ((thrf[1] > thrf[0]) && ((bits & 0x01) != 0)) rv = 1;
+ if ((thrf[2] > thrf[1]) && ((bits & 0x04) != 0)) rv = 1; /*lo is wrong*/
+ }
+ if ((bits & 0x10) != 0) { /*thrf[4] hi-crit is valid*/
+ if ((thrf[4] < thrf[3]) && ((bits & 0x08) != 0)) rv = 2;
+ if ((thrf[5] < thrf[4]) && ((bits & 0x20) != 0)) rv = 2; /*hi is wrong*/
+ }
+ if (rv != 0) {
+ printf("Threshold values: %f>=%f>=%f, %f<=%f<=%f\n",
+ thrf[0], thrf[1], thrf[2], thrf[3], thrf[4], thrf[5]);
+ printf("Invalid threshold order in %s range.\n",
+ ((rv == 1)? "lo": "hi"));
+ }
+ } else {
+ thr = (uchar *)pthrs;
+ if ((bits & 0x02) != 0) { /*thr[1] lo-crit is valid*/
+ if ((thr[1] > thr[0]) && ((bits & 0x01) != 0)) rv = 1;
+ if ((thr[2] > thr[1]) && ((bits & 0x04) != 0)) rv = 1; /*lo is wrong*/
+ }
+ if ((bits & 0x10) != 0) { /*thr[4] hi-crit is valid*/
+ if ((thr[4] < thr[3]) && ((bits & 0x08) != 0)) rv = 2;
+ if ((thr[5] < thr[4]) && ((bits & 0x20) != 0)) rv = 2; /*hi is wrong*/
+ }
+ if (rv != 0) {
+ printf("Threshold values: %02x>=%02x>=%02x %02x<=%02x<=%02x\n",
+ thr[0], thr[1], thr[2], thr[3], thr[4], thr[5]);
+ printf("Invalid threshold order within -u (%s)\n",
+ ((rv == 1)? "lo": "hi"));
+ }
+ }
+ return(rv);
+}
+
+int
+GetSDRRepositoryInfo(int *nret, int *fdev)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ int rc;
+ int nSDR;
+ int freespace;
+ ushort cmd;
+ uchar cc = 0;
+ int i;
+
+ memset(resp,0,6); /* init first part of buffer */
+ if (nret != NULL) *nret = 0;
+ if (fdev != NULL) fdevsdrs = *fdev;
+ if (fdevsdrs) cmd = GET_DEVSDR_INFO;
+ else cmd = GET_SDR_REPINFO;
+ rc = ipmi_cmd_mc(cmd, NULL, 0, resp,&sresp, &cc, fdebug);
+ if (fdebug) printf("ipmi_cmd[%04x] repinf(%d) status=%d cc=%x\n",
+ cmd, fdevsdrs,rc,cc);
+ /* some drivers return cc in rc */
+ if ((rc == 0xc1) || (rc == 0xd4)) cc = rc;
+ else if (rc != 0) return(rc);
+ if (cc != 0) {
+ if ((cc == 0xc1) || /*0xC1 (193.) means unsupported command */
+ (cc == 0xd4)) /*0xD4 means insufficient privilege (Sun/HP)*/
+ {
+ /* Must be reporting wrong bit for fdevsdrs,
+ * so switch & retry */
+ if (fdevsdrs) {
+ fdevsdrs = 0;
+ cmd = GET_SDR_REPINFO;
+ } else {
+ fdevsdrs = 1;
+ cmd = GET_DEVSDR_INFO;
+ }
+ sresp = MAX_BUFFER_SIZE;
+ rc = ipmi_cmd_mc(cmd, NULL, 0, resp,&sresp, &cc, fdebug);
+ if (fdebug)
+ printf("ipmi_cmd[%04x] repinf status=%d cc=%x\n",cmd,rc,cc);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ } else return(cc);
+ }
+
+ if (fdevsdrs) {
+ nSDR = resp[0];
+ freespace = 1;
+ fReserveOK = 1;
+ } else {
+ nSDR = resp[1] + (resp[2] << 8);
+ freespace = resp[3] + (resp[4] << 8);
+ if ((resp[13] & 0x02) == 0) fReserveOK = 0;
+ else fReserveOK = 1;
+ }
+ if (nret != NULL) *nret = nSDR;
+ if (fdev != NULL) *fdev = fdevsdrs;
+ if (fdebug) {
+ //successful, show data
+ printf("SDR Repository (len=%d): ",sresp);
+ for (i = 0; i < sresp; i++) printf("%02x ",resp[i]);
+ printf("\n");
+ printf("SDR Info: fdevsdrs=%d nSDRs=%d free space = %x ReserveOK=%d\n",
+ fdevsdrs,nSDR,freespace,fReserveOK);
+ }
+
+ return(0);
+} /*end GetSDRRepositoryInfo()*/
+
+
+int
+GetSensorThresholds(uchar sens_num, uchar *thr_data)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[6];
+ int rc;
+ uchar cc = 0;
+
+ inputData[0] = sens_num;
+ rc = ipmi_cmd_mc(GET_SENSOR_THRESHOLD, inputData,1, resp,&sresp, &cc,fdebug);
+ if (fdebug)
+ printf("GetSensorThreshold[%02x] rc = %d, resp(%d) %02x %02x %02x %02x %02x %02x %02x\n",
+ sens_num,rc, sresp,resp[0],resp[1],resp[2],resp[3],
+ resp[4],resp[5],resp[6]);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ if (sresp == 0) return(-2);
+ memcpy(thr_data,resp,sresp);
+ return(0);
+}
+
+int
+RearmSensor(uchar sens_num)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[8];
+ int rc;
+ uchar cc = 0;
+
+ memset(inputData,0,6);
+ memset(resp,0,6);
+ inputData[0] = sens_num;
+ rc = ipmi_cmd_mc(GET_SEVT_ENABLE, inputData, 1, resp,&sresp, &cc, fdebug);
+ if (rc == 0 && cc != 0) rc = cc;
+ if (rc != 0 || fdebug)
+ printf("GetSensorEventEnable(%02x) rc = %d, cc = %x %02x %02x %02x\n",
+ sens_num,rc,cc,resp[0],resp[1],resp[3]);
+ if (rc == 0 && resp[0] != 0xc0) {
+ printf("EventEnable(%02x) = %02x, is not 0xc0\n",
+ sens_num,resp[0]);
+ memset(inputData,0,6);
+ inputData[0] = sens_num;
+ inputData[1] = resp[0] | 0xc0;
+ inputData[2] = resp[1];
+ inputData[3] = resp[2];
+ inputData[4] = resp[3];
+ inputData[5] = resp[4];
+ rc = ipmi_cmd_mc(SET_SEVT_ENABLE, inputData, 6, resp,&sresp,
+ &cc, fdebug);
+ if (rc == 0 && cc != 0) rc = cc;
+ if (rc != 0 || fdebug)
+ printf("SetSensorEventEnable(%02x) rc = %d, cc = %x\n",
+ sens_num,rc,cc);
+ }
+
+ memset(inputData,0,6);
+ inputData[0] = sens_num;
+ inputData[1] = 0; /* rearm all events for this sensor */
+ rc = ipmi_cmd_mc(REARM_SENSOR, inputData, 6, resp,&sresp, &cc, fdebug);
+ if (fdebug)
+ printf("RearmSensor(%02x) rc = %d, cc = %x %02x %02x\n",
+ sens_num,rc,cc,resp[0],resp[1]);
+ if (rc == 0 && cc != 0) rc = cc;
+
+ /* Could also do a global rearm via SetEventReceiver. */
+
+ return(rc);
+} /*end RearmSensor*/
+
+int
+SetSensorThresholds(uchar sens_num, uchar hi, uchar lo,
+ uchar *thr_data, uchar *thr_set)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[8];
+ int rc;
+ uchar cc = 0;
+ uchar sets = 0;
+ int i;
+
+ /*
+ * Set the sensor Hysteresis before setting the threshold.
+ */
+ memset(inputData,0,8);
+ inputData[0] = sens_num;
+ inputData[1] = 0xff;
+ rc = ipmi_cmd_mc(GET_SENSOR_HYSTERESIS,inputData,2, resp,&sresp, &cc,fdebug);
+ if (fdebug)
+ printf("GetSensorHysteresis(%02x) rc = %d, cc = %x %02x %02x\n",
+ sens_num,rc,cc,resp[0],resp[1]);
+ if (rc != ACCESS_OK) return(rc);
+ inputData[0] = sens_num;
+ inputData[1] = 0xff;
+ inputData[2] = resp[0];
+ inputData[3] = resp[1];
+ rc = ipmi_cmd_mc(SET_SENSOR_HYSTERESIS,inputData,4, resp,&sresp, &cc,fdebug);
+ if (fdebug)
+ printf("SetSensorHysteresis(%02x) rc = %d, cc = %x\n",
+ sens_num,rc,cc);
+ if (rc != ACCESS_OK) return(rc);
+
+ /*
+ * The application should validate that values are ordered,
+ * e.g. upper critical should be greater than upper
+ * non-critical.
+ * Due to the limited command line parameter interface,
+ * use the hi & lo values to set each of the thresholds.
+ * For a full implemenation, these thresholds should be set
+ * individually.
+ */
+ memset(inputData,0,8);
+ inputData[0] = sens_num;
+ sets = thr_data[0];
+ if (thr_set != NULL) { /* use specific thr_set values */
+ memcpy(&inputData[2],thr_set,6);
+ } else { /*default, use hi/lo params */
+ if (lo == 0xff) sets &= 0x38; /* don't set lowers */
+ else {
+ inputData[2] = lo; /* lower non-crit (& 0x01) */
+ inputData[3] = lo - 1; /* lower critical (& 0x02) */
+ inputData[4] = lo - 2; /* lower non-recov (& 0x04) */
+ }
+ if (hi == 0xff) sets &= 0x07; /* don't set uppers */
+ else {
+ inputData[5] = hi; /* upper non-crit (& 0x08) */
+ inputData[6] = hi + 1; /* upper critical (& 0x10) */
+ inputData[7] = hi + 2; /* upper non-recov (& 0x20) */
+ }
+ }
+ inputData[1] = sets; /* which ones to set */
+ { /* show from/to changes */
+ printf("GetThreshold[%02x]: %02x ",sens_num,sens_num);
+ for (i = 0; i < 7; i++) printf("%02x ",thr_data[i]);
+ printf("\n");
+ printf("SetThreshold[%02x]: ",sens_num);
+ for (i = 0; i < 8; i++) printf("%02x ",inputData[i]);
+ printf("\n");
+ }
+ rc = ipmi_cmd_mc(SET_SENSOR_THRESHOLD, inputData, 8, resp,&sresp, &cc, fdebug);
+ if (fdebug)
+ printf("SetSensorThreshold(%02x) rc = %d, cc = %x\n",
+ sens_num,rc,cc);
+ if (rc == 0 && cc != 0) rc = cc;
+ /* mBMC gets cc = 0xD5 (213.) here, setting thresholds disabled. */
+ return(rc);
+}
+
+int
+GetSensorReading(uchar sens_num, void *psdr, uchar *sens_data)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[6];
+ SDR02REC *sdr = NULL;
+ int mc;
+ int rc;
+ uchar cc = 0;
+ uchar lun = 0;
+ uchar chan = 0;
+
+ if (psdr != NULL) {
+ sdr = (SDR02REC *)psdr;
+ mc = sdr->sens_ownid;
+ if (mc != BMC_SA) { /* not BMC, e.g. HSC or ME sensor */
+ uchar a = ADDR_IPMB;
+ if (mc == HSC_SA) a = ADDR_SMI;
+ chan = (sdr->sens_ownlun & 0xf0) >> 4;
+ lun = (sdr->sens_ownlun & 0x03);
+ ipmi_set_mc(chan,(uchar)mc, lun,a);
+ }
+ } else mc = BMC_SA;
+ inputData[0] = sens_num;
+ rc = ipmi_cmd_mc(GET_SENSOR_READING,inputData,1, resp,&sresp,&cc,fdebug);
+ if (fdebug)
+ printf("GetSensorReading mc=%x,%x,%x status=%d cc=%x sz=%d resp: %02x %02x %02x %02x\n",
+ chan,mc,lun,rc,cc,sresp,resp[0],resp[1],resp[2],resp[3]);
+ if (mc != BMC_SA) ipmi_restore_mc();
+ if ((rc == 0) && (cc != 0)) {
+ if (fdebug) printf("GetSensorReading error %x %s\n",cc,
+ decode_cc((ushort)0,(uchar)cc));
+ rc = cc;
+ }
+ if (rc != 0) return(rc);
+
+ if (resp[1] & 0x20) { /* init state, reading invalid */
+ if (fdebug)
+ printf("sensor[%x] in init state, no reading\n", sens_num);
+ sens_data[1] = resp[1];
+ sens_data[2] = 0x40; /*set bit num for init state*/
+ } else { /*valid reading, copy it*/
+ /* only returns 4 bytes, no matter what type */
+ memcpy(sens_data,resp,4);
+ }
+ return(0);
+} /*end GetSensorReading()*/
+
+int
+GetSensorReadingFactors(uchar snum, uchar raw, int *m, int *b, int * b_exp,
+ int *r, int *a)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[6];
+ int rc;
+ uchar cc = 0;
+ int toler, a_exp;
+
+ inputData[0] = snum;
+ inputData[1] = raw;
+ rc = ipmi_cmd_mc(GET_SENSOR_READING_FACTORS, inputData, 2,
+ resp,&sresp, &cc, fdebug);
+ if (fdebug) printf("GetSensorReadingFactors status = %d\n",rc);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+
+ /* successful, copy values */
+ *m = resp[1] + ((resp[2] & 0xc0) << 2);
+ toler = resp[2] & 0x3f;
+ *b = resp[3] + ((resp[4] & 0xc0) << 2);
+ *a = (resp[4] & 0x3f) + ((resp[5] & 0xf0) << 4);
+ a_exp = (resp[5] & 0xc0) >> 2;
+ *r = (resp[6] &0xf0) >> 4;
+ *b_exp = resp[6] & 0x0f;
+ if (fdebug) {
+ printf("factors: next=%x m=%d b=%d b_exp=%d a=%d a_exp=%d r=%d\n",
+ resp[0],*m,*b,*b_exp,*a,a_exp,*r);
+ }
+ return(0);
+}
+
+int GetSensorType(uchar snum, uchar *stype, uchar *rtype)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar inputData[6];
+ int rc;
+ uchar cc = 0;
+
+ inputData[0] = snum;
+ rc = ipmi_cmd_mc(GET_SENSOR_TYPE, inputData, 1,
+ resp,&sresp, &cc, fdebug);
+ if (fdebug) printf("GetSensorType: ipmi_cmd rv = %d, cc = %x\n",rc,cc);
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ /* successful, copy values */
+ if (stype != NULL) *stype = resp[0];
+ if (rtype != NULL) *rtype = resp[1] & 0x7f;
+ return(rc);
+}
+
+void set_reserve(int val)
+{
+ fDoReserve = val;
+}
+
+int sdr_get_reservation(uchar *res_id, int fdev)
+{
+ int sresp;
+ uchar resp[MAX_BUFFER_SIZE];
+ uchar cc = 0;
+ ushort cmd;
+ int rc = -1;
+
+ if (fDoReserve == 1) {
+ fDoReserve = 0; /* only reserve SDR the first time */
+ sresp = sizeof(resp);;
+ if (fdev) cmd = RESERVE_DEVSDR_REP;
+ else cmd = RESERVE_SDR_REP;
+ rc = ipmi_cmd_mc(cmd, NULL, 0, resp, &sresp, &cc, fdebug);
+ if (rc == 0 && cc != 0) rc = cc;
+ if (rc == 0) { /* ok, so set the reservation id */
+ resid[0] = resp[0];
+ resid[1] = resp[1];
+ }
+ /* A reservation is cancelled by the next reserve request. */
+ if (fdebug)
+ printf("ipmi_cmd RESERVE status=%d cc=%x id=%02x%02x\n",
+ rc,cc,resid[0],resid[1]);
+ } else rc = 0;
+ /* if not first time, or if error, return existing resid. */
+ res_id[0] = resid[0];
+ res_id[1] = resid[1];
+ return(rc);
+} /*end sdr_get_reservation*/
+
+int sdr_clear_repo(int fdev)
+{
+ int sresp;
+ uchar resp[MAX_BUFFER_SIZE];
+ uchar inputData[6];
+ uchar cc = 0;
+ int rc = -1;
+ ushort cmd;
+ uchar resv[2] = {0,0};
+
+ if (fReserveOK)
+ rc = sdr_get_reservation(resv,fdev);
+
+ cmd = 0x27 + (NETFN_STOR << 8); /*Clear SDR Repository*/
+ inputData[0] = resv[0]; /*res id LSB*/
+ inputData[1] = resv[1]; /*res id MSB*/
+ inputData[2] = 'C';
+ inputData[3] = 'L';
+ inputData[4] = 'R';
+ inputData[5] = 0xAA;
+ sresp = sizeof(resp);;
+ rc = ipmi_cmd_mc(cmd, inputData, 6, resp, &sresp,&cc, fdebug);
+ if (fdebug) printf("sdr_clear_repo: rc = %d, cc = %x, sz=%d\n",rc,cc,sresp);
+ if (rc == 0 && cc != 0) rc = cc;
+
+ if (rc == 0 && (resp[0] & 1) != 1) {
+ if (fdebug) printf("Wait for sdr_clear_repo to complete\n");
+ os_usleep(1,0);
+ }
+ return(rc);
+}
+
+int sdr_add_record(uchar *sdr, int fdev)
+{
+ int sresp;
+ uchar resp[MAX_BUFFER_SIZE];
+ uchar inputData[6+SZCHUNK];
+ uchar cc = 0;
+ int rc = -1;
+ ushort cmd;
+ uchar resv[2] = {0,0};
+ int reclen, len, i;
+ int recid, chunksz;
+ uchar prog;
+
+ reclen = sdr[4] + 5;
+ recid = sdr[0] + (sdr[1] << 8);
+ /* OEM SDRs can be min 8 bytes, less is an error. */
+ if (reclen < 8) return(LAN_ERR_BADLENGTH);
+ if (fReserveOK)
+ rc = sdr_get_reservation(resv,fdev);
+ if (fdebug) printf("sdr_add_record[%x]: reclen = %d, reserve rc = %d\n",
+ recid,reclen,rc);
+
+ cmd = 0x25 + (NETFN_STOR << 8); /*PartialAddSdr*/
+ recid = 0; /*first chunk must be added as 0000*/
+ chunksz = SZCHUNK;
+ for (i = 0; i < reclen; )
+ {
+ prog = 0;
+ len = chunksz;
+ if ((i+chunksz) >= reclen) { /*last record*/
+ len = reclen - i;
+ prog = 1;
+ }
+ inputData[0] = resv[0]; /*res id LSB*/
+ inputData[1] = resv[1]; /*res id MSB*/
+ inputData[2] = recid & 0x00ff; /*record id LSB*/
+ inputData[3] = (recid >> 8) & 0x00ff; /*record id MSB*/
+ inputData[4] = (uchar)i; /*offset */
+ inputData[5] = prog; /*progress: 1=last record*/
+ memcpy(&inputData[6],&sdr[i],len);
+ sresp = sizeof(resp);
+ rc = ipmi_cmd_mc(cmd, inputData, 6+len, resp, &sresp,&cc, fdebug);
+ if (fdebug)
+ printf("sdr_add_record[%x,%x]: rc = %d, cc = %x, sz=%d\n",
+ recid,i,rc,cc,sresp);
+ if (rc == 0 && cc != 0) rc = cc;
+ if (rc != 0) break;
+ if (recid == 0 && rc == 0) /*first time, so set recid*/
+ recid = resp[0] + (resp[1] << 8);
+ i += len;
+ }
+ return(rc);
+}
+
+int GetSDR(int r_id, int *r_next, uchar *recdata, int srecdata, int *rlen)
+{
+ int sresp;
+ uchar resp[MAX_BUFFER_SIZE+SZCHUNK];
+ uchar respchunk[SZCHUNK+10];
+ uchar inputData[6];
+ uchar cc = 0;
+ int rc = -1;
+ int i, chunksz, thislen, off;
+ int reclen;
+ ushort cmd;
+ uchar resv[2] = {0,0};
+
+ chunksz = SZCHUNK;
+ reclen = srecdata; /*max size of SDR record*/
+ off = 0;
+ *rlen = 0;
+ *r_next = 0xffff; /*default*/
+ if (fReserveOK)
+ rc = sdr_get_reservation(resv,fdevsdrs);
+ if (fdevsdrs) cmd = GET_DEVICE_SDR;
+ else cmd = GET_SDR;
+ if (reclen == 0xFFFF) { /* get it all in one call */
+ inputData[0] = resv[0]; /*res id LSB*/
+ inputData[1] = resv[1]; /*res id MSB*/
+ inputData[2] = r_id & 0x00ff; /*record id LSB*/
+ inputData[3] = (r_id & 0xff00) >> 8; /*record id MSB*/
+ inputData[4] = 0; /*offset */
+ inputData[5] = 0xFF; /*bytes to read, ff=all*/
+ sresp = sizeof(resp);;
+ if (fdebug) printf("ipmi_cmd SDR id=%d read_all, len=%d\n",
+ r_id,sresp);
+ rc = ipmi_cmd_mc(cmd, inputData, 6, recdata, &sresp,&cc, fdebug);
+ /* This will usually return cc = 0xCA (invalid length). */
+ if (fdebug) printf("ipmi_cmd SDR data status = %d, cc = %x, sz=%d\n",
+ rc,cc,sresp);
+ reclen = sresp;
+ *r_next = recdata[0] + (recdata[1] << 8);
+ } else /* if (reclen > chunksz) do multi-part chunks */
+ for (off = 0; off < reclen; )
+ {
+ thislen = chunksz;
+ if ((off+chunksz) > reclen) thislen = reclen - off;
+ inputData[0] = resv[0]; /*res id LSB*/
+ inputData[1] = resv[1]; /*res id MSB*/
+ inputData[2] = r_id & 0x00ff; /*record id LSB*/
+ inputData[3] = (r_id & 0xff00) >> 8; /*record id MSB*/
+ inputData[4] = (uchar)off; /*offset */
+ inputData[5] = (uchar)thislen; /*bytes to read, ff=all*/
+ sresp = sizeof(respchunk);
+ rc = ipmi_cmd_mc(cmd, inputData, 6, respchunk, &sresp,&cc, fdebug);
+ if (fdebug)
+ printf("ipmi_cmd SDR[%x] off=%d ilen=%d status=%d cc=%x sz=%d\n",
+ r_id,off,thislen,rc,cc,sresp);
+ if (off == 0 && cc == 0xCA && thislen == SZCHUNK) {
+ /* maybe shorter than SZCHUNK, try again */
+ chunksz = 0x06;
+ if (fdebug) printf("sdr[%x] try again with chunksz=%d\n",
+ r_id,chunksz);
+ continue;
+ }
+ if (off > chunksz) {
+ /* already have first part of the SDR, ok to truncate */
+ if (rc == -3) { /* if LAN_ERR_RECV_FAIL */
+ if (fdebug) printf("sdr[%x] error rc=%d len=%d truncated\n",
+ r_id,rc,sresp);
+ sresp = 0;
+ rc = 0;
+ }
+ if (cc == 0xC8 || cc == 0xCA) { /* length errors */
+ /* handle certain MCs that report wrong length,
+ * at least use what we already have (sresp==0) */
+ if (fdebug) printf("sdr[%x] error cc=%02x len=%d truncated\n",
+ r_id,cc,sresp);
+ cc = 0;
+ }
+ }
+ if (rc != ACCESS_OK) return(rc);
+ if (cc != 0) return(cc);
+ /* if here, successful, chunk was read */
+ if (sresp < (thislen+2)) {
+ /* There are some SDRs that may report the wrong length, and
+ * return less bytes than they reported, so just truncate. */
+ if (fdebug) printf("sdr[%x] off=%d, expected %d, got %d\n",
+ r_id,off,thislen+2,sresp);
+ if (sresp >= 2) thislen = sresp - 2;
+ else thislen = 0;
+ reclen = off + thislen; /* truncate, stop reading */
+ }
+ /* successful */
+ memcpy(&resp[off],&respchunk[2],thislen);
+ if (off == 0 && sresp >= 5) {
+ *r_next = respchunk[0] + (respchunk[1] << 8);
+ reclen = respchunk[6] + 5; /*get actual record size*/
+ if (reclen > srecdata) {
+ if (fdebug) printf("sdr[%x] chunk0, reclen=%d srecdata=%d\n",
+ r_id, reclen, srecdata);
+ reclen = srecdata; /*truncate*/
+ }
+ }
+ off += thislen;
+ *rlen = off;
+ }
+ if (fdebug) {
+ printf("GetSDR[%04x] next=%x (len=%d): ",r_id,*r_next,reclen);
+ for (i = 0; i < reclen; i++) printf("%02x ",resp[i]);
+ printf("\n");
+ }
+ memcpy(recdata,&resp[0],reclen);
+ *rlen = reclen;
+ return(rc);
+} /*end GetSDR*/
+
+static int nsdrs = 0; /*number of sdrs*/
+static int sz_sdrs = 0; /*actual size used with sdrs*/
+static uchar *psdrcache = NULL;
+
+void free_sdr_cache(uchar *ptr)
+{
+ if (ptr != NULL) free(ptr);
+ if ((ptr != psdrcache) && (psdrcache != NULL))
+ free(psdrcache);
+ psdrcache = NULL;
+}
+
+int get_sdr_file(char *sdrfile, uchar **sdrlist)
+{
+ int rv = -1;
+ FILE *fp = NULL;
+ int i, n, num, nsdr, isdr, len;
+ uchar *sdrbuf;
+ uchar buff[255];
+ uchar hbuf[85];
+ char fvalid;
+
+ fp = fopen(sdrfile,"r");
+ if (fp == NULL) {
+ printf("Cannot open file %s\n",sdrfile);
+ return(ERR_FILE_OPEN);
+ }
+ /* determine number of SDRs by number of lines in the file */
+ num = 0;
+ while (fgets(buff, 255, fp)) { num++; }
+ if (fdebug) printf("Reading %d SDRs from file %s\n",num,sdrfile);
+ sdrbuf = malloc(num * SDR_SZ);
+ if (sdrbuf == NULL) {
+ fclose(fp);
+ return(rv);
+ }
+ fseek(fp, 0L, SEEK_SET);
+ *sdrlist = sdrbuf;
+ psdrcache = sdrbuf;
+ nsdrs = num;
+ isdr = 0;
+ nsdr = 0;
+ while (fgets(buff, 255, fp)) {
+ len = strlen_(buff);
+ fvalid = 0;
+ if (buff[0] >= '0' && (buff[0] <= '9')) fvalid = 1;
+ else if (buff[0] >= 'a' && (buff[0] <= 'f')) fvalid = 1;
+ else if (buff[0] >= 'A' && (buff[0] <= 'F')) fvalid = 1;
+ if (fvalid == 0) continue;
+ i = 0;
+ for (n = 0; n < len; ) {
+ if (buff[n] < 0x20) break; /* '\n', etc. */
+ hbuf[i++] = htoi(&buff[n]);
+ n += 3;
+ }
+ memcpy(&sdrbuf[isdr],hbuf,i);
+ isdr += i;
+ nsdr++;
+ } /*end while*/
+ if (fdebug) printf("Read %d SDRs, %d bytes\n",nsdr,isdr);
+ fclose(fp);
+ rv = 0;
+ return(rv);
+}
+
+int get_sdr_cache(uchar **pret)
+{
+ int rv = -1;
+ int i, n, sz, len, asz;
+ int recid, recnext;
+ uchar *pcache;
+ uchar *psdr;
+
+ if (pret == NULL) return(rv);
+ fdevsdrs = use_devsdrs(fpicmg);
+
+ if ((psdrcache != NULL) && (nsdrs > 0)) { /*already have sdrcache*/
+ *pret = psdrcache;
+ if (fdebug) printf("get_sdr_cache: already have cache (%p)\n",*pret);
+ return(0);
+ }
+
+ rv = GetSDRRepositoryInfo(&n,&fdevsdrs);
+ if (rv != 0) return(rv);
+ if (n == 0) {
+ /* this is an error, probably because fdevsdrs is wrong.*/
+ if (fdebug) printf("get_sdr_cache: nsdrs=0, retrying\n");
+ fdevsdrs = (fdevsdrs ^ 1);
+ n = 150; /*try some default num SDRs*/
+ }
+
+ sz = n * SDR_SZ; /*estimate max size for n sdrs*/
+ pcache = malloc(sz);
+ if (pcache == NULL) return(rv);
+ psdrcache = pcache;
+ *pret = pcache;
+ memset(pcache,0,sz);
+ recid = 0;
+ asz = 0;
+ for (i = 0; i <= n; i++)
+ {
+ if (recid == 0xffff) break;
+ // psdr = &pcache[i * SDR_SZ];
+ psdr = &pcache[asz];
+ rv = GetSDR(recid,&recnext,psdr,SDR_SZ,&len);
+ if (fdebug)
+ printf("GetSDR[%x] rv = %d len=%d next=%x\n",recid,rv,len,recnext);
+ if (rv != 0) {
+ if (rv == 0xC5) { set_reserve(1); i--; } /*retry*/
+ else break;
+ } else { /*success*/
+ asz += len;
+ if (recnext == recid) recid = 0xffff;
+ else recid = recnext;
+ }
+ }
+ nsdrs = n;
+ sz_sdrs = asz; /* save the size for later*/
+ if (fdebug) {
+ printf("get_sdr_cache, n=%d sz=%d asz=%d\n",n,sz,asz);
+ if (i < n) printf("get_sdr_cache error, i=%d < n=%d, rv=%d\n",i,n,rv);
+ }
+ return(rv);
+}
+
+int find_nsdrs(uchar *pcache)
+{
+ int num = 0;
+ int asz = 0;
+ int i, len;
+ uchar *sdr;
+ ushort recid;
+
+ if (pcache == NULL) return(num);
+ for (i = 0; asz < sz_sdrs; i++)
+ {
+ sdr = &pcache[asz];
+ len = sdr[4] + 5;
+ recid = sdr[0] + (sdr[1] << 8);
+ asz += len;
+ if (fdebug) printf("SDR[%x] len=%d i=%d\n", recid,len,i);
+ }
+ num = i;
+ return(num);
+}
+
+int find_sdr_by_snum(uchar *psdr, uchar *pcache, uchar snum, uchar sa)
+{
+ int rv = -1;
+ uchar *sdr;
+ int i, k, len;
+ int asz = 0;
+ if (psdr == NULL) return(rv);
+ if (pcache == NULL) return(rv);
+ for (i = 0; i <= nsdrs; i++)
+ {
+ // sdr = &pcache[i * SDR_SZ];
+ sdr = &pcache[asz];
+ len = sdr[4] + 5;
+ asz += len;
+ switch(sdr[3]) {
+ case 0x01: k = 7; break; /*full sensor*/
+ case 0x02: k = 7; break; /*compact sensor*/
+ case 0x03: k = 7; break;/*compact sensor*/
+ default: k = 0; break;
+ }
+ if (k == 0) continue;
+ else {
+ if ((sdr[5] == sa) && (sdr[k] == snum)) {
+ memcpy(psdr,sdr,len);
+ return(0);
+ }
+ }
+ }
+ return(rv);
+}
+
+int find_sdr_by_tag(uchar *psdr, uchar *pcache, char *tag, uchar dbg)
+{
+ int rv = -1;
+ uchar *sdr;
+ int i, k, n, len;
+ int asz = 0;
+ if (psdr == NULL) return(rv);
+ if (pcache == NULL) return(rv);
+ if (tag == NULL) return(rv);
+ if (dbg) fdebug = 1;
+ n = strlen_(tag);
+ if (fdebug) printf("find_sdr_by_tag(%s) nsdrs=%d\n",tag,nsdrs);
+ for (i = 0; i <= nsdrs; i++)
+ {
+ // sdr = &pcache[i * SDR_SZ];
+ sdr = &pcache[asz];
+ len = sdr[4] + 5;
+ asz += len;
+ switch(sdr[3]) { /* set tag offset by SDR type */
+ case 0x01: k = 48; break; /*full SDR*/
+ case 0x02: k = 32; break; /*compact SDR*/
+ case 0x03: k = 17; break; /*event-only SDR*/
+ case 0x10: k = 16; break; /*device locator SDR*/
+ case 0x11: k = 16; break; /*FRU device locator SDR*/
+ case 0x12: k = 16; break; /*IPMB device locator SDR*/
+ default: k = 0; break; /*else do not have an ID string/tag*/
+ }
+ if (k == 0) {
+ if (fdebug) printf("sdr[%d] idx=%02x%02x num=%x type=%x skip\n",
+ i,sdr[1],sdr[0],sdr[7],sdr[3]);
+ continue;
+ } else {
+ if (len > SDR_SZ) len = SDR_SZ;
+ if (fdebug) {
+ char tmp[17];
+ memset(tmp,0,sizeof(tmp));
+ memcpy(tmp,&sdr[k],(len - k));
+ tmp[16] = 0; /*force stringify*/
+ printf("sdr[%d] idx=%02x%02x num=%x tag: %s\n",i,sdr[1],sdr[0],
+ sdr[7],tmp);
+ }
+ if (strncmp(tag,&sdr[k],n) == 0) {
+ memcpy(psdr,sdr,len);
+ return(0);
+ }
+ }
+ }
+ return(rv);
+}
+
+
+int find_sdr_next(uchar *psdr, uchar *pcache, ushort id)
+{
+ int rv = -1;
+ uchar *sdr;
+ int i, imatch, len;
+ ushort recid;
+ int asz = 0;
+ if (psdr == NULL) return(rv);
+ if (pcache == NULL) return(rv);
+ imatch = nsdrs;
+ for (i = 0; i < nsdrs; i++)
+ {
+ // sdr = &pcache[i * SDR_SZ];
+ sdr = &pcache[asz];
+ len = sdr[4] + 5;
+ recid = sdr[0] + (sdr[1] << 8);
+ asz += len;
+ // if (fdebug) printf("SDR[%x] len=%d id=%x i=%d imatch=%d\n",
+ // recid,len,id,i,imatch);
+ if (recid == id) imatch = i + 1; /*matches prev, return next one*/
+ if (id == 0) { rv = 0; break; }
+ if (i == imatch) { rv = 0; break; }
+ }
+ if (rv == 0) memcpy(psdr,sdr,len);
+ return(rv);
+}
+
+int find_sdr_by_id(uchar *psdr, uchar *pcache, ushort id)
+{
+ int rv = -1;
+ uchar *sdr;
+ int i, imatch, len;
+ ushort recid;
+ int asz = 0;
+ if (psdr == NULL) return(rv);
+ if (pcache == NULL) return(rv);
+ imatch = nsdrs;
+ for (i = 0; i < nsdrs; i++)
+ {
+ sdr = &pcache[asz];
+ len = sdr[4] + 5;
+ recid = sdr[0] + (sdr[1] << 8);
+ asz += len;
+ if (recid == id) { rv = 0; break; }
+ }
+ if (rv == 0) memcpy(psdr,sdr,len);
+ return(rv);
+}
+
+uchar
+bitnum(ushort value)
+{
+ uchar ret = 0;
+ int i;
+ /* returns the highest bit number number set in this word. */
+ /* Bit numbers are 1-based in this routine, 0 means no bits set. */
+ /* scan 15 bits (0x7FFF). */
+ for (i = 0; i < 15; i++) {
+ if (value & 0x01) ret = i+1; /*was ret++;*/
+ value = (value >> 1);
+ }
+ return(ret);
+}
+
+static double
+expon(int x, int y)
+{
+ double res;
+ int i;
+ /* compute exponent: x to the power y */
+ res = 1;
+ if (y > 0) {
+ for (i = 0; i < y; i++) res = res * x;
+ } else if (y < 0) {
+ for (i = 0; i > y; i--) res = res / x;
+ } /* else if if (y == 0) do nothing, res=1 */
+ return(res);
+}
+
+double
+RawToFloat(uchar raw, uchar *psdr)
+{
+ double floatval;
+ int m, b, a;
+ uchar ax;
+ int rx, b_exp;
+ SDR01REC *sdr;
+ int signval;
+
+ sdr = (SDR01REC *)psdr;
+ floatval = (double)raw; /*default*/
+
+ // if (raw == 0xff) floatval = 0; else
+ if (sdr->rectype == 0x01) { /* SDR rectype == full */
+ if (fdebug)
+ printf("units=%x base=%d mod=%d (raw=%x, nom_rd=%x)\n",
+ sdr->sens_units,sdr->sens_base,sdr->sens_mod,
+ raw, sdr->nom_reading);
+ m = sdr->m + ((sdr->m_t & 0xc0) << 2);
+ b = sdr->b + ((sdr->b_a & 0xc0) << 2);
+ if (b & 0x0200) b = (b - 0x0400); /*negative*/
+ if (m & 0x0200) m = (m - 0x0400); /*negative*/
+ rx = (sdr->rx_bx & 0xf0) >> 4;
+ if (rx & 0x08) rx = (rx - 0x10); /*negative, fix sign w ARM compilers*/
+ a = (sdr->b_a & 0x3f) + ((sdr->a_ax & 0xf0) << 2);
+ ax = (sdr->a_ax & 0x0c) >> 2;
+ b_exp = (sdr->rx_bx & 0x0f);
+ if (b_exp & 0x08) b_exp = (b_exp - 0x10); /*negative*/
+ //b_exp |= 0xf0; /* negative 8-bit */
+ if ((sdr->sens_units & 0xc0) == 0) { /*unsigned*/
+ floatval = (double)raw;
+ } else { /*signed*/
+ if (raw & 0x80) signval = (raw - 0x100);
+ else signval = raw;
+ floatval = (double)signval;
+ }
+ floatval *= (double) m;
+#ifdef MATH_OK
+ floatval += (b * pow (10,b_exp));
+ floatval *= pow (10,rx);
+#else
+ floatval += (b * expon (10,b_exp));
+ floatval *= expon (10,rx);
+#endif
+ if (fdebug)
+ printf("decode1: m=%d b=%d b_exp=%x rx=%d, a=%d ax=%d l=%x, floatval=%f\n",
+ m,b,b_exp,rx,a,ax,sdr->linear,floatval);
+ switch(sdr->linear) {
+ case 0: /*linear*/
+ break;
+ case 7: /*invert 1/x*/
+ /* skip if zero to avoid dividing by zero */
+ if (raw != 0) floatval = 1 / floatval;
+ break;
+ case 1: /*ln*/
+ case 2: /*log10, log2, e, exp10, exp2, */
+ case 3: /*log2*/
+ case 4: /*e*/
+ case 5: /*exp10*/
+ case 6: /*exp2*/
+ case 8: /*sqr(x)*/
+ case 9: /*cube(x)*/
+ case 10: /*sqrt(x)*/
+ case 11: /*cube-1(x)*/
+ default:
+ if (fdebug) printf("linear mode %x not implemented\n",sdr->linear);
+ break;
+ } /*end-switch linear*/
+ }
+
+#ifdef NOT_LINEAR
+ /* else if (sdr->linear != 7) */
+ {
+ double be, re;
+ rc = GetSensorType(sdr->sens_num,&stype,&rtype);
+ if (fdebug)
+ printf("decode: rc=%x, stype=%x, rtype=%x\n",rc,stype,rtype);
+ if (rc != 0) return(floatval);
+
+ /* GetSensorReadingFactors */
+ rc = GetSensorReadingFactors(sdr->sens_num,raw,&m,&b,&b_exp,&r,&a);
+ if (rc == 0) {
+ // floatval = ((m * raw) + (b * be)) * re;
+ }
+ if (fdebug) printf("decode: rc=%x, floatval=%f\n",rc,floatval);
+ }
+#endif
+
+ return(floatval);
+}
+
+#define IpmiAnalogDataFormatUnsigned 0
+#define IpmiAnalogDataFormat1Compl 1
+#define IpmiAnalogDataFormat2Compl 2
+
+uchar
+FloatToRaw(double val, uchar *psdr, int rounding)
+{
+ double cval;
+ int lowraw, highraw, raw, maxraw, minraw, next_raw;
+ int analog_dfmt;
+
+ analog_dfmt = (psdr[20] >> 6) & 0x03;
+ switch( analog_dfmt )
+ {
+ case IpmiAnalogDataFormat1Compl:
+ lowraw = -127;
+ highraw = 127;
+ minraw = -127;
+ maxraw = 127;
+ next_raw = 0;
+ break;
+ case IpmiAnalogDataFormat2Compl:
+ lowraw = -128;
+ highraw = 127;
+ minraw = -128;
+ maxraw = 127;
+ next_raw = 0;
+ break;
+ case IpmiAnalogDataFormatUnsigned:
+ default:
+ lowraw = 0;
+ highraw = 255;
+ minraw = 0;
+ maxraw = 255;
+ next_raw = 128;
+ break;
+ }
+
+ /* do a binary search for the right nth root value */
+ do {
+ raw = next_raw;
+ cval = RawToFloat( (uchar)raw, psdr );
+ if ( cval < val ) {
+ next_raw = ((highraw - raw) / 2) + raw;
+ lowraw = raw;
+ } else {
+ next_raw = ((raw - lowraw) / 2) + lowraw;
+ highraw = raw;
+ }
+ } while ( raw != next_raw );
+
+ /* Do rounding to get the final value */
+ switch( rounding ) {
+ case 0: /* Round Normal = Round to nearest value */
+ if ( val > cval ) {
+ if ( raw < maxraw ) {
+ double nval;
+ nval = RawToFloat((uchar)(raw+1),psdr);
+ nval = cval + ((nval - cval) / 2.0);
+ if ( val >= nval ) raw++;
+ }
+ } else {
+ if ( raw > minraw ) {
+ double pval;
+ pval = RawToFloat((uchar)(raw-1),psdr);
+ pval = pval + ((cval - pval) / 2.0);
+ if ( val < pval ) raw--;
+ }
+ }
+ break;
+ case 1: /*Round Down*/
+ if ((val < cval) && (raw > minraw )) raw--;
+ break;
+ case 2: /*Round Up*/
+ if ((val > cval) && (raw < maxraw)) raw++;
+ break;
+ }
+ if ( analog_dfmt == IpmiAnalogDataFormat1Compl )
+ if ( raw < 0 ) raw -= 1;
+ return((uchar)raw);
+} /*end FloatToRaw()*/
+
+static int fill_thresholds(double *thrf, uchar *sdr)
+{
+ int rv = 0;
+ uchar *vals;
+ uchar bits;
+
+ // snum = sdr[7];
+ bits = sdr[19]; /*which are settable*/
+ vals = &sdr[36];
+ if (fdebug)
+ printf("fill_thresholds: bits=%02x, values: %f>=%f>=%f, %f<=%f<=%f\n",
+ bits, thrf[0],thrf[1],thrf[2], thrf[3],thrf[4],thrf[5]);
+ if (thrf[0] == THR_EMPTY) {
+ if ((bits & 0x01) != 0) { /*lo-noncrit*/
+ thrf[0] = RawToFloat(vals[5],sdr);
+ rv++;
+ } else thrf[0] = 0;
+ }
+ if (thrf[1] == THR_EMPTY) {
+ if ((bits & 0x02) != 0) { /*lo-crit*/
+ thrf[1] = RawToFloat(vals[4],sdr);
+ rv++;
+ } else thrf[1] = 0;
+ }
+ if (thrf[2] == THR_EMPTY) {
+ if ((bits & 0x04) != 0) { /*lo-unrec*/
+ thrf[2] = RawToFloat(vals[3],sdr);
+ rv++;
+ } else thrf[2] = 0;
+ }
+ if (thrf[3] == THR_EMPTY) {
+ if ((bits & 0x08) != 0) { /*hi-noncrit*/
+ thrf[3] = RawToFloat(vals[2],sdr);
+ rv++;
+ } else thrf[3] = 0;
+ }
+ if (thrf[4] == THR_EMPTY) {
+ if ((bits & 0x10) != 0) { /*hi-crit*/
+ thrf[4] = RawToFloat(vals[1],sdr);
+ rv++;
+ } else thrf[4] = 0;
+ }
+ if (thrf[5] == THR_EMPTY) {
+ if ((bits & 0x20) != 0) { /*hi-unrec*/
+ thrf[5] = RawToFloat(vals[0],sdr);
+ rv++;
+ } else thrf[5] = 0;
+ }
+ if (fdebug)
+ printf("fill_thresholds: after rv=%d values: %f>=%f>=%f, %f<=%f<=%f\n",
+ rv,thrf[0],thrf[1],thrf[2], thrf[3],thrf[4],thrf[5]);
+ return(rv);
+}
+
+char *
+decode_itype(uchar itype)
+{
+ char *retstr;
+ int i;
+ /* Decode the Interrupt Type from Entity Assoc records */
+
+ retstr = tmpstr;
+ if (itype <= 0x0f) sprintf(retstr,"IRQ_%d",itype);
+ else if (itype <= 0x13) {
+ strcpy(retstr,"PCI-A");
+ for (i=0x10;i<itype;i++) retstr[4]++;
+ }
+ else if (itype == 0x14) strcpy(retstr,"SMI");
+ else if (itype == 0x15) strcpy(retstr,"SCI");
+ else if (itype >= 0x20 && itype <= 0x5f)
+ sprintf(retstr,"SysInt_%d",itype-0x20);
+ else if (itype == 0x60) strcpy(retstr,"ACPI/PnP");
+ else if (itype == 0xFF) strcpy(retstr,"NoInt");
+ else strcpy(retstr,"Invalid");
+ return(retstr);
+}
+
+int decode_oem_sensor(uchar *sdr,uchar *reading,char *pstring,int slen)
+{
+ int rv = -1;
+#ifdef METACOMMAND
+ switch(vend_id) {
+ case VENDOR_INTEL:
+ rv = decode_sensor_intel(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_KONTRON:
+ rv = decode_sensor_kontron(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_FUJITSU:
+ rv = decode_sensor_fujitsu(sdr,reading,pstring,slen);
+ break;
+ case VENDOR_SUN:
+ rv = decode_sensor_sun(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_MAGNUM:
+ case VENDOR_SUPERMICRO:
+ case VENDOR_SUPERMICROX:
+ rv = decode_sensor_supermicro(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_QUANTA:
+ rv = decode_sensor_quanta(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_HP:
+ rv = decode_sensor_hp(sdr, reading, pstring, slen);
+ break;
+ case VENDOR_DELL:
+ rv = decode_sensor_dell(sdr, reading, pstring, slen);
+ break;
+ default:
+ break;
+ } /*end-switch vend_id*/
+ if (fdebug && rv == 0)
+ printf("decode_oem_sensor rv=%d vend=%x string=%s\n",rv,vend_id,pstring);
+#endif
+ return (rv);
+}
+
+int show_oemsdr(int vend, uchar *sdr)
+{
+ int rv = -1;
+ int i, len;
+
+#ifdef METACOMMAND
+ if (vend == VENDOR_INTEL) {
+ show_oemsdr_intel(sdr); /*show subtypes for Intel BMC_TAM*/
+ rv = 0;
+ } else if (vend == 4156) { /*special HP/NewAccess OEM SDR*/
+ show_oemsdr_hp(sdr);
+ rv = 0;
+ } else if (vend == VENDOR_QUANTA) {
+ printf("Quanta: ");
+ show_oemsdr_nm(sdr);
+ rv = 0;
+ }
+#endif
+ if (rv != 0) {
+ len = sdr[4] + 5;
+ if (vend == VENDOR_FUJITSU) printf("Fujitsu: ");
+ else if (vend == VENDOR_INTEL) printf("Intel: ");
+ else printf("manuf=%d: ",vend);
+ for (i = 8; i < len; i++) printf("%02x ",sdr[i]);
+ printf("\n");
+ }
+ return(rv);
+}
+
+void
+ShowThresh(int flg, uchar bits, uchar *vals, uchar *sdr)
+{
+ char str[128] = "";
+ char part[24]; /* ~15 bytes used */
+ double ival;
+ char sep[4];
+ char *tag;
+ tag = "";
+ if (fsimple) {
+ sprintf(sep,"%c ",bdelim);
+ tag = "Thresholds";
+ } else sep[0] = 0; /*null string*/
+ if (fshowthr == 2) {
+ double i0, i1, i2, i3, i4, i5;
+ i0 = RawToFloat(vals[0],sdr);
+ i1 = RawToFloat(vals[1],sdr);
+ i2 = RawToFloat(vals[2],sdr);
+ i3 = RawToFloat(vals[3],sdr);
+ i4 = RawToFloat(vals[4],sdr);
+ i5 = RawToFloat(vals[5],sdr);
+ sprintf(str,"%.2f:%.2f:%.2f:%.2f:%.2f:%.2f",i0,i1,i2,i3,i4,i5);
+ printf("\t%s%s%s%c",sep,"Thresh ",str,chEol);
+ } else if (flg != 0) { /* Compact, did GetThresholds, reverse order */
+ if (bits & 0x20) {
+ ival = RawToFloat(vals[5],sdr);
+ sprintf(part,"%shi-unrec %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x10) {
+ ival = RawToFloat(vals[4],sdr);
+ sprintf(part,"%shi-crit %.2f ", sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x08) {
+ ival = RawToFloat(vals[3],sdr);
+ sprintf(part,"%shi-noncr %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x01) {
+ ival = RawToFloat(vals[0],sdr);
+ sprintf(part,"%slo-noncr %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x02) {
+ ival = RawToFloat(vals[1],sdr);
+ sprintf(part,"%slo-crit %.2f ", sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x04) {
+ ival = RawToFloat(vals[2],sdr);
+ sprintf(part,"%slo-unrec %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (flg == 2) {
+ if (sens_verbose) tag = "Volatile ";
+ printf("\t%s%s%s%c",sep,tag,str,chEol);
+ } else
+ printf("\t%s%s%s%c",sep,tag,str,chEol);
+ } else { /*Full SDR*/
+ if (fdebug) printf("ShowThresh[%x]: bits=%02x, sdr18=%02x %02x\n",
+ sdr[7],bits,sdr[18],sdr[19]);
+ if (bits & 0x20) {
+ ival = RawToFloat(vals[0],sdr);
+ sprintf(part,"%shi-unrec %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x10) {
+ ival = RawToFloat(vals[1],sdr);
+ sprintf(part,"%shi-crit %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x08) {
+ ival = RawToFloat(vals[2],sdr);
+ sprintf(part,"%shi-noncr %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x01) {
+ ival = RawToFloat(vals[5],sdr);
+ sprintf(part,"%slo-noncr %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x02) {
+ ival = RawToFloat(vals[4],sdr);
+ sprintf(part,"%slo-crit %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (bits & 0x04) {
+ ival = RawToFloat(vals[3],sdr);
+ sprintf(part,"%slo-unrec %.2f ",sep,ival);
+ strcat(str,part);
+ }
+ if (sens_verbose) tag = "SdrThres ";
+ printf("\t%s%s%s%c",sep,tag,str,chEol);
+ if (sens_verbose)
+ { /* show max/min & hysteresis from full sdr */
+ str[0] = 0;
+ ival = RawToFloat(sdr[31],sdr);
+ sprintf(part,"%snom %.2f ",sep,ival);
+ strcat(str,part);
+ ival = RawToFloat(sdr[32],sdr);
+ sprintf(part,"%snmax %.2f ",sep,ival);
+ strcat(str,part);
+ ival = RawToFloat(sdr[33],sdr);
+ sprintf(part,"%snmin %.2f ",sep,ival);
+ strcat(str,part);
+
+ ival = RawToFloat(sdr[34],sdr);
+ sprintf(part,"%ssmax %.2f ",sep,ival);
+ strcat(str,part);
+
+ ival = RawToFloat(sdr[35],sdr);
+ sprintf(part,"%ssmin %.2f ",sep,ival);
+ strcat(str,part);
+
+#ifdef OLD
+ ival = RawToFloat(sdr[42],sdr);
+ sprintf(part,"%s+hyst %.2f ",sep,ival);
+ strcat(str,part);
+
+ ival = RawToFloat(sdr[43],sdr);
+ sprintf(part,"%s-hyst %.2f ",sep,ival);
+ strcat(str,part);
+#endif
+
+ printf("\t%s%c",str,chEol);
+ }
+ } /*endif full sdr*/
+}
+
+/*
+ * decode_comp_reading
+ *
+ * Decodes the readings from compact SDR sensors.
+ * Use sensor_dstatus array for sensor reading types and meaning strings.
+ * Refer to IPMI Table 36-1 and 36-2 for this.
+ *
+ * Note that decoding should be based on sensor type and ev_type only,
+ * except for end cases.
+ *
+ * Note reading1 = sens_reading[2], reading2 = sens_reading[3]
+ */
+int
+decode_comp_reading(uchar type, uchar evtype, uchar num,
+ uchar reading1, uchar reading2)
+{
+ int istr = 0; /*string index into sensor_dstatus[] */
+ uchar b;
+ ushort reading;
+ static char customstr[35];
+
+ /* usually reading2 has h.o. bit set (0x80). */
+ reading = reading1 | ((reading2 & 0x7f) << 8);
+
+ switch(type)
+ {
+ case 0x01: /*Discrete Thermal, Temperature*/
+ if (fdebug)
+ printf("Discrete Thermal snum %x evtype=%x reading=%x\n",
+ num,evtype,reading);
+ if (evtype == 0x07) {
+ b = bitnum(reading);
+ if (b == 0) istr = 8; /*no bits set, "OK*"*/
+ else if (b < 3) istr = 0; /*bits 1,2 "OK"*/
+ else istr = 65; /*transition to error, Limit Exceeded*/
+ } else if (evtype == 0x05) {
+ /* see CPU1 VRD Temp on S5000, snum 0xc0 thru 0xcf */
+ if (reading & 0x01) istr = 65; /* Limit Exceeded*/
+ else istr = 0; /* "OK" LimitNotExceeded*/
+ } else if (evtype == 0x03) {
+ if (reading & 0x01) istr = 13; /* Asserted */
+ else istr = 0; /* "OK" Deasserted */
+ } else { /* evtype == other 0x05 */
+ if (reading & 0x01) istr = 0; /* 8="OK*", 0="OK" */
+ else istr = 5; /*state asserted, Crit-hi */
+ }
+ break;
+ case 0x02: /*Discrete Voltage*/
+ { /* evtype == 0x05 for VBat, 0x03 for VR Watchdog */
+ if (reading & 0x01) istr = 65; /*LimitExceeded, was Crit-hi*/
+ else istr = 0; /* "OK" LimitNotExceeded*/
+ }
+ break;
+ case 0x04: /*Fan*/
+ if (evtype == 0x0b) { /*redundancy*/
+ b = reading & 0x3f;
+ if (b == 0x00) istr = 16; /*sensor disabled*/
+ else if (b == 0x01) istr = 18; /*fully redundant*/
+ else if (b == 0x02) istr = 19; /*redundancy lost*/
+ else if (b == 0x0b) istr = STR_AC_LOST; /*ac lost*/
+ else istr = 20; /*redundancy degraded*/
+ } else if (evtype == 0x08) { /*presence*/
+ if (reading & 0x02) istr = 9; /*Present/Inserted*/
+ else if (reading & 0x01) istr = 10; /*Absent/Removed*/
+ else /*reading==00*/ istr = 47; /*Unused*/
+ } else if (evtype == 0x03) { /*PS Fan Fail*/
+ if (reading == 0) istr = 0; /*OK*/
+ else istr = 12; /*faulty*/
+ } else { /*other evtype*/
+ b = reading & 0x0f;
+ if (b == 0) istr = 12; /*faulty*/
+ else if (b & 0x01) istr = 11; /*ready*/
+ else istr = 41; /*Unknown*/
+ }
+ break;
+ case 0x05: /*Physical Security, Chassis */
+ if (reading == 0) istr = 0; /*OK*/
+ else if (reading & 0x01) istr = 38; /*chassis intrusion*/
+ /* 0x02 Drive bay intrusion */
+ /* 0x04 IO area intrusion */
+ /* 0x08 Processor area intrusion */
+ else if (reading & 0x10) istr = 37; /*lan leash lost*/
+ /* 0x20 Dock/Undock */
+ /* 0x40 Fan area intrusion */
+ else istr = 41; /* Unknown, was bitnum(reading); */
+ break;
+ case 0x07: /*Processor Status - 0x80 is OK/Present */
+ b = bitnum(reading);
+ if (evtype == 0x03) {
+ if (b <= 1) istr = 0; /*bit1 Deasserted, OK* */
+ else istr = 13; /*bit2 Asserted*/
+ } else { /*usu 0x6f*/
+ if (b > 10) istr = 41; /*Unknown*/
+ else if (b == 0) istr = 0; /*OK*/
+ else istr = 47 + b; /*Proc strings 48 thru 57*/
+ }
+ break;
+ case 0x08: /*Power Supply*/
+ b = reading & 0x7f;
+ if (b == 0) istr = 10; /*absent*/
+ else if (b & 0x40) istr = STR_PS_CONFIG; /*Config Err*/
+ else if (b & 0x08) istr = STR_AC_LOST; /*AC Lost*/
+ else if (b & 0x04) istr = 15; /*Predictive Fail*/
+ else if (b & 0x02) istr = STR_PS_FAIL; /*PS Fail*/
+ else if (b & 0x01) istr = 9; /*present*/
+ break;
+ case 0x09: /*Power Unit*/
+ b = reading & 0x3f;
+ if (evtype == 0x0b) { /*Power Redundancy*/
+ if (b == 0x00) istr = 16; /*sensor disabled*/
+ else if (b == 0x01) istr = 18; /*fully redundant*/
+ else if (b == 0x02) istr = 19; /*redundancy lost*/
+ else if (b == 0x0b) istr = STR_AC_LOST; /*ac lost*/
+ else istr = 20; /*redundancy degraded*/
+ } else { /* Power Unit (evtype==0x6f or 0xef) */
+ if (b == 0) istr = 17; /*enabled*/
+ else if ((b & 0x01) == 1) istr = 16; /*disabled*/
+ }
+ break;
+ case 0x0C: /* Memory */
+ b = reading & 0x3f;
+ if (b == 0) istr = 0; /*OK*/
+ else if (b & 0x01) istr = 8; /*Correctable ECC (OK*)*/
+ else if ((b & 0x02) || (b & 0x20)) istr = 39; /*ECC Error*/
+ else if (b & 0x04) istr = 40; /*Parity Error*/
+ else istr = bitnum(b); /* ECC or other error */
+ break;
+ case 0x0D: /* drive slot - usually HSC sens_ownid == 0xc0 */
+ if (fRomley) { /* evtype==0x6f, has both status and presence */
+ if (reading & 0x02) istr = 12; /*Faulty*/
+ else if (reading & 0x80) istr = STR_REBUILDING; /*Rebuilding*/
+ else if (reading & 0x01) istr = 9; /*Present (OK)*/
+ else istr = 10; /*Absent*/
+ } else {
+ if (evtype == 8) { /* HSC slot presence sensors (num > 8)*/
+ if (reading1 & 0x02) istr = 9; /*Present/Inserted*/
+ else if (reading1 & 0x01) istr = 10; /*Absent/Removed*/
+ else /*reading1==00*/ istr = 47; /*Unused*/
+ } else { /* HSC slot status sensors (evtype==0x6f) */
+ /* usually reading2 == 0x82 or 0x8E if healthy */
+ if (reading2 & 0x01) istr = 12; /*state8=Rebuild stopped*/
+ else if (reading2 & 0x02) istr = 11; /*state9=Inserted/Ready */
+ else if (reading2 & 0x04) istr = 11; /*state10=Safe_to_Remove*/
+ else if (reading2 & 0x08) istr = 11; /*state11=Ready */
+ else if (reading2 == 0x80) istr = 47; /*no states, Unused*/
+ else istr = 12; /*faulty*/
+ b = 8; /*if no bits set, no raid state */
+ if (reading1 & 0x01) { b = 0; } /*state0=Faulty*/
+ else if (reading1 & 0x02) b = 1; /*state1=Rebuilding*/
+ else if (reading1 & 0x04) b = 2; /*state2=InFailedArray*/
+ else if (reading1 & 0x08) b = 3; /*state3=InCriticalArray*/
+ else if (reading1 & 0x10) b = 4; /*state4=ParityCheck*/
+ else if (reading1 & 0x20) b = 5; /*state5=PredictedFault*/
+ else if (reading1 & 0x40) b = 6; /*state6=Un-configured*/
+ else if (reading1 & 0x80) b = 7; /*state7=HotSpare*/
+ if (b < 8) {
+ /* also include a raid_state, via custom string */
+ sprintf(customstr,"%s %s",
+ sensor_dstatus[istr], raid_states[b]);
+ istr = STR_CUSTOM;
+ sensor_dstatus[istr] = customstr;
+ if (fdebug) printf("dstatus=%s\n",sensor_dstatus[istr]);
+ }
+ } /*end-else HSC slot status*/
+ }
+ break;
+ case 0x10: /*Event Logging*/
+ /* usu evtype==0x6f*/
+ b = bitnum(reading & 0x3f);
+ switch (b) {
+ case 0x00: istr = 0; break; /*OK*/
+ case 0x01: istr = 59; break; /*MemLogDisabled*/
+ case 0x02: istr = 60; break; /*TypLogDisabled*/
+ case 0x03: istr = 61; break; /*LogCleared*/
+ case 0x04: istr = 62; break; /*AllLogDisabled*/
+ case 0x05: istr = 63; break; /*SelFull*/
+ case 0x06: istr = 64; break; /*SelNearFull*/
+ default: istr = 41; break; /*Unknown*/
+ }
+ break;
+ case 0x12: /*System Event*/
+ if (reading == 0) istr = 0;
+ else istr = 13; /*Asserted*/
+ break;
+ case 0x13: /*Critical Interrupt*/
+ /* valid bits: 0x03FF */
+ if (reading == 0) istr = 0; /*OK*/
+ else {
+ b = bitnum(reading); /* ECC or other error */
+ if (b > 10) b = 10;
+ istr = 24 + b;
+ }
+ break;
+ case 0x14: /*Button*/
+ if (reading == 0) istr = 0; /*OK*/
+ else istr = 13; /*Asserted*/
+ break;
+ case 0x15: /*Module/ Board */
+ if (evtype == 0x08) { /*presence*/
+ if (reading & 0x02) istr = 9; /*Present/Inserted*/
+ else if (reading & 0x01) istr = 10; /*Absent/Removed*/
+ else /*reading==00*/ istr = 47; /*Unused*/
+ }
+ break;
+ case 0x16: /* HSBP Status (esp. Romley) */
+ if (reading & 0x010) istr = STR_HSC_OFF; /*Offline*/
+ else istr = 0; /*OK*/
+ break;
+ case 0x17: /* ATCA CDM, Air Filter, Filter Tray */
+ if (reading == 0) istr = 0; /*OK*/
+ else if (reading & 0x01) istr = 10; /*Absent*/
+ else istr = bitnum(reading); /* other error, TODO: fix this */
+ break;
+ case 0x1C: /*Terminator (usu SCSI)*/
+ if (reading & 0x01) istr = 9; /*present*/
+ else istr = 10; /*missing,absent*/
+ break;
+ case 0x21: /*DIMM memory slot*/
+ if ((reading & 0x04) != 0) istr = 9; /*present*/
+ else istr = 10; /*absent*/
+ sprintf(customstr,"%s", sensor_dstatus[istr]);
+ if ((reading & 0x01) != 0) strcat(customstr,",Fault");
+ if ((reading & 0x0100) != 0) strcat(customstr,",Disabled");
+ istr = 58; /*use a custom string*/
+ sensor_dstatus[istr] = customstr;
+ if (fdebug) printf("dstatus=%s\n",sensor_dstatus[istr]);
+ break;
+ case 0x22: /*ACPI Power State*/
+ b = bitnum(reading);
+ switch(b) {
+ case 0: istr = 0; break; /*OK*/
+ case 1: istr = 22; break; /*Working*/
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 9:
+ case 10: istr = 23; break; /*Sleeping*/
+ case 6:
+ case 7:
+ case 8:
+ case 11:
+ case 13: istr = 21; break; /*Off*/
+ case 12: istr = 24; break; /*On*/
+ default: istr = 41; /*unknown*/
+ }
+ break;
+ case 0x23: /*Watchdog*/
+ if (reading == 0) istr = 0;
+ else istr = 13; /*Asserted*/
+ break;
+ case 0x24: /*Platform Alert*/
+ b = bitnum(reading);
+ switch(b) {
+ case 0: istr = 0; break; /*OK, no bits set*/
+ case 1: istr = 66; break; /*Page, bit 0 set*/
+ case 2: istr = 67; break; /*LAN, bit 1 set*/
+ case 3: istr = 68; break; /*PET*/
+ case 4: istr = 69; break; /*SNMP OEM*/
+ default: istr = 70; /*None*/
+ }
+ break;
+ case 0x25: /* Entity Presence */
+ if (reading & 0x01) istr = 8; /*Present*/
+ else if (reading & 0x02) istr = 9; /*Absent*/
+ else if (reading & 0x04) istr = 16; /*Disabled*/
+ else istr = 42; /* NotAvailable */
+ break;
+ case 0x28: /* BMC FW Health */
+ if (reading == 0) istr = 0; /*OK*/
+ else istr = 12; /*Faulty*/
+ break;
+ case 0x29: /* Battery */
+ switch(reading & 0x7f) {
+ case 0x00: istr = 0; break; /*OK*/
+ case 0x01: istr = 15; break; /*Predict Fail*/
+ case 0x04: istr = 9; break; /*Present*/
+ case 0x02:
+ default: istr = 12; break; /*Failed/Faulty*/
+ }
+ break;
+ case 0x2A: /* Session Audit (IPMI 2.0) */
+ if (reading == 0x00) istr = 45; /*Activated*/
+ else istr = 46; /*Deactivated*/
+ break;
+ case 0x2B: /* Version Change */
+ b = bitnum(reading1);
+ switch(b) {
+ case 0: istr = 0; break; /*OK, no bits set*/
+ case 1: istr = 72; break; /*HW Changed, bit 0 set*/
+ case 2: istr = 73; break; /*SW Changed, bit 1 set*/
+ case 3: istr = 74; break; /*HW incompatibility*/
+ default: istr = 75; break; /*Change error*/
+ }
+ break;
+ case 0x60: /* SCSI 1 Term Flt */
+ case 0x61: /* SCSI 2 Term Flt */
+ break;
+ /* sensor types 0xC0 - 0xFF are OEM RESERVED */
+ case 0xF1: /* ATCA IPMB-0 Sensor */
+ if ((reading & 0x7fff) == 0x0008) istr = 0; /*OK*/
+ else istr = bitnum(reading1); /* other error, TODO: refine this */
+ break;
+ case 0xC0: /* SMI State, NMI State */
+ case 0xD8: /* BIST */
+ case 0xF0: /* ATCA FRU HotSwap, TODO: refine this */
+ case 0xF2: /* ATCA Module HotSwap, TODO: refine this */
+ case 0xF3: /* SMI Timeout, etc. */
+ if (reading & 0x01) istr = 13; /* Asserted */
+ else istr = 0; /* "OK", Deasserted */
+ break;
+ default:
+ if (fdebug)
+ printf("sensor[%x] type %02x not decoded, reading = %04x\n",
+ num,type,reading);
+ istr = STR_OTHER; /* other " - " */
+ }
+ return(istr);
+} /* end decode_comp_reading */
+
+#define STYPSZ 15
+static char *get_stype_str(uchar stype)
+{ /*return sensor type string, with fixed length */
+ static char stype_str[STYPSZ+1];
+ char *tmpstr;
+ int i, n;
+ tmpstr = get_sensor_type_desc(stype);
+ n = strlen_(tmpstr);
+ if (n > STYPSZ) n = STYPSZ;
+ strncpy(stype_str,tmpstr,n);
+ for (i = n; i < STYPSZ; i++) stype_str[i] = ' ';
+ stype_str[i] = 0;
+ tmpstr = stype_str;
+ return(tmpstr);
+}
+
+void
+ShowSDR(char *tag, uchar *sdr)
+{
+ SDR01REC *sdr01;
+ SDR02REC *sdr02;
+ SDR08REC *sdr08;
+ SDR11REC *sdr11;
+ SDR12REC *sdr12;
+ SDR14REC *sdr14;
+ SDRc0REC *sdrc0;
+ char idstr[32];
+ char *typestr = NULL;
+ int vend;
+ int len, ilen, i, j;
+ int ioff;
+ uchar sens[4];
+ uchar sens_cap;
+ uchar shar_cnt;
+ int rc;
+ double val;
+ char brearm;
+ uchar sep[4];
+ char rdgstr[50];
+
+ len = sdr[4] + 5;
+ sens_cap = 0x80; /*ignore*/
+ if (fdebug) printf("ShowSDR: len=%d, type=%x\n",len,sdr[3]);
+ memset(sens,0,4);
+ if (frawsdr || fdebug) {
+ printf("raw SDR: ");
+ for (i = 0; i < len; i++)
+ printf("%02x ",sdr[i]);
+ printf("\n");
+ }
+ switch(sdr[3])
+ {
+ case 0x01: /* Full sensor record */
+ sdr01 = (SDR01REC *)sdr;
+ ioff = 48;
+ if (ioff > len) {
+ if (fdebug) printf("bad length: type=%x, len=%d, ioff=%d\n",
+ sdr[3],len,ioff);
+ printf("Bad SDR Length, please apply the correct FRU/SDR diskette\n");
+ return;
+ }
+ sens_cap = sdr[11]; /*sdr01->sens_capab*/
+ ilen = len - ioff;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[ioff],ilen);
+ for (i=ilen; i<16; i++) { idstr[i] = ' '; ilen++; }
+ idstr[ilen] = 0; /* stringify */
+ if ((sdr01->sens_capab & 0x40) == 0) brearm = 'm'; /*manual rearm*/
+ else brearm = 'a'; /*automatic rearm*/
+ if (fdebug) printf("entity %d.%d, idlen=%d sizeof=%d idstr0=%c s0=%x\n",
+ sdr01->entity_id, sdr01->entity_inst,
+ ilen,sizeof(SDR01REC),idstr[0],sdr[ioff]);
+ rc = GetSensorReading(sdr01->sens_num,sdr01,sens);
+ if (rc != 0) { /* if rc != 0, leave sens values zero */
+ i = 41; /* Unknown */
+ val = 0;
+ if (rc == 0xCB) { /*sensor not present*/
+ i = 10; /* Absent */
+ typestr = "na";
+ } else typestr = decode_rv(rc);
+ } else {
+ j = (sens[2] & 0x3f); /*sensor reading state*/
+ i = bitnum((ushort)j); /*sensor_dstatus index*/
+ if (fdebug)
+ printf("bitnum(%02x)=%d raw=%02x init=%x base/units=%x/%x\n",
+ sens[2],i,sens[0],sens[1],sdr01->sens_base,
+ sdr01->sens_units);
+ if ((sens[1] & 0x20) != 0) { i = 7; val = 0; } /* Init state */
+ else val = RawToFloat(sens[0],sdr);
+ typestr = get_unit_type(sdr01->sens_units, sdr01->sens_base,
+ sdr01->sens_mod, fsimple);
+#ifdef WRONG
+ if (is_romley(vend_id,prod_id) &&
+ (sdr01->sens_type == 0x0C) && (sdr01->sens_units & 0x01))
+ { /* Intel Memory Thermal Throttling %, raw 0x01 == 0.5 % */
+ val = (val / 2); /* handle MTT SDR errata */
+ } /*correct solution is to fix the SDR m-value instead */
+#endif
+ }
+ rc = decode_oem_sensor(sdr,sens,oem_string,sizeof(oem_string));
+ if (rc == 0) {
+ strncpy(rdgstr,oem_string,sizeof(rdgstr));
+ } else {
+ if (fsimple)
+ snprintf(rdgstr,sizeof(rdgstr),"%s %c %.2f %s",
+ sensor_dstatus[i],bdelim,val,typestr);
+ else
+ snprintf(rdgstr,sizeof(rdgstr),"%02x %s %.2f %s",
+ sens[0], sensor_dstatus[i],val,typestr);
+ }
+ sep[0] = 0; /*null string*/
+ printf("%s", tag);
+ if (fsimple) {
+ sprintf(sep,"%c ",bdelim);
+ printf("%04x %c Full %c %s %c %02x %c %s %c %s%c",
+ sdr01->recid, bdelim, bdelim,
+ get_stype_str(sdr01->sens_type),
+ bdelim, sdr01->sens_num,bdelim, idstr,
+ bdelim,rdgstr,chEol);
+ } else
+ printf("%04x SDR Full %02x %02x %02x %c %02x snum %02x %s = %s%c",
+ sdr01->recid, sdr01->rectype, sdr01->ev_type,
+ sdr01->sens_ownid, brearm, sdr01->sens_type, sdr01->sens_num,
+ idstr, rdgstr, chEol);
+ if (fdebug && fshowthr)
+ printf("cap=%02x settable=%02x, readable=%02x\n",
+ sens_cap,sdr[19],sdr[18]);
+ if (sens_verbose) /* if -v, also show Entity ID */
+ printf("\t%sEntity ID %d.%d (%s), Capab: %s%c",
+ sep, sdr01->entity_id, sdr01->entity_inst,
+ decode_entity_id(sdr01->entity_id), // sens_cap,
+ decode_capab(sens_cap),chEol);
+ if (fshowthr && (sens_cap & 0x0f) != 0x03) {
+ uchar thresh[7];
+ /* Thresholds, so show them */
+ /* Use settable bits to show thresholds, since the
+ * readable values will be off for Full SDRs.
+ * If cant set any thresholds, only show SDR thresholds */
+ if (sdr[19] == 0) rc = 1;
+ else {
+ /* Show volatile thresholds. */
+ rc = GetSensorThresholds(sdr01->sens_num,&thresh[0]);
+ if (rc == 0) ShowThresh(2,thresh[0],&thresh[1],sdr);
+ }
+ /* Show SDR non-volatile thresholds. */
+ if (sens_verbose || rc !=0) ShowThresh(0,sdr[18],&sdr[36],sdr);
+ // ShowThresh(0,0x3f,&sdr[36],sdr); /* to show all %%%% */
+ }
+ if (fwrap) { /* (chEol != '\n') include time */
+ time_t ltime;
+ time(&ltime);
+ if (fsimple)
+ printf("%c %s",bdelim,ctime(&ltime)); /*ctime has '\n' */
+ else
+ printf("at %s",ctime(&ltime)); /*ctime has '\n' */
+ }
+ break;
+ case 0x02: /* Compact sensor record */
+ sdr02 = (SDR02REC *)sdr;
+ ioff = 32;
+ if (ioff > len) {
+ if (fdebug) printf("bad length: type=%x, len=%d, ioff=%d\n",
+ sdr[3],len,ioff);
+ printf("Bad SDR Length, please apply the correct FRU/SDR diskette\n");
+ return;
+ }
+ sens_cap = sdr[11]; /*sdr02->sens_capab*/
+ shar_cnt = sdr02->shar_cnt & 0x0f; /*sdr[23]*/
+ ilen = len - ioff;
+ if ((ilen+1) >= sizeof(idstr)) ilen = sizeof(idstr) - 2;
+ memcpy(idstr,&sdr[ioff],ilen);
+ if ((shar_cnt > 1) && (sdr02->shar_off & 0x80) != 0) { /*do shared SDR*/
+ j = (sdr02->shar_off & 0x7f); /*sdr[24] = modifier offset*/
+ if (fdebug) printf("share count = %d, mod_offset = %d\n",shar_cnt,j);
+ if ((sdr02->shar_cnt & 0x10) != 0) { /*alpha*/
+ idstr[ilen++] = 0x40 + j; /* j=1 -> 'A' */
+ idstr[ilen] = 0; /* stringify */
+ } else { /*numeric*/
+ sprintf(&idstr[ilen],"%d",j);
+ ilen = strlen_(idstr);
+ }
+ } /* else normal idstr */
+ for (i=ilen; i<16; i++) { idstr[i] = ' '; ilen++; }
+ idstr[ilen] = 0; /* stringify */
+ if ((sdr02->sens_capab & 0x40) == 0) brearm = 'm'; /*manual rearm*/
+ else brearm = 'a'; /*automatic rearm*/
+ if (fdebug) printf("ilen=%d, istr0=%c, sizeof=%d, s0=%x\n",
+ ilen,idstr[0],sizeof(SDR02REC),sdr[ioff]);
+ memset(sens,0,sizeof(sens));
+ rc = GetSensorReading(sdr02->sens_num,sdr02,sens);
+ if (rc != 0) { /* if rc != 0, leave sens values zero */
+ i = 41; /* Unknown */
+ val = 0;
+ if (rc == 0xCB) { /*sensor not present*/
+ i = 10; /* Absent */
+ typestr = "na";
+ } else typestr = decode_rv(rc);
+ } else {
+ if ((sens[1] & 0x20) != 0) i = 42; /*init state, NotAvailable*/
+ else {
+ rc = decode_oem_sensor(sdr,sens,oem_string,sizeof(oem_string));
+ if (rc == 0) i = STR_OEM;
+ else i = decode_comp_reading(sdr02->sens_type,sdr02->ev_type,
+ sdr02->sens_num,sens[2],sens[3]);
+ }
+ }
+ if (fdebug)
+ printf("snum %x type %x evt %x reading %02x%02x i=%d rc=%d %s\n",
+ sdr02->sens_num,sdr02->sens_type,sdr02->ev_type,
+ sens[3],sens[2],i,rc, decode_rv(rc));
+ j = sens[2] | ((sens[3] & 0x7f) << 8); /*full reading, less h.o. bit*/
+ sep[0] = 0; /*null string*/
+ printf("%s", tag);
+ if (fsimple) {
+ sprintf(sep,"%c ",bdelim);
+ printf("%04x %c Compact %c %s %c %02x %c %s %c %s %c%c",
+ sdr02->recid, bdelim, bdelim,
+ get_stype_str(sdr02->sens_type),
+ bdelim, sdr02->sens_num, bdelim, idstr,
+ bdelim, sensor_dstatus[i],bdelim,chEol);
+ } else if (i == STR_OEM) {
+ // idstr[ilen] = 0; /*cut out padding in idstr*/
+ printf("%04x SDR Comp %02x %02x %02x %c %02x snum %02x %s = %04x %s%c",
+ sdr02->recid, sdr02->rectype, sdr02->ev_type,
+ sdr02->sens_ownid, brearm, sdr02->sens_type, sdr02->sens_num,
+ idstr, j, sensor_dstatus[i],chEol);
+ // sensor_dstatus[i] == oem_string
+ } else {
+ printf("%04x SDR Comp %02x %02x %02x %c %02x snum %02x %s = %04x %s%c",
+ sdr02->recid, sdr02->rectype, sdr02->ev_type,
+ sdr02->sens_ownid, brearm, sdr02->sens_type, sdr02->sens_num,
+ idstr, j, sensor_dstatus[i],chEol);
+ /* idstr, sens[0], sens[1], sens[2], sens[3], */
+ }
+ if (fdebug && fshowthr)
+ printf("cap=%02x settable=%02x, readable=%02x\n",
+ sens_cap,sdr[19],sdr[18]);
+ if (fshowthr) /*also show Entity ID */
+ printf("\t%sEntity ID %d.%d (%s), Capab: %s%c",
+ sep, sdr02->entity_id, sdr02->entity_inst,
+ decode_entity_id(sdr02->entity_id), // sens_cap,
+ decode_capab(sens_cap),chEol);
+ if (fshowthr &&
+ ((sens_cap & 0x80) == 0) && (sens_cap & 0x0C) != 0) {
+ uchar thresh[7];
+ /* Thresholds, show them */
+ /* Use readable bits to get & show thresholds */
+ if (sdr[20] != 0) {
+ rc = GetSensorThresholds(sdr02->sens_num,&thresh[0]);
+ if (rc == 0) ShowThresh(1,thresh[0],&thresh[1],sdr);
+ }
+ }
+ if (fwrap) { /*include time and \n */
+ time_t ltime;
+ time(&ltime);
+ if (fsimple)
+ printf("%c %s",bdelim,ctime(&ltime)); /*ctime has '\n' */
+ else
+ printf("at %s",ctime(&ltime)); /*ctime has '\n' */
+ }
+ break;
+ case 0x03: /* Event-only sensor record, treat like Compact SDR */
+ sdr02 = (SDR02REC *)sdr;
+ ioff = 17;
+ if (ioff > len) {
+ printf("Bad SDR %x Length %d. Please apply the correct FRU/SDR diskette\n",
+ sdr02->recid, len);
+ return;
+ }
+ if (!fsimple)
+ {
+ ilen = len - ioff;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[ioff],ilen);
+ for (i=ilen; i<16; i++) { idstr[i] = ' '; ilen++; }
+ idstr[ilen] = 0; /* stringify */
+ sens_cap = sdr[11];
+ memset(sens,0,sizeof(sens));
+ if ((sdr02->sens_capab & 0x40) == 0) brearm = 'm'; /*manual rearm*/
+ else brearm = 'a'; /*automatic rearm*/
+ // rc = GetSensorReading(sdr02->sens_num,sdr02,sens);
+ /* EvtOnly SDRs do not support readings.
+ * GetSensorReading would return ccode=0xCB (not present),
+ * but this skips error msg */
+ rc = 0xCB;
+ i = bitnum((ushort)sens[2]);
+ j = sens[2] | ((sens[3] & 0x7f) << 8);
+ printf("%s",tag);
+ printf("%04x SDR EvtO %02x %02x %02x %c %02x snum %02x %s = %04x %s\n",
+ sdr02->recid, sdr02->rectype, sdr02->reclen,
+ sdr02->sens_ownid, 'a', sdr[10], sdr02->sens_num,
+ idstr, j, sensor_dstatus[i]);
+ // sens[0], sens[1], sens[2], sens[3], sensor_dstatus[i]
+ }
+ break;
+ case 0x08: /* Entity Association record */
+ sdr08 = (SDR08REC *)sdr;
+ if (!fsimple)
+ {
+ printf("%s",tag);
+ printf("%04x SDR EntA %02x %02x %02x %02x %02x: ",
+ sdr08->recid, sdr08->rectype, sdr08->reclen,
+ sdr08->contid, sdr08->continst, sdr08->flags);
+ for (i = 0; i < 8; i++) printf("%02x ",sdr08->edata[i]);
+ printf("\n");
+ }
+ break;
+ case 0x09: /* Device-relative Entity Association record */
+ sdr08 = (SDR08REC *)sdr; /*but SDR09 is 26 bytes*/
+ if (!fsimple)
+ {
+ printf("%s",tag);
+ printf("%04x SDR DEnt %02x %02x %02x %02x %02x %02x %02x: ",
+ sdr08->recid, sdr08->rectype, sdr08->reclen,
+ sdr08->contid, sdr08->continst, sdr08->flags,
+ sdr08->edata[0], sdr08->edata[1]);
+ /*display 2 of 4 contained entity devices edata[2-10] */
+ for (i = 2; i < 8; i++) printf("%02x ",sdr08->edata[i]);
+ printf("\n");
+ }
+ break;
+ case 0x10: /* Generic Device Locator record */
+ sdr11 = (SDR11REC *)sdr;
+ ioff = 16;
+ if (ioff > len) {
+ if (fdebug) printf("SDR %x bad length: type=%x, len=%d, ioff=%d\n",
+ sdr11->recid, sdr[3],len,ioff);
+ return;
+ }
+ if (!fsimple)
+ {
+ ilen = len - ioff;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[ioff],ilen);
+ idstr[ilen] = 0; /* stringify */
+ printf("%s", tag);
+ if (fsimple)
+ printf("DevLocator record[%x]%c device %02x %c %s\n",
+ sdr11->recid, bdelim,sdr11->dev_slave_adr,bdelim,idstr);
+ else
+ printf("%04x SDR DLoc %02x %02x dev: %02x %02x %02x %02x %02x %02x %s\n",
+ sdr11->recid, sdr11->rectype, sdr11->reclen,
+ sdr11->dev_access_adr, sdr11->dev_slave_adr,
+ sdr11->access_lun, sdr[8], sdr[10], sdr[11],
+ idstr);
+ }
+ break;
+ case 0x11: /* FRU record */
+ sdr11 = (SDR11REC *)sdr;
+ ioff = 16;
+ if (ioff > len) {
+ if (fdebug) printf("SDR %x bad length: type=%x len=%d ioff=%d\n",
+ sdr11->recid, sdr[3],len,ioff);
+ printf("Please apply the correct FRU/SDR diskette\n");
+ return;
+ }
+ if (!fsimple)
+ {
+ ilen = len - ioff;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[ioff],ilen);
+ idstr[ilen] = 0; /* stringify */
+ if (fdebug) printf("ilen=%d, istr0=%c, sizeof=%d, s0=%x\n",
+ ilen,idstr[0],sizeof(SDR11REC),sdr[ioff]);
+ printf("%s", tag);
+ if (fsimple)
+ printf("FRU record[%x]: device %02x : %s\n",
+ sdr11->recid, sdr11->dev_slave_adr,idstr);
+ else
+ printf("%04x SDR FRU %02x %02x dev: %02x %02x %02x %02x %02x %02x %s\n",
+ sdr11->recid, sdr11->rectype, sdr11->reclen,
+ sdr11->dev_access_adr, sdr11->dev_slave_adr /*fru_id*/,
+ sdr11->access_lun, sdr11->chan_num,
+ sdr11->entity_id, sdr11->entity_inst,
+ idstr);
+ }
+ break;
+ case 0x12: /* IPMB record */
+ sdr12 = (SDR12REC *)sdr;
+ ioff = 16;
+ if (ioff > len) {
+ if (fdebug) printf("bad length: type=%x, len=%d, ioff=%d\n",
+ sdr[3],len,ioff);
+ printf("Please apply the correct FRU/SDR diskette\n");
+ return;
+ }
+ if (!fsimple)
+ {
+ ilen = len - ioff;
+ if (ilen >= sizeof(idstr)) ilen = sizeof(idstr) - 1;
+ memcpy(idstr,&sdr[ioff],ilen);
+ idstr[ilen] = 0; /* stringify */
+ if (fdebug) printf("ilen=%d, istr0=%c, sizeof=%d, s0=%x\n",
+ ilen,idstr[0],sizeof(SDR12REC),sdr[ioff]);
+ printf("%s", tag);
+ if (fsimple)
+ printf("IPMB record[%x]%c addr %02x %02x %c %s\n",
+ sdr12->recid, bdelim,sdr12->dev_slave_adr,
+ sdr12->chan_num,bdelim,idstr);
+ else
+ printf("%04x SDR IPMB %02x %02x dev: %02x %02x %02x %02x %02x %s\n",
+ sdr12->recid, sdr12->rectype, sdr12->reclen,
+ sdr12->dev_slave_adr, sdr12->chan_num, sdr12->dev_capab,
+ sdr12->entity_id, sdr12->entity_inst,
+ idstr);
+ }
+ break;
+ case 0x14: /* BMC Message Channel Info record */
+ sdr14 = (SDR14REC *)sdr;
+ if(!fsimple){
+ printf("%s", tag);
+ printf("%04x SDR BMsg %02x %02x: ",
+ sdr14->recid, sdr14->rectype, sdr14->reclen );
+ for (i = 0; i < 8; i++) printf("%02x ",sdr14->mdata[i]);
+ printf("%s %s %02x\n",decode_itype(sdr14->mint),
+ decode_itype(sdr14->eint), sdr14->rsvd);
+ }
+ break;
+ case 0xc0: /* OEM SDR record (manuf_id 343. = Intel) */
+ sdrc0 = (SDRc0REC *)sdr;
+ if(!fsimple)
+ {
+ vend = sdrc0->manuf_id[0] + (sdrc0->manuf_id[1] << 8)
+ + (sdrc0->manuf_id[2] << 16);
+ printf("%s",tag);
+ printf("%04x SDR OEM %02x %02x ",
+ sdrc0->recid, sdrc0->rectype, sdrc0->reclen);
+ show_oemsdr(vend,sdr);
+ }
+ break;
+ default:
+ sdrc0 = (SDRc0REC *)sdr;
+ /* also saw type = 0x08 & 0x14 on STL2s */
+ if (!fsimple){
+ printf("%s", tag);
+ printf("%04x SDR type=%02x ", sdrc0->recid, sdr[3]);
+ for (i = 0; i < len; i++) printf("%02x ",sdr[i]);
+ printf("\n");
+ }
+ }
+ return;
+}
+
+static int
+ShowPowerOnHours(void)
+{
+ uchar resp[MAX_BUFFER_SIZE];
+ int sresp = MAX_BUFFER_SIZE;
+ uchar cc;
+ int rc = -1;
+ int i;
+ unsigned int hrs;
+
+ if (fmBMC) return(0);
+ if (fsimple) return(0);
+ sresp = MAX_BUFFER_SIZE;
+ memset(resp,0,6); /* default response size is 5 */
+ rc = ipmi_cmd_mc(GET_POWERON_HOURS, NULL, 0, resp, &sresp, &cc, fdebug);
+ if (rc == 0 && cc == 0) {
+ /* show the hours (32-bits) */
+ hrs = resp[1] | (resp[2] << 8) | (resp[3] << 16) | (resp[4] << 24);
+ if (resp[0] == 0) /*avoid div-by-zero*/ i = 1;
+ else if (resp[0] == 60) /*normal*/ i = 1;
+ else {
+ i = 60 / resp[0];
+ hrs = hrs / i;
+ }
+ printf(" SDR IPMI sensor: Power On Hours \t = %d hours\n",
+ hrs);
+ }
+ if (fdebug) {
+ printf("PowerOnHours (rc=%d cc=%x len=%d): ",rc,cc,sresp);
+ if (rc == 0)
+ for (i = 0; i < sresp; i++) printf("%02x ",resp[i]);
+ printf("\n");
+ }
+ return(rc);
+}
+
+int SaveThreshold(int id, int sensor_num, int sensor_lo, int sensor_hi,
+ uchar *thr_set)
+{
+ int rv = 0;
+ char lostr[20];
+ char histr[20];
+ FILE *fd;
+
+ /* persist the thresholds by re-applying with ipmiutil sensor commands.*/
+ if (thr_set != NULL) {
+ sprintf(lostr,"-u 0x%02x%02x%02x%02x%02x%02x",
+ sensor_thr[0], sensor_thr[1], sensor_thr[2],
+ sensor_thr[3], sensor_thr[4], sensor_thr[5]);
+ histr[0] = 0; /*empty string*/
+ } else {
+ if (sensor_lo != 0xff) {
+ sprintf(lostr,"-l 0x%02x",sensor_lo);
+ } else lostr[0] = 0;
+ if (sensor_hi != 0xff) {
+ sprintf(histr,"-h 0x%02x",sensor_hi);
+ } else histr[0] = 0;
+ }
+ fd = fopen(savefile,"a+");
+ if (fd == NULL) return(-1);
+ fprintf(fd, "ipmiutil sensor -i 0x%04x -n 0x%02x %s %s\n", id, sensor_num,
+ lostr,histr);
+ fclose(fd);
+ return(rv);
+}
+
+#ifdef NOT_USED
+#define PICMG_GET_ADDR_INFO 0x01
+static int get_picmg_addrinfo(uchar a1, uchar a2, uchar *addrdata)
+{
+ uchar idata[5];
+ uchar rdata[16];
+ int rlen;
+ ushort icmd;
+ uchar ilen, cc;
+ int rv;
+
+ idata[0] = 0x00;
+ idata[1] = 0x00;
+ idata[2] = 0x03;
+ idata[3] = a1; /* 01 thru 0f */
+ idata[4] = a2; /* 00, 01 thru 09 */
+ ilen = 5;
+ rlen = sizeof(rdata);
+ icmd = PICMG_GET_ADDR_INFO | (NETFN_PICMG << 8);
+ rv = ipmi_cmd_mc(icmd, idata, ilen, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ if (fdebug) {
+ printf("picmg_addr(%02x,%02x)",a1,a2);
+ dump_buf("picmg_addr",rdata,rlen,0);
+ }
+ memcpy(addrdata,rdata,rlen);
+ }
+ return(rv);
+}
+#endif
+
+#ifdef WIN32
+static int get_filesize(char *fileName, ulong *psize)
+{
+ int rv;
+ WIN32_FILE_ATTRIBUTE_DATA fileInfo;
+
+ if (fileName == NULL) return -1;
+ if (psize == NULL) return -1;
+ rv = GetFileAttributesEx(fileName, GetFileExInfoStandard, (void*)&fileInfo);
+ if (!rv) return -1;
+ *psize = (long)fileInfo.nFileSizeLow;
+ return 0;
+}
+#endif
+
+int read_sdr_binfile(char *binfile, uchar **pbufret, int *buflen)
+{
+ uchar *pbuf = NULL;
+ FILE *fp;
+ int len;
+ int ret;
+#ifdef WIN32
+ {
+ ulong flen;
+ ret = get_filesize(binfile, &flen);
+ if (ret == 0) len = flen;
+ else {
+ ret = get_LastError();
+ printf("Cannot get file size for %s, error %d\n",binfile,ret);
+ return(ret);
+ }
+ }
+#endif
+ fp = fopen(binfile,"r");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ return(ret);
+ }
+#ifndef WIN32
+ {
+ struct stat st;
+ /* use fstat to get file size and allocate buffer */
+ ret = fstat(fileno(fp), &st);
+ len = st.st_size; /*file size in bytes*/
+ if (ret != 0) {
+ ret = get_LastError();
+ printf("Cannot stat file %s, error %d\n",binfile,ret);
+ return(ret);
+ }
+ }
+#endif
+ // len = nsdrs * SDR_SZ; /*estimate max size for n sdrs*/
+ sz_sdrs = len;
+ pbuf = malloc(len);
+ if (fdebug) printf("restore: malloc(%d) pbuf=%p\n",len,pbuf);
+ if (pbuf == NULL) {
+ ret = -1;
+ fclose(fp);
+ return(ret);
+ }
+ /*ok, so proceed with restore*/
+ ret = 0;
+ len = (int)fread(pbuf, 1, sz_sdrs, fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d reading file %s\n",ret,binfile);
+ sz_sdrs = 0; /*for safety*/
+ }
+ fclose(fp);
+ if (fdebug) {
+ printf("SDR buffer from file (len=%d,sz=%d)\n",len,sz_sdrs);
+ dump_buf("SDR buffer",pbuf,len,1);
+ }
+ *pbufret = pbuf;
+ *buflen = len;
+ return(ret);
+}
+
+#ifdef ALONE
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#else
+/* METACOMMAND or libipmiutil */
+int i_sensor(int argc, char **argv)
+#endif
+{
+ int ret, rv;
+ int c;
+ int recid, recnext;
+ uchar sdrdata[MAX_BUFFER_SIZE];
+ uchar devrec[16];
+ int sz, i, j;
+ int fsetfound = 0;
+ int iloop;
+ int ipass, npass;
+ uchar *pset;
+ char *p;
+ char *s1;
+
+ printf("%s: version %s\n",progname,progver);
+
+ while ( (c = getopt( argc, argv,"a:bcd:ef:g:h:i:j:l:m:n:opqrstu:vwxT:V:J:L:EYF:P:N:R:U:Z:?")) != EOF )
+ switch(c) {
+ case 'a': /* reArm sensor number N */
+ if (strncmp(optarg,"0x",2) == 0) frearm = htoi(&optarg[2]);
+ else frearm = htoi(optarg); /*was atoi()*/
+ break;
+ case 'c': fsimple = 1; break; /* Canonical/simple output*/
+ case 'd': fdump = 1; /* Dump SDRs to a file*/
+ binfile = optarg; break;
+ case 'b': fchild = 1; break; /* Bladed, so get child SDRs */
+ case 'e': fchild = 1; break; /* Extra bladed child SDRs */
+ case 'f': frestore = 1; /* Restore SDRs from a file*/
+ binfile = optarg; break;
+ case 's': fsimple = 1; break; /* Simple/canonical output */
+ /*fcanonical==fsimple*/
+ case 'g':
+ rv = get_group_id(optarg);
+ if (rv < 0) {
+ printf("Unrecognized sensor type group (%s)\n",optarg);
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ } else fshowgrp = rv;
+ if (fdebug) printf("num sensor type groups = %d\n",fshowgrp);
+ break;
+ case 'i':
+ fshowidx = 1;
+ get_idx_range(optarg);
+ break;
+ case 'j': fjumpstart = 1; /* Load SDR cache from a file*/
+ binfile = optarg; break;
+ case 't': fshowthr = 1; break;
+ case 'v': fshowthr = 1; sens_verbose = 1; break;
+ case 'p': fsavethresh = 1; break;
+ case 'q': fshowthr = 2; fwrap = 1; break;
+ case 'r': frawsdr = 1; break;
+ case 'm': /* specific MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ fset_mc = 1;
+ printf("set MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'o':
+ fgetmem = 1;
+ break;
+ case 'n':
+ if (strncmp(optarg,"0x",2) == 0) i = htoi(&optarg[2]);
+ else i = htoi(optarg); /*was atoi()*/
+ sensor_num = (uchar)i;
+ printf("sensor_num = 0x%x\n",sensor_num);
+ break;
+ case 'h': /* highest threshold */
+ if (strncmp(optarg,"0x",2) == 0) {
+ i = htoi(&optarg[2]);
+ sensor_hi = (uchar)i;
+ fsetthresh = 1;
+ } else {
+ sensor_hi_f = atof(optarg);
+ fsetthresh = 2; /*indicates float conversion*/
+ }
+ break;
+ case 'l': /* lowest threshold */
+ if (strncmp(optarg,"0x",2) == 0) {
+ i = htoi(&optarg[2]);
+ sensor_lo = (uchar)i;
+ fsetthresh = 1;
+ } else {
+ sensor_lo_f = atof(optarg);
+ fsetthresh = 2; /*indicates float conversion*/
+ }
+ break;
+ case 'u': /* specify unique thresholds in hex or float */
+ /* raw hex format: 0xLNLCLUHNHCHU, all 6 required */
+ if (strncmp(optarg,"0x",2) == 0) { /*raw hex thresholds*/
+ sensor_thr[0] = htoi(&optarg[2]); /*lo noncrit*/
+ sensor_thr[1] = htoi(&optarg[4]); /*lo crit*/
+ sensor_thr[2] = htoi(&optarg[6]); /*lo unrec*/
+ sensor_thr[3] = htoi(&optarg[8]); /*hi noncrit*/
+ sensor_thr[4] = htoi(&optarg[10]); /*hi crit*/
+ sensor_thr[5] = htoi(&optarg[12]); /*hi unrec*/
+ /* validate sensor threshold ordering */
+ rv = validate_thresholds(&sensor_thr[0],0,NULL);
+ if (rv == 0) {
+ sensor_lo = sensor_thr[0];
+ sensor_hi = sensor_thr[3];
+ fsetthresh = 3; /*indicates unique raw thresholds */
+ } else {
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ } else {
+ /* assume float input thresholds, with ':' separator*/
+ /* format LN:LC:LU:HN:HC:HU */
+ sz = strlen_(optarg);
+ p = &optarg[0];
+ for (i = 0; i < 6; i++) sensor_thrf[i] = THR_EMPTY;
+ j = 0;
+ for (i = 0; i <= sz; i++) {
+ if (j >= 6) break;
+ switch(optarg[i]) {
+ case ':':
+ case '\n':
+ case '\0':
+ optarg[i] = 0;
+ if (p[0] == 0) sensor_thrf[j] = THR_EMPTY;
+ else sensor_thrf[j] = atof(p);
+ if (i+1 < sz) p = &optarg[i+1];
+ j++;
+ break;
+ default:
+ break;
+ }
+ }
+ /* validate sensor threshold ordering later */
+ // rv = validate_thresholds(&sensor_thrf[0],1,NULL);
+ // if (rv == 0) {
+ sensor_lo_f = sensor_thrf[0];
+ sensor_hi_f = sensor_thrf[3];
+ fsetthresh = 4; /*indicates unique float thresholds */
+ // } else {
+ // ret = ERR_BAD_PARAM;
+ // goto do_exit;
+ // }
+ } /*end-else -u float thresholds*/
+ break;
+ case 'w': fwrap = 1; break;
+ case 'x': fdebug = 1; break;
+ case 'L': /* Loop */
+ nloops = atoi(optarg);
+ fdoloop = 1;
+ break;
+ case 'V': /* priv level */
+ fprivset = 1;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default: /*usage*/
+ printf("Usage: %s [-abcdefghijlmnprstuvwxL -NUPREFTVY]\n",progname);
+ printf("where -x shows eXtra debug messages\n");
+ printf(" -a snum reArms the sensor (snum) for events\n");
+ printf(" -b show Bladed child MCs for PICMG (same as -e)\n");
+ printf(" -c displays a simpler, Canonical output fmt\n");
+ printf(" -d file Dump SDRs to a binary file\n");
+ printf(" -e show Every bladed child MC for PICMG\n");
+ // printf(" -f file Restore SDRs from a binary dump file\n");
+ printf(" -g fan show only this sensor type group\n");
+ printf(" -h tval specifies the Highest threshold to set\n");
+ printf(" -i id only show these sensor ids\n");
+ printf(" -j file Jump-start SDR cache from a binary file\n");
+ printf(" -l tval specifies the Lowest threshold to set\n");
+ printf(" -m002000 specific MC (bus 00,sa 20,lun 00)\n");
+ printf(" -n snum specifies the sensor Number to set hi/lo\n");
+ printf(" -o output memory DIMM information\n");
+ printf(" -p persist the threshold being set\n");
+ printf(" -q shows threshold values in d:d:d format\n");
+ printf(" -r show Raw SDR bytes\n");
+ printf(" -s displays a Simpler output format\n");
+ printf(" -t shows Threshold values in text format\n");
+ printf(" -u thr set Unique threshold values (e.g. 3:2:1:48:49:50)\n");
+ printf(" -v Verbose: thresholds, max/min, hysteresis\n");
+ printf(" -w Wrap thresholds on sensor line\n");
+ printf(" -L n Loop n times\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+ if (fjumpstart && fchild) {
+ printf("Cannot use -j jumpstart cache with -c child SDRs\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ fremote = is_remote();
+#ifndef WIN32
+ if (fremote == 0) {
+ /* only run this as superuser for accessing IPMI devices. */
+ i = geteuid();
+ if (i > 1) {
+ printf("Not superuser (%d)\n", i);
+ ret = ERR_NOT_ALLOWED;
+ goto do_exit;
+ }
+ }
+#endif
+ if (fremote) {
+ if (!fprivset) {
+ /* on many systems, getting the SDR Reservation ID requires admin */
+ /* if ((fsetthresh != 0) || (frearm != 0)) also require admin */
+ parse_lan_options('V',"4",0);
+ }
+ }
+
+ ret = ipmi_getdeviceid(devrec,sizeof(devrec),fdebug);
+ if (ret == 0) {
+ uchar ipmi_maj;
+ uchar ipmi_min;
+ char *pstr;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ if ((devrec[1] & 0x80) == 0x80) fdevsdrs = 1;
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ if (vend_id == VENDOR_NSC) { /*NSC mBMC*/
+ pstr = "mBMC";
+ fmBMC = 1;
+ fdevsdrs = 0;
+ } else if (vend_id == VENDOR_INTEL) { /*Intel BMC*/
+ /*Intel Sahalee BMC */
+ pstr = "BMC";
+ fmBMC = 0;
+ if (is_romley(vend_id,prod_id)) fRomley = 1;
+ if (prod_id == 0x003E || fRomley) /*Urbanna NSN2U,CG2100*/
+ set_max_kcs_loops(URNLOOPS); /*longer KCS timeout*/
+ } else { /* Other products */
+ pstr = "BMC";
+ fmBMC = 0;
+ if (vend_id == VENDOR_NEC) fdevsdrs = 0;
+ }
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ // "-- %s version %x.%x, IPMI version %d.%d \n", pstr,
+ } else {
+ goto do_exit;
+ }
+
+ ret = ipmi_getpicmg( devrec, sizeof(devrec),fdebug);
+ if (ret == 0) fpicmg = 1;
+ /*if not PICMG, some vendors override to SDR Rep*/
+ fdevsdrs = use_devsdrs(fpicmg);
+ if (fdevsdrs) printf("supports device sdrs\n");
+ npass = 1;
+ if (g_sa != 0) {
+ /* target a specific MC via IPMB (usu a picmg blade) */
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ fchild = 0; /* no children, only the specified address */
+ } else {
+#ifdef PICMG_CHILD
+ /* fchild set above if -b is specified to get Blade child SDRs */
+ /* npass = 2 will get both SdrRep & DevSdr passes on CMM */
+ if (fpicmg && fdevsdrs) {
+ npass = 2;
+ g_addrtype = ADDR_IPMB;
+ }
+#endif
+ g_sa = BMC_SA;
+ }
+
+ if (fgetmem) {
+ if (fremote) printf("Cannot get memory DIMM information remotely.\n");
+ else {
+ int msz;
+ char desc[80];
+ char szstr[25];
+ ret = -1;
+ for (j = 0; j < 1; j++) {
+ for (i = 0; i < 16; i++) {
+ rv = get_MemDesc(j, i, desc,&msz);
+ if (rv == 0) {
+ if (msz == 0) strcpy(szstr,"not present");
+ else if (msz & 0x8000)
+ sprintf(szstr,"size=%dKB",(msz & 0x7FFF));
+ else sprintf(szstr,"size=%dMB",msz);
+ printf("Memory Device (%d,%d): %s : %s\n",
+ j,i,desc,szstr);
+ ret = 0;
+ }
+ }
+ }
+ } /*end-else*/
+ goto do_exit;
+ }
+
+ if (fdump) {
+ uchar *pbuf = NULL;
+ FILE *fp;
+ int len;
+ ret = get_sdr_cache(&pbuf);
+ if (ret == 0) {
+ fp = fopen(binfile,"w");
+ if (fp == NULL) {
+ ret = get_LastError();
+ printf("Cannot open file %s, error %d\n",binfile,ret);
+ } else {
+ printf("Writing SDR size %d to %s ...\n",sz_sdrs,binfile);
+ len = (int)fwrite(pbuf, 1, sz_sdrs, fp);
+ fclose(fp);
+ if (len <= 0) {
+ ret = get_LastError();
+ printf("Error %d writing file %s\n",ret,binfile);
+ } else ret = 0;
+ }
+ free_sdr_cache(pbuf);
+ }
+ goto do_exit;
+ } /*endif fdump*/
+
+ if (frestore) {
+ uchar sdr[MAX_BUFFER_SIZE];
+ ushort id;
+ int slen;
+ uchar *pbuf = NULL;
+
+ ret = read_sdr_binfile(binfile,&pbuf,&slen);
+ if (ret == 0) { /*successful, so write SDRs */
+ nsdrs = find_nsdrs(pbuf);
+ printf("Ready to restore %d SDRs\n",nsdrs);
+ set_reserve(1);
+ ret = sdr_clear_repo(fdevsdrs);
+ if (ret != 0) {
+ printf("SDR Clear Repository error %d\n",ret);
+ goto do_exit;
+ }
+ id = 0;
+ while(find_sdr_next(sdr,pbuf,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (fdebug) printf("adding SDR[%x]\n",id);
+ set_reserve(1);
+ ret = sdr_add_record(sdr,fdevsdrs);
+ if (ret != 0) {
+ printf("SDR[%x] add error %d\n",id,ret);
+ break;
+ }
+ } /*end while sdr*/
+ }
+ if (ret == 0) printf("Restored %d SDRs successfully.\n",nsdrs);
+ free_sdr_cache(pbuf); /* does nothing if (pbuf == NULL) */
+ goto do_exit;
+ } /*endif frestore*/
+
+ if (fjumpstart) {
+ uchar *pbuf = NULL;
+ int slen;
+ ret = read_sdr_binfile(binfile,&pbuf,&slen);
+ if (ret != 0) fjumpstart = 0; /* use normal method if error*/
+ else { /* set this as the SDR cache */
+ psdrcache = pbuf;
+ sz_sdrs = slen;
+ nsdrs = find_nsdrs(pbuf);
+ if (fdebug) printf("jumpstart cache: nsdrs=%d size=%d\n",nsdrs,slen);
+ }
+ } /*endif fjumpstart*/
+
+ for (ipass = 0; ipass < npass; ipass++)
+ {
+ if (fjumpstart) ; /*already got this above*/
+ else {
+ ret = GetSDRRepositoryInfo(&j,&fdevsdrs);
+ if (fdebug) printf("GetSDRRepositoryInfo: ret=%x nSDRs=%d\n",ret,j);
+ if (ret == 0 && j == 0) {
+ printf("SDR Repository is empty\n");
+ goto do_exit;
+ }
+ nsdrs = j;
+ }
+
+ /* show header for SDR records */
+ if (fsimple)
+ printf(" ID | SDRType | Type |SNum| Name |Status| Reading\n");
+ else
+ printf("_ID_ SDR_Type_xx ET Own Typ S_Num Sens_Description Hex & Interp Reading\n");
+
+ if (fwrap) chEol = ' ';
+ if (!fdoloop) nloops = 1;
+ for (iloop = 0; iloop < nloops; iloop++)
+ {
+ if (fshowidx) recid = sensor_idx1;
+ else recid = 0;
+ while (recid != 0xffff)
+ {
+ if (fjumpstart) {
+ ret = find_sdr_next(sdrdata,psdrcache,recid);
+ if (ret != 0) { ret = 0; break; } /*end of sdrs*/
+ recnext = sdrdata[0] + (sdrdata[1] << 8); /*same as recid*/
+ sz = sdrdata[4] + 5;
+ } else {
+ ret = GetSDR(recid,&recnext,sdrdata,sizeof(sdrdata),&sz);
+ if (fdebug)
+ printf("GetSDR[%04x]: ret = %x, next=%x\n",recid,ret,recnext);
+ if (ret != 0) {
+ if (ret > 0) { /* ret is a completion code error */
+ printf("%04x GetSDR error 0x%02x %s, rlen=%d\n",recid,ret,
+ decode_cc((ushort)0,(uchar)ret),sz);
+ if (ret == 0xC5) { /* lost Reservation ID, retry */
+ /* This means that some other IPMI software has
+ * requested a Reservation before we finished, so
+ * we need to refresh the Reservation ID * retry. */
+ fDoReserve = 1; /* get a new SDR Reservation ID */
+ ret = GetSDR(recid,&recnext,sdrdata,sizeof(sdrdata),&sz);
+ if (fdebug)
+ printf("GetSDR[%04x]: ret = %x, next=%x\n",recid,ret,
+ recnext);
+ }
+ } else printf("%04x GetSDR error %d, rlen = %d\n", recid,ret,sz);
+ if (sz < MIN_SDR_SZ) { /* don't have recnext, so abort */
+ break;
+ } /* else fall through & continue */
+ }
+ } /*end-else*/
+ if (ret == 0) { /* (ret == 0) OK, got full SDR */
+ if (fdebug) {
+ dump_buf("got SDR",sdrdata,sz,0);
+ }
+ if (sz < MIN_SDR_SZ) goto NextSdr;
+ /* if recid == 0, get real record id */
+ if (recid == 0) recid = sdrdata[0] + (sdrdata[1] << 8);
+ if (fshowgrp > 0) {
+ for (i = 0; i < fshowgrp; i++) {
+ uchar styp;
+ if (sdrdata[3] == 0x03) styp = sdrdata[10]; /*EvtOnly*/
+ else styp = sdrdata[12];
+ if (fdebug) printf("sdrt=%02x styp=%02x sgrp[%d]=%02x\n",
+ sdrdata[3],styp,i,sensor_grps[i]);
+ if (sdrdata[3] == 0xc0) continue; /*skip OEM SDRs*/
+ if (styp == sensor_grps[i]) break;
+ }
+ if (i >= fshowgrp) goto NextSdr;
+ }
+
+ if ((sensor_num == INIT_SNUM) || (sdrdata[7] == sensor_num)
+ || fsetthresh) {
+ /* if -n not set or if -n matches, parse and show the SDR */
+ ShowSDR("",sdrdata);
+ } /* else filter SDRs if not matching -n sensor_num */
+
+#ifdef PICMG_CHILD
+ /*
+ * Special logic for blade child MCs in PICMG ATCA systems
+ * if fchild, try all child MCs within the chassis.
+ * SDR type 12 capabilities bits (sdrdata[8]):
+ * 80 = Chassis Device
+ * 40 = Bridge
+ * 20 = IPMB Event Generator
+ * 10 = IPMB Event Receiver
+ * 08 = FRU Device
+ * 04 = SEL Device
+ * 02 = SDR Repository Device
+ * 01 = Sensor Device
+ * But all child MCs use Device SDRs anyway.
+ */
+ if (fpicmg && fchild && (sdrdata[3] == 0x12)) { /* PICMG MC DLR */
+ int _recid, _recnext, _sz;
+ uchar _sdrdata[MAX_SDR_SIZE];
+ int devsdrs_save;
+ uchar cc;
+
+ /* save the BMC globals, use IPMB MC */
+ devsdrs_save = fdevsdrs;
+ fdevsdrs = 1; /* use Device SDRs for the children*/
+ if (fdebug)
+ printf(" --- IPMB MC (sa=%02x cap=%02x id=%02x devsdrs=%d):\n",
+ sdrdata[5],sdrdata[8],sdrdata[12],fdevsdrs);
+ fDoReserve = 1; /* get a new SDR Reservation ID */
+ ipmi_set_mc(PICMG_SLAVE_BUS,sdrdata[5],sdrdata[6],g_addrtype);
+
+ _sz = 16;
+ ret = ipmi_cmd_mc(GET_DEVICE_ID,NULL,0,_sdrdata,&_sz,&cc,fdebug);
+ if (ret == 0 && cc == 0) {
+ /* Get the SDRs from the IPMB MC */
+ _recid = 0;
+ while (_recid != 0xffff)
+ {
+ ret = GetSDR(_recid,&_recnext,_sdrdata,sizeof(_sdrdata),&_sz);
+ if (ret != 0) {
+ printf("%04x GetSDR error %d, rlen = %d\n",_recid,ret,_sz);
+ break;
+ }
+ else if (_sz >= MIN_SDR_SZ)
+ ShowSDR(" ",_sdrdata);
+
+ if (_recnext == _recid) _recid = 0xffff;
+ else _recid = _recnext;
+ } /*end while*/
+ } /*endif ret==0*/
+
+ /* restore BMC globals */
+ fdevsdrs = devsdrs_save;
+ ipmi_restore_mc();
+ fDoReserve = 1; /* get a new SDR Reservation ID */
+ } /*endif fpicmg && fchild*/
+#endif
+
+ if (fdebug) printf("fsetthresh=%d snum=%02x(%02x) sa=%02x(%02x)\n",
+ fsetthresh,sdrdata[7],sensor_num,sdrdata[5],g_sa);
+ if (fsetthresh && (sdrdata[7] == sensor_num)
+ && (sdrdata[5] == g_sa)) /*g_sa usu is BMC_SA*/
+ {
+ /* setting threshold, compute threshold raw values */
+ if (fsetthresh == 2) { /*set from float*/
+ if (fdebug)
+ printf("lof=%.2f hif=%.2f\n", sensor_lo_f,sensor_hi_f);
+ if (sensor_lo_f != 0)
+ sensor_lo = FloatToRaw(sensor_lo_f,sdrdata,0);
+ if (sensor_hi_f != 0)
+ sensor_hi = FloatToRaw(sensor_hi_f,sdrdata,0);
+ } else if (fsetthresh == 1) { /*raw thresholds*/
+ if (sensor_hi != 0xff)
+ sensor_hi_f = RawToFloat(sensor_hi,sdrdata);
+ if (sensor_lo != 0xff)
+ sensor_lo_f = RawToFloat(sensor_lo,sdrdata);
+ } else if (fsetthresh == 3) { /*unique raw thresholds*/
+ if (sensor_hi != 0xff)
+ sensor_hi_f = RawToFloat(sensor_hi,sdrdata);
+ if (sensor_lo != 0xff)
+ sensor_lo_f = RawToFloat(sensor_lo,sdrdata);
+ } else if (fsetthresh == 4) { /*set unique from float*/
+ i = fill_thresholds(&sensor_thrf[0], sdrdata);
+ /* if (i > 0) ; * filled in some thresholds */
+ { /* always set lo/hi if any are non-zero */
+ for (j = 0; j < 3; j++) {
+ if (sensor_thrf[j] != 0) {
+ sensor_lo_f = sensor_thrf[j]; break; }
+ }
+ for (j = 3; j < 6; j++) {
+ if (sensor_thrf[j] != 0) {
+ sensor_hi_f = sensor_thrf[j]; break; }
+ }
+ }
+ if (fdebug)
+ printf("lof=%.2f hif=%.2f\n", sensor_lo_f,sensor_hi_f);
+ /* convert thrf (float) to thr (raw) */
+ if (sensor_lo_f != 0) {
+ sensor_lo = FloatToRaw(sensor_lo_f,sdrdata,0);
+ sensor_thr[0] = FloatToRaw(sensor_thrf[0],sdrdata,0);
+ sensor_thr[1] = FloatToRaw(sensor_thrf[1],sdrdata,0);
+ sensor_thr[2] = FloatToRaw(sensor_thrf[2],sdrdata,0);
+ }
+ if (sensor_hi_f != 0) {
+ sensor_hi = FloatToRaw(sensor_hi_f,sdrdata,0);
+ sensor_thr[3] = FloatToRaw(sensor_thrf[3],sdrdata,0);
+ sensor_thr[4] = FloatToRaw(sensor_thrf[4],sdrdata,0);
+ sensor_thr[5] = FloatToRaw(sensor_thrf[5],sdrdata,0);
+ }
+ /* validate threshold ordering */
+ if (validate_thresholds(sensor_thrf,1,sdrdata) != 0) {
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ }
+ {
+ printf("\tSetting SDR %04x sensor %02x to lo=%02x hi=%02x\n",
+ recid,sensor_num,sensor_lo,sensor_hi);
+ if (recid == 0) fsetfound = 1;
+ else fsetfound = recid;
+ }
+ } /*endif fsetthresh */
+ } /*endif ok, got full SDR */
+
+NextSdr:
+ if (fshowidx) {
+ /* if we have already read the last in the range, done. */
+ if (recid >= sensor_idxN) break; // recnext = 0xffff; // break;
+ }
+ if (fjumpstart) recid = recnext;
+ else {
+ if (recnext == recid) recid = 0xffff; /*break;*/
+ else recid = recnext;
+ }
+ } /*end while recid*/
+ if (fdoloop && (nloops > 1)) {
+ printf("\n"); /* output an empty separator line */
+ os_usleep(1,0); /*delay 1 sec between loops*/
+ }
+ } /*end for nloops*/
+
+ if (npass > 1) { /* npass==2 for PICMG */
+ /* Switch fdevsdrs from Device to Repository */
+ if (fdevsdrs == 0) fdevsdrs = 1;
+ else fdevsdrs = 0;
+ fDoReserve = 1; /* get a new SDR Reservation ID */
+ }
+ } /*end for npass*/
+
+ if ((fshowidx == 0) && (fshowgrp == 0)) {
+ /* use local rv, errors are ignored for POH */
+ rv = ShowPowerOnHours();
+ }
+
+ if (frearm != 0) {
+ ret = RearmSensor((uchar)frearm);
+ printf("RearmSensor(0x%02x) ret = %d\n",frearm,ret);
+ }
+
+ if (fsetthresh != 0) {
+ uchar tdata[7];
+ if (fsetfound == 0) {
+ printf("Did not find sensor number %02x.\nPlease enter the sensor number parameter in hex, as it is displayed above.\n",sensor_num);
+ }
+ ret = GetSensorThresholds(sensor_num,tdata);
+ if (ret != 0) goto do_exit;
+#ifdef TEST
+ printf("thresh(%02x): %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ sensor_num, sensor_num, tdata[0], tdata[1], tdata[2],
+ tdata[3], tdata[4], tdata[5], tdata[6]);
+ printf(" set(%02x): %02x %02x \n",
+ sensor_num,sensor_lo,sensor_hi);
+#endif
+ if (fsetthresh == 3 || fsetthresh == 4) {
+ /* apply unique sensor thresholds */
+ pset = &sensor_thr[0];
+ } else pset = NULL; /* use just hi/lo */
+ ret = SetSensorThresholds(sensor_num,sensor_hi,sensor_lo,tdata,pset);
+ printf("SetSensorThreshold[%02x] to lo=%02x(%4.3f) hi=%02x(%4.3f), ret = %d\n",
+ sensor_num,sensor_lo,sensor_lo_f,sensor_hi,sensor_hi_f,ret);
+ if (fsavethresh && ret == 0) {
+ recid = fsetfound;
+ rv = SaveThreshold(recid,sensor_num,sensor_lo,sensor_hi,pset);
+ if (rv == 0)
+ printf("Saved thresholds for sensor %02x\n",sensor_num);
+ }
+ fsetthresh = 0; /*only set threshold once*/
+ }
+
+do_exit:
+ if (fjumpstart) free_sdr_cache(psdrcache); /* does nothing if ==NULL*/
+ /* show_outcome(progname,ret); *handled in ipmiutil.c*/
+ ipmi_close_();
+ return(ret);
+}
+
+/* end isensor.c */
diff --git a/util/isensor.h b/util/isensor.h
new file mode 100644
index 0000000..8927b6e
--- /dev/null
+++ b/util/isensor.h
@@ -0,0 +1,176 @@
+/*
+ * isensor.h
+ * common routines from isensor.c
+ */
+#define SDR_SZ 80 /*max SDR size*/
+
+typedef struct {
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar sens_ownid;
+ uchar sens_ownlun;
+ uchar sens_num; /*sdr[7]*/
+ uchar entity_id;
+ uchar entity_inst;
+ uchar sens_init;
+ uchar sens_capab;
+ uchar sens_type;
+ uchar ev_type;
+ uchar data1[6]; /*masks*/
+ uchar sens_units; /*sdr[20]*/
+ uchar sens_base;
+ uchar sens_mod;
+ uchar linear;
+ uchar m;
+ uchar m_t;
+ uchar b;
+ uchar b_a;
+ uchar a_ax;
+ uchar rx_bx;
+ uchar flags;
+ uchar nom_reading;
+ uchar norm_max;
+ uchar norm_min;
+ uchar sens_max_reading;
+ uchar sens_min_reading;
+ uchar unr_threshold;
+ uchar ucr_threshold;
+ uchar unc_threshold;
+ uchar lnr_threshold;
+ uchar lcr_threshold;
+ uchar lnc_threshold;
+ uchar pos_hysteresis;
+ uchar neg_hysteresis;
+ uchar data3[3];
+ uchar id_strlen;
+ uchar id_string[16];
+ } SDR01REC;
+
+typedef struct {
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar sens_ownid;
+ uchar sens_ownlun;
+ uchar sens_num;
+ uchar entity_id;
+ uchar entity_inst;
+ uchar sens_init;
+ uchar sens_capab;
+ uchar sens_type;
+ uchar ev_type;
+ uchar data1[6];
+ uchar sens_units;
+ uchar sens_base;
+ uchar sens_mod;
+ uchar shar_cnt;
+ uchar shar_off;
+ uchar pos_hysteresis;
+ uchar neg_hysteresis;
+ uchar data2[4];
+ uchar id_strlen;
+ uchar id_string[16];
+ } SDR02REC;
+
+typedef struct { /* 0x08 = Entity Association record */
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar contid;
+ uchar continst;
+ uchar flags;
+ uchar edata[8];
+ } SDR08REC;
+
+typedef struct { /*0x14 = BMC Message Channel Info record */
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar mdata[8];
+ uchar mint;
+ uchar eint;
+ uchar rsvd;
+ } SDR14REC;
+
+typedef struct { /*0x11 = FRU Locator*/
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar dev_access_adr; /*usu sa*/
+ uchar dev_slave_adr; /*usu fru_id*/
+ uchar access_lun;
+ uchar chan_num;
+ uchar reserved;
+ uchar dev_type;
+ uchar dev_typemod;
+ uchar entity_id;
+ uchar entity_inst;
+ uchar oem;
+ uchar id_strlen;
+ uchar id_string[16];
+ } SDR11REC;
+
+typedef struct { /*0x12 = IPMB Locator, for MCs*/
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar dev_slave_adr;
+ uchar chan_num;
+ uchar power_state;
+ uchar dev_capab;
+ uchar reserved[3];
+ uchar entity_id;
+ uchar entity_inst;
+ uchar oem;
+ uchar id_strlen;
+ uchar id_string[16];
+ } SDR12REC;
+
+typedef struct { /*0xc0 = OEM Record*/
+ ushort recid;
+ uchar sdrver; /*usu. 0x51 = v1.5*/
+ uchar rectype; /* 01, 02, 11, 12, c0 */
+ uchar reclen;
+ uchar manuf_id[3]; /*Intel = 0x57,0x01,0x00 = 343.*/
+ uchar oem_data[60]; /* (reclen-3 bytes)*/
+ } SDRc0REC;
+
+int get_sdr_cache(uchar **pcache);
+void free_sdr_cache(uchar *pcache);
+int get_sdr_file(char *sdrfile, uchar **sdrlist);
+int find_nsdrs(uchar *pcache);
+int find_sdr_next(uchar *psdr, uchar *pcache, ushort id);
+int find_sdr_by_snum(uchar *psdr, uchar *pcache, uchar snum, uchar sa);
+int find_sdr_by_tag(uchar *psdr, uchar *pcache, char *tag, uchar dbg);
+int find_sdr_by_id(uchar *psdr, uchar *pcache, ushort id);
+
+void ShowSDR(char *tag, uchar *sdr);
+int GetSDRRepositoryInfo(int *nret, int *fdev);
+int GetSensorThresholds(uchar sens_num, uchar *data);
+int GetSensorReading(uchar sens_num, void *psdr, uchar *sens_data);
+double RawToFloat(uchar raw, uchar *psdr);
+char *decode_entity_id(int id);
+char *get_unit_type(int iunits, int ibase, int imod, int fshort);
+
+/*
+ * decode_comp_reading
+ *
+ * Decodes the readings from compact SDR sensors.
+ * Use sensor_dstatus array for sensor reading types and meaning strings.
+ * Refer to IPMI Table 36-1 and 36-2 for this.
+ * Note that decoding should be based on sensor type and ev_type only,
+ * except for end cases.
+ *
+ * reading1 = sens_reading[2], reading2 = sens_reading[3]
+ */
+int decode_comp_reading(uchar type, uchar evtype, uchar num,
+ uchar reading1, uchar reading2);
+
+/* end isensor.h */
diff --git a/util/iserial.c b/util/iserial.c
new file mode 100644
index 0000000..ce00ed3
--- /dev/null
+++ b/util/iserial.c
@@ -0,0 +1,1592 @@
+/*
+ * tmconfig.c
+ *
+ * This tool sets up the serial EMP port for the Terminal Mode settings.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2002-2006 Intel Corporation.
+ *
+ * Options:
+ * -b Set serial port up for Basic Mode (fBMode)
+ * -B Set baud rate for serial port
+ * -d Disable serial port for IPMI use
+ * -f Flow Control setting, default=1 (RTS/CTS)
+ * -r Read-only, view serial port parameters
+ * -s configure serial port for Shared Basic Mode & Remote Console
+ * -t Configure serial port for shared Terminal Mode (TMode) & Console
+ * -u username Set username for EMP TMode login (default is null user 1)
+ * -p password Set password for EMP TMode login
+ * -l show LAN parameters also
+ * -m0 switch MUX to Normal baseboard operation
+ * -m1 switch MUX to BMC operation (BMode or TMode)
+ * -x eXtra debug messages
+ * -f special boot Flags
+ *
+ * Change Log:
+ * 02/12/02 Andy Cress - created from pefconfig.c
+ * 03/08/02 Andy Cress - added GET_USER_ACCESS to serial parameters shown
+ * 03/11/02 Andy Cress - changed MUX param 8 value for -b
+ * 03/13/02 Andy Cress - changed default behavior to be like -r,
+ * added -c option to configure TMode
+ * 03/15/02 Andy Cress v1.3 added bootflags
+ * 04/12/02 Andy Cress v1.4 use always avail instead of shared mode
+ * also, don't do boot flags if not specified
+ * 07/02/02 Andy Cress v1.5 add more Usage, add -d option.
+ * 07/25/02 Andy Cress v1.6 fixed passwd offset for fSetTMode (-c)
+ * 08/02/02 Andy Cress v1.7 moved common ipmi_cmd() code to ipmicmd.c
+ * 12/09/02 Andy Cress v1.8 make sure -d sets user1 to admin again,
+ * combine -n/-t into -m for MUX,
+ * fix -c to drop thru to SetTMode logic,
+ * param 8 values changed,
+ * Dont SetUser for TMode unless -u,
+ * use DCD & RTS/CTS for TMode.
+ * 12/12/02 Andy Cress v1.9 change access from 0x23 to 0x2b
+ * 01/23/03 Andy Cress v1.10 decode UserAccess meanings
+ * 01/29/03 Andy Cress v1.11 added MV OpenIPMI support
+ * 07/31/03 Andy Cress v1.12 added -F to try force it
+ * 09/10/03 Andy Cress v1.13 isolate ser_ch, add -n option to specify chan#,
+ * abort if no serial channels
+ * 05/05/04 Andy Cress v1.14 call ipmi_close before exit, added WIN32
+ * 06/29/04 Andy Cress v1.15 added fSetPsw even if not fSetUser3
+ * 11/01/04 Andy Cress v1.16 add -N / -R for remote nodes
+ * 11/23/04 Andy Cress v1.17 recompile with ipmignu.c changes
+ * 01/31/05 Andy Cress v1.18 allow IPMI 2.0 versions
+ * 03/18/05 Andy Cress v1.19 fix for -n, show the ser_ch it is using.
+ * 05/19/05 Andy Cress v1.20 show 4 users if IPMI20
+ * 06/13/05 Andy Cress v1.21 show multiple alert destinations
+ * 08/10/05 Andy Cress v1.22 truncate extra string chars
+ * 05/02/06 Andy Cress v1.23 add -B option for baud rate
+ * 09/12/06 Andy Cress v1.26 use authmask to set Serial Param(2)
+ * 09/29/06 Andy Cress v1.27 add -q for user number, add -f for Flow Control,
+ * adjust Mode if known, clear SerialParam(3) if -d,
+ * added ShowAccess if -r.
+ */
+/*M*
+Copyright (c) 2002-2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#elif defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include <string.h>
+#endif
+#include "ipmicmd.h"
+
+#define SELprintf printf
+#define SER_CH 4
+#define LAN_CH 1
+#define MAXCHAN 16
+#define PSW_LEN 16 /*see also PSW_MAX=20 in ipmicmd.h*/
+/* Note: The optional IPMI 2.0 20-byte passwords are not supported here,
+ * due to back-compatibility issues. */
+
+/* serial channel access values */
+#define ALWAYS_AUTH 0x22
+#define ALWAYS_NOAUTH 0x2A
+#define SHARED_AUTH 0x23
+#define SHARED_NOAUTH 0x2B
+
+typedef struct
+{
+ unsigned short record_id;
+ uchar record_type;
+ int timestamp;
+ unsigned short generator_id;
+ uchar evm_rev; //event message revision
+ uchar sensor_type;
+ uchar sensor_number;
+ uchar event_trigger;
+ uchar event_data1;
+ uchar event_data2;
+ uchar event_data3;
+} SEL_RECORD;
+
+typedef struct
+{ /* See IPMI Table 19-3 */
+ uchar data[30];
+} SER_RECORD;
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "iserial";
+static int vend_id = 0;
+static int prod_id = 0;
+static char fdebug = 0;
+static char fpicmg = 0;
+static char freadonly = 0;
+static char fdoanyway = 0;
+static char fSetUser3 = 0; /* =1 set User3->admin and User1->user access*/
+static char fSetPsw = 0; /* =1 set Password to user parameter */
+static char fSetTMode = 0; /* =1 configure for TMode */
+static char fBasebdOn = 0; /* =1 only do MUX switch BMC -> Baseboard */
+static char fTModeOn = 0; /* =1 only do MUX switch Baseboard -> BMC */
+static char fBMode = 0; /* =1 do Basic mode config stuff */
+static char fShared = 0; /* =1 shared Basic mode & Remote console */
+static char fDisable = 0; /* =1 to disable serial port IPMI */
+static char fKnownMode = 0; /* =0 if unknown, =1 if TMode, =2 if BMode */
+static char fgetlan = 0;
+static char fnotshared = 0; /* =1 if IPMI serial shared with OS/BIOS*/
+static char fconsoleonly = 0; /* =1 BIOS console only, no serial mux */
+static char fIPMI20 = 0; /* =1 IPMI v2.0 or greater */
+static char fcanonical = 0; /* =1 IPMI v2.0 or greater */
+static char fuser1admin = 0; /* =1 if default user 1 should be admin */
+static char bdelim = ':';
+static char bFlow = 1; /* Flow Control: 1=RTS/CTS, 0=none */
+static char inactivity = 0; /* Inactivity Timeout (30 sec increments) */
+static char newbaud = 0x07; /* default = 19.2K */
+static uchar bootflags = 16; /* if < 16 use these bootflags */
+static uchar ser_ch = SER_CH;
+static uchar lan_ch = LAN_CH; /* usu LAN 1 = 7 */
+static uchar ser_user = 0x03; /* if -u specified, configure user 3 */
+static uchar ser_access = 0x04; /* user priv 4=Admin, 3=Operator, 2=User */
+static uchar usernum = 0; /* set non-zero to specify user number */
+static uchar useridx = 0; /* user number index for get/show*/
+static uchar max_users = 5; /* set in GetUserAccess() if unum==1 */
+static uchar enabled_users = 0; /* set in GetUserAccess() if unum==1 */
+static uchar show_users = 5; /* set in GetUserAccess() if unum==1 */
+static char rguser[16] = "root"; /* default, settable via user param */
+static char rgpasswd[PSW_LEN+1] = "password"; /* default, set via user param */
+
+#define NLAN 27
+static struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} lanparams[NLAN] = { /* see IPMI Table 19-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 4, "IP address"},
+ /* 4 */ { 4, 1, "IP addr src"}, /* (DHCP/Static) */
+ /* 5 */ { 5, 6, "MAC addr"},
+ /* 6 */ { 6, 4, "Subnet mask"},
+ /* 7 */ { 7, 3, "IPv4 header"},
+ /* 8 */ { 8, 2, "Prim RMCP port "},
+ /* 9 */ { 9, 2, "Sec RMCP port "},
+ /* 10 */ {10, 1, "BMC grat ARP "},
+ /* 11 */ {11, 1, "grat ARP interval"},
+ /* 12 */ {12, 4, "Def gateway IP"},
+ /* 13 */ {13, 6, "Def gateway MAC"},
+ /* 14 */ {14, 4, "Sec gateway IP"},
+ /* 15 */ {15, 6, "Sec gateway MAC"},
+ /* 16 */ {16,18, "Community string"},
+ /* 17 */ {17, 1, "Num dest"},
+ /* 18 */ {18, 5, "Dest type"},
+ /* 19 */ {19, 13, "Dest address"},
+ /* 20 */ {96, 28, "OEM Alert String"},
+ /* 21 */ {97, 1, "Alert Retry Algorithm"},
+ /* 22 */ {98, 3, "UTC Offset"},
+ /* 23 */ {192, 4, "DHCP Server IP"},
+ /* 24 */ {193, 6, "DHCP MAC Address"},
+ /* 25 */ {194, 1, "DHCP Enable"},
+ /* 26 */ {201, 2, "Channel Access Mode (Lan)"}
+};
+
+/* Special temp ids for other serial commands that aren't serial params */
+#define CMDID_CA1 201 /*this is the first temp id*/
+#define CMDID_UA1 202
+#define CMDID_UA2 203
+#define CMDID_UA3 204
+#define CMDID_UA4 205
+#define CMDID_MUX 210
+#define CMDID_BOOT 211
+#define NSER 28 /* was 32 */
+static struct {
+ int cmd;
+ int sz;
+ char desc[28];
+} serparams[NSER] = { /* see IPMI Table 20-4 */
+ /* 0 */ { 0, 1, "Set in progress"},
+ /* 1 */ { 1, 1, "Auth type support"},
+ /* 2 */ { 2, 5, "Auth type enables"},
+ /* 3 */ { 3, 1, "Connection Mode"},
+ /* 4 */ { 4, 1, "Sess Inactiv Timeout"},
+ /* 5 */ { 5, 5, "Channel Callback"},
+ /* 6 */ { 6, 1, "Session Termination"},
+ /* 7 */ { 7, 2, "IPMI Msg Comm"},
+ /* 8 */ { 8, 2, "Mux Switch"},
+ /* 9 */ { 9, 2, "Modem Ring Time"},
+ /* 10 */ {10,17, "Modem Init String"},
+ /* 11 */ {11, 5, "Modem Escape Seq"},
+ /* 12 */ {12, 8, "Modem Hangup Seq"},
+ /* 13 */ {13, 8, "Modem Dial Command"},
+ /* 14 */ {14, 1, "Page Blackout Interval"},
+ /* 15 */ {15,18, "Community String"},
+ /* 16 */ {16, 1, "Num of Alert Dest"},
+ /* 17 */ {17, 5, "Destination Info"},
+ /* 18 */ {18, 1, "Call Retry Interval"},
+ /* 19 */ {19, 3, "Destination Comm Settings"},
+ /* 20 */ {20, 1, "Number Dial Strings"},
+ /* 21 */ {21,33, "Dest Dial String"},
+ /* 22 */ {22, 1, "Number Dest IP Addrs"},
+ /* 23 */ {23, 5, "Dest IP Address"},
+ /* 24 */ {29, 2, "Terminal Mode Config"},
+ /* 25 */ {CMDID_MUX, 1,"Get Serial MUX Status"},
+ /* 26 */ {CMDID_BOOT, 3,"Get Boot Options(3)"},
+ /* 27 */ {CMDID_CA1, 2,"Channel Access Mode (Ser)"}
+ /* 28 *% {CMDID_UA1, 4,""}, //"Get User Access (1)", */
+ /* 29 *% {CMDID_UA2, 4,""}, //"Get User Access (2)", */
+ /* 30 *% {CMDID_UA3, 4,""}, //"Get User Access (3)", */
+ /* 31 *% {CMDID_UA4, 4,""} //"Get User Access (4)" */
+};
+
+static int GetDeviceID(SER_RECORD *pSerRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pSerRecord == NULL) return(-1);
+
+ status = ipmi_cmd(GET_DEVICE_ID, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetDeviceID: completion code=%x\n",
+ completionCode);
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pSerRecord,&responseData[0],responseLength);
+ set_mfgid(&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(-1);
+} /*end GetDeviceID() */
+
+static int GetChanAcc(uchar chan, uchar parm, SER_RECORD *pSerRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ if (pSerRecord == NULL) return(-1);
+ responseLength = 3;
+ inputData[0] = chan;
+ inputData[1] = parm; /* 0x80 = active, 0x40 = non-volatile */
+
+ status = ipmi_cmd(GET_CHANNEL_ACC, inputData, 2, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetChanAcc: completion code=%x\n",
+ completionCode);
+ } else {
+ memcpy(pSerRecord,&responseData[0],responseLength);
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(-1);
+} /*GetChanAcc()*/
+
+static int SetChanAcc(uchar chan, uchar parm, uchar val)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ int status;
+ uchar inputData[24];
+ uchar completionCode;
+
+ /* parm: 0x80 = active, 0x40 = set non-vol*/
+ responseLength = 1;
+ inputData[0] = chan; /* channel */
+ inputData[1] = (parm & 0xc0) | (val & 0x3F);
+ if (chan == lan_ch) inputData[2] = 0x04; /* LAN, don't set priv level*/
+ else inputData[2] = (parm & 0xc0) | 0x04; /* set Admin priv level */
+ /* serial defaults to 0x02 = User priv level */
+
+ status = ipmi_cmd(SET_CHANNEL_ACC, inputData, 3, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SetChanAcc: completion code=%x\n",
+ completionCode);
+ } else {
+ return(0); // successful, done
+ }
+ } /* endif */
+ /* if get here, error */
+ return(-1);
+} /*SetChanAcc()*/
+
+static int GetSerEntry(uchar subfunc, uchar bset, SER_RECORD *pSerRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+ uchar chan;
+
+ if (pSerRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetSerEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ chan = ser_ch; /* sample: 0=IPMB, 1=EMP/serial, 6=LAN2, 7=LAN1 */
+
+ inputData[0] = chan; // flags, channel 3:0 (1=EMP)
+ inputData[1] = subfunc; // Param selector
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+ if (subfunc == 10) { /*modem init string*/
+ inputData[3] = 1; /*blocks start with 1*/
+ } else if (subfunc == 21) {
+ inputData[3] = 1; /*blocks start with 1*/
+ }
+
+ status = ipmi_cmd(GET_SER_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (completionCode == 0x80)
+ SELprintf("GetSerEntry(%d): Parameter not supported\n",
+ subfunc);
+ else
+ SELprintf("GetSerEntry(%d): completion code=%x\n",
+ subfunc,completionCode); // responseData[0]);
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pSerRecord,&responseData[1],responseLength-1);
+ pSerRecord->data[responseLength-1] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ printf("GetSerEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ return -1;
+}
+
+static int SetSerEntry(uchar subfunc, SER_RECORD *pSerRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pSerRecord == NULL)
+ {
+ if (fdebug)
+ printf("SetSerEntry(%d): error, input buffer is NULL\n",
+ subfunc);
+ return (-1);
+ }
+
+ inputData[0] = ser_ch; // flags, channel 3:0 (EMP)
+ inputData[1] = subfunc; // Param selector
+ memcpy(&inputData[2],pSerRecord,reqlen);
+
+ status = ipmi_cmd(SET_SER_CONFIG, inputData, (uchar)(reqlen+2),
+ responseData, &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (completionCode == 0x80)
+ SELprintf("SetSerEntry(%d): Parameter not supported\n",
+ subfunc);
+ else
+ SELprintf("SetSerEntry(%d): completion code=%x\n",
+ subfunc, completionCode);
+ } else {
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ printf("SetSerEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ return -1;
+} /* end SetSerEntry() */
+
+#ifdef NEEDED
+int SerialIsOptional(uchar bparam)
+{
+ /* These Serial Parameters are for optional Modem/Callback functions. */
+ uchar optvals[9] = { 5, 9, 10, 11, 12, 13, 14, 20, 21 };
+ int rv = 0;
+ int i;
+ for (i = 0; i < sizeof(optvals); i++) {
+ if (optvals[i] == bparam) { rv = 1; break; }
+ }
+ return(rv);
+}
+#endif
+
+int SetMiscEntry(ushort icmd, SER_RECORD *pSerRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pSerRecord == NULL) {
+ if (fdebug) printf("SetMiscEntry: error, input buffer is NULL\n");
+ return (-1);
+ }
+ memcpy(&inputData[0],pSerRecord,reqlen);
+
+ status = ipmi_cmd(icmd, inputData, (uchar)reqlen, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ printf("SetMiscEntry(%04x): completion code=%x\n",
+ icmd,completionCode);
+ } else { //successful
+ if (responseLength > 1) {
+ // skip first byte (Parameter revision, usu 0x11)
+ memcpy(pSerRecord,&responseData[1],responseLength-1);
+ }
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ printf("SetMiscEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ return -1;
+} /* end SetMiscEntry() */
+
+int GetMiscEntry(ushort icmd, SER_RECORD *pSerRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pSerRecord == NULL) {
+ if (fdebug) printf("GetMiscEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ memcpy(&inputData[0],pSerRecord,reqlen);
+ status = ipmi_cmd(icmd, inputData, (uchar)reqlen, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ if (completionCode == 0x80)
+ printf("GetMiscEntry(%d): Parameter not supported\n",
+ icmd);
+ else
+ printf("GetMiscEntry(%d): completion code=%x\n",
+ icmd,completionCode);
+ } else { //successful
+ if (responseLength > 1)
+ memcpy(pSerRecord,&responseData[0],responseLength);
+ return(0);
+ }
+ }
+
+ if (fdebug)
+ printf("GetMiscEntry(%d): ipmi_cmd status=%d, completion code=%x\n",
+ icmd,status,completionCode);
+ return -1;
+} /* end GetMiscEntry() */
+
+void ShowUserAccess(uchar unum, uchar c0, uchar c1, uchar c2, uchar c,
+ char *name)
+{
+ /* channel is always ser_ch */
+ if (unum == 1 && !fcanonical) {
+ printf("Users: showing %d of max %d users (%d enabled)\n",
+ show_users,max_users,enabled_users);
+ }
+ printf("Get User Access(%d)%c %02x %02x %02x %02x%c ",
+ unum,bdelim,c0,c1,c2,c,bdelim);
+ if (c & 0x10) printf("IPMI, ");
+ c = (c & 0x0f);
+ switch(c) {
+ case 1: printf("Callback"); break;
+ case 2: printf("User "); break;
+ case 3: printf("Operator"); break;
+ case 4: printf("Admin"); break;
+ case 5: printf("OEM "); break;
+ case 0x0f: printf("No access"); break;
+ default: printf("Reserved");
+ }
+ printf(" (%s)\n",name);
+}
+
+int GetUserAccess(uchar unum, uchar *rdata, char *name)
+{
+ int rv;
+ /* rdata must be at least 2 bytes, and name must be at least 16 bytes */
+ rdata[0] = ser_ch; /* channel# */
+ rdata[1] = unum; /* user# */
+ rv = GetMiscEntry(GET_USER_ACCESS, (SER_RECORD *)rdata, 2);
+ if (rv == 0 && name != NULL) {
+ name[0] = unum; /* user# */
+ rv = GetMiscEntry(GET_USER_NAME, (SER_RECORD *)name, 1);
+ if (rv != 0) name[0] = 0;
+ rv = 0;
+ }
+ if (unum == 1) { /*get max_users and enabled_users*/
+ max_users = rdata[0] & 0x3f;
+ enabled_users = rdata[1] & 0x3f;
+ // if (enabled_users > show_users) show_users = enabled_users;
+ if (show_users > max_users) show_users = max_users;
+ }
+ if (rv == 0)
+ ShowUserAccess(unum,rdata[0],rdata[1],rdata[2],rdata[3],name);
+ else printf("Get User Access(%d): error %d\n",unum,rv);
+ return(rv);
+}
+
+static int GetLanEntry(uchar subfunc, SER_RECORD *pSerRecord)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+ uchar chan; uchar bset;
+
+ if (pSerRecord == NULL)
+ {
+ if (fdebug)
+ printf("GetLanEntry: error, output buffer is NULL\n");
+ return (-1);
+ }
+
+ chan = lan_ch;
+ if (subfunc == 18 || subfunc == 19) bset = 1; /* dest id = 1 */
+ else bset = 0;
+
+ inputData[0] = chan; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ inputData[2] = bset; // Set selector
+ inputData[3] = 0; // Block selector
+
+ status = ipmi_cmd(GET_LAN_CONFIG, inputData, 4, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("GetLanEntry: completion code=%x\n",
+ completionCode); // responseData[0]);
+ } else {
+ // dont copy first byte (Parameter revision, usu 0x11)
+ memcpy(pSerRecord,&responseData[1],responseLength-1);
+ pSerRecord->data[responseLength-1] = 0;
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ printf("GetLanEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ return -1;
+} /* end GetLanEntry() */
+
+#ifdef NOT
+static int SetLanEntry(uchar subfunc, SER_RECORD *pSerRecord, int reqlen)
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar inputData[24];
+ int status;
+ uchar completionCode;
+
+ if (pSerRecord == NULL)
+ {
+ if (fdebug)
+ printf("SetLanEntry: error, input buffer is NULL\n");
+ return (-1);
+ }
+
+ inputData[0] = lan_ch; // flags, channel 3:0 (LAN 1)
+ inputData[1] = subfunc; // Param selector (3 = ip addr)
+ memcpy(&inputData[2],pSerRecord,reqlen);
+
+ status = ipmi_cmd(SET_LAN_CONFIG,inputData,(uchar)(reqlen+2),responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK) {
+ if( completionCode ) {
+ SELprintf("SetLanEntry: completion code=%x\n",
+ completionCode); // responseData[0]);
+ } else {
+ //successful, done
+ return(0);
+ }
+ }
+
+ // we are here because completionCode is not COMPLETION_CODE_OK
+ if (fdebug)
+ printf("SetLanEntry: ipmi_cmd status=%d, completion code=%d\n",
+ status,completionCode);
+ return -1;
+} /* end SetLanEntry() */
+#endif
+
+static int ReadSELinfo()
+{
+ uchar responseData[MAX_BUFFER_SIZE];
+ int responseLength = MAX_BUFFER_SIZE;
+ uchar completionCode;
+ uchar inputData[6];
+ int status;
+
+ status = ipmi_cmd(GET_SEL_INFO, inputData, 0, responseData,
+ &responseLength, &completionCode, fdebug);
+
+ if (status == ACCESS_OK)
+ {
+ if (fdebug)
+ SELprintf("Code %d SEL Ver %d Support %d\n",
+ completionCode,
+ responseData[0],
+ responseData[13]
+ );
+ //successful, done
+ return(0);
+ }
+ else return(1);
+
+} /*end ReadSELinfo()*/
+
+#define NBAUDS 10
+static struct {
+ unsigned char val;
+ char str[8];
+ } mapbaud[NBAUDS] = {
+ { 6, "9600" },
+ { 6, "9.6K" },
+ { 7, "19.2K" },
+ { 7, "19200" },
+ { 8, "38.4K" },
+ { 8, "38400" },
+ { 9, "57.6K" },
+ { 9, "57600" },
+ { 10, "115.2K" },
+ { 10, "115200" }
+ };
+
+static unsigned char Str2Baud(char * str)
+{
+ unsigned char baud = 0;
+ int i, n, len;
+ len = (int)strlen(str);
+ for (i = 0; i < len; i++) /*toupper*/
+ if (str[i] >= 'a' && str[i] <= 'z') str[i] &= 0x5F;
+ for (i = 0; i < NBAUDS; i++) {
+ n = (int)strlen(mapbaud[i].str);
+ if (strncmp(str,mapbaud[i].str,n) == 0) {
+ baud = mapbaud[i].val;
+ break;
+ }
+ }
+ if (i == NBAUDS || baud == 0) {
+ printf("Invalid -B parameter value (%s), using 19.2K.\n",str);
+ i = 1; /* default is 19.2K */
+ baud = mapbaud[i].val; /* =7 */
+ }
+ if (fdebug) printf("new baud = %02x (%s)\n",baud,mapbaud[i].str);
+ return(baud);
+}
+
+static char *Baud2Str(unsigned char bin)
+{
+ char *baudstr;
+ unsigned char b;
+ b = bin & 0x0f;
+ switch(b) {
+ case 6: baudstr = "9600 "; break;
+ case 7: baudstr = "19.2k"; break;
+ case 8: baudstr = "38.4k"; break;
+ case 9: baudstr = "57.6k"; break;
+ case 10: baudstr = "115.2k"; break;
+ default: baudstr = "nobaud";
+ }
+ return(baudstr);
+}
+
+void ShowChanAccess(uchar chan, char *tag, uchar access, uchar access2)
+{
+ printf("Channel Access Mode(%d=%s)%c %02x %02x %c ",
+ chan,tag,bdelim,access,access2,bdelim);
+ switch (access & 0x03) {
+ case 0: printf("Access = Disabled, "); break;
+ case 1: printf("Access = Pre-Boot, "); break;
+ case 2: printf("Access = Always Avail, "); break;
+ case 3: printf("Access = Shared, "); break;
+ default: break;
+ }
+ if (access & 0x20) printf("PEF Alerts Disabled\n"); /*0*/
+ else printf("PEF Alerts Enabled\n"); /*1*/
+}
+
+static int valid_priv(int c)
+{
+ int rv;
+ switch(c) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 0x0f:
+ rv = 1; break;
+ default:
+ rv = 0; break;
+ }
+ return(rv);
+}
+
+#ifdef METACOMMAND
+int i_serial(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret;
+ SER_RECORD SerRecord;
+ char uname[16];
+ int i, idx;
+ int c;
+ int rlen;
+ uchar iData[2];
+ uchar rData[10];
+ uchar cc;
+ int j;
+ uchar bset;
+ uchar nalert, ndial, ndest;
+ uchar ialert, idial, idest;
+ uchar authmask = 0;
+ char mystr[80];
+
+ // progname = argv[0];
+ printf("%s ver %s \n",progname,progver);
+
+ if (argc <= 1) freadonly = 1; /* default to readonly if no options */
+
+ while ( (c = getopt( argc, argv,"abcdef:gi:lm:n:p:#:q:rstu:v:xB:F:T:V:J:EYP:N:R:U:X:Z:?")) != EOF )
+ switch(c) {
+ case 'x': fdebug = 1; break;
+ case 'r': freadonly = 1; break;
+ case 'l': fgetlan = 1; break;
+ case 'd': fDisable = 1; freadonly = 0; break;
+ case 'a': fcanonical = 1; /* canonical mode with delimeter */
+ bdelim = BDELIM; break;
+ case 'c': /* configure Terminal Mode & Console */
+ case 't': fSetTMode = 1; /* set Terminal Mode & Console */
+ freadonly = 0; break;
+ case 'e': fSetTMode = 1; /* set Terminal Mode not shared*/
+ fnotshared = 1; /* no BIOS console, not shared */
+ freadonly = 0; break;
+ case 'g': fSetTMode = 1; /* set Terminal Mode, but BCR only */
+ fconsoleonly = 1; /* BIOS console only, disable mux */
+ freadonly = 0; break;
+ case 'b': fBMode = 1; /* set Basic Mode only */
+ freadonly = 0; break;
+ case 's': fBMode = 1; /* set Basic Mode & Console */
+ fShared = 1; freadonly = 0;
+ break;
+ case 'f': i = atoi(optarg); /*flow control*/
+ if (i >= 0 && i < 2) bFlow = (uchar)i;
+ break;
+ case 'i': i = atoi(optarg); /*inactivity timeout*/
+ if (i > 0 && i < 30) inactivity = 1;
+ else inactivity = i / 30;
+ break;
+ case 'B': newbaud = Str2Baud(optarg); break;
+ case 'm': /* set MUX to specific value */
+ i = atoi(optarg);
+ if (fdebug) printf("MUX Mode %d\n",i);
+ switch(i) {
+ case 0: fBasebdOn = 1; break;
+ case 1: fTModeOn = 1; break;
+ default: fBasebdOn = 1;
+ }
+ break;
+ case 'u':
+ strncpy(rguser,optarg,16);
+ rguser[15] = 0;
+ /* Use specified user #3, and set user 1 to not admin */
+ fSetUser3 = 1;
+ break;
+ case 'p':
+ strncpy(rgpasswd,optarg,PSW_LEN);
+ rgpasswd[PSW_LEN] = 0;
+ fSetPsw = 1;
+ /* Hide password from 'ps' */
+ memset(optarg, ' ', strlen(optarg));
+ break;
+ case 'q':
+ case '#':
+ usernum = atob(optarg);
+ if (usernum > 15) usernum = 0; /*MAX_IPMI_USERS = 4*/
+ break;
+ case 'n':
+ ser_ch = atob(optarg);
+ if (ser_ch > MAXCHAN) ser_ch = SER_CH; /*default=1*/
+ break;
+ case 'v': /*user privilege level access */
+ i = atoi(optarg);
+ if (valid_priv(i)) ser_access = i & 0x0f;
+ else printf("Invalid privilege -v %d, using Admin\n",i);
+ break;
+ case 'X':
+ bootflags = atob(optarg);
+ fdoanyway = 1; /* undocumented, for test only */
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-bcdefglmnq#rstxB -u user -p passwd -NUPREFTVY]\n",progname);
+ printf(" -b configure serial port for Basic Mode\n");
+ printf(" -c Configure serial port for shared Terminal Mode & Console\n");
+ printf(" -d Disable serial port for IPMI use.\n");
+ printf(" -e configure serial port for Terminal Mode only\n");
+ printf(" -f0 Flow control: 0=none, 1=RTS/CTS(default)\n");
+ printf(" -g configure serial port for console only, with BMode CTS\n");
+ printf(" -s configure serial port for Shared Basic Mode & Remote Console\n");
+ printf(" -l show some LAN parameters also\n");
+ printf(" -m0 switch MUX to Normal baseboard operation\n");
+ printf(" -m1 switch MUX to BMC operation (BMode or TMode)\n");
+ printf(" -B bval set Baud to bval for serial port\n");
+ printf(" -n ser_chan serial channel Number (default=1)\n");
+ printf(" -p password set Password for EMP TMode login\n");
+ printf(" -u username set Username for EMP TMode login\n");
+ printf(" -q/-# User number of Username for EMP\n");
+ printf(" -r Read-only, view serial port parameters (default)\n");
+ printf(" -t Configure serial port for shared Terminal Mode & Console (same as -c)\n");
+ printf(" -v4 access priVilege: 4=Admin, 3=Operator, 2=User\n");
+ printf(" -x eXtra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ if (is_remote() && !freadonly) parse_lan_options('V',"4",0);
+
+ ret = GetDeviceID( &SerRecord);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ uchar ipmi_maj, ipmi_min;
+ uchar *devrec;
+
+ devrec = &SerRecord.data[0];
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ vend_id = devrec[6] + (devrec[7] << 8) + (int)(devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ if ((ipmi_maj == 0) || (ipmi_maj == 1 && ipmi_min < 5)) {
+ /* IPMI 0.9 and 1.0 dont support this. */
+ printf("This system does not support EMP Terminal Mode.\n");
+ if (!fdoanyway)
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+ }
+ if (ipmi_maj >= 2) fIPMI20 = 1;
+ /* Determine if Basic or Terminal Mode is supported by product id */
+ if (vend_id == VENDOR_INTEL) { /*Intel*/
+ switch(prod_id) {
+ case 0x4311: fKnownMode = 1; break; /*NSI2U, BMode*/
+ case 0x000C: fKnownMode = 1; break; /*TSRLT2, BMode*/
+ case 0x0100: fKnownMode = 1; break; /*Tiger2, BMode*/
+ case 0x001B: fKnownMode = 2; break; /*TIGPR2U, TMode*/
+ case 0x0022: fKnownMode = 2; break; /*TIGI2U, TMode*/
+ case 0x0026: fKnownMode = 2; break; /*Alcolu, TMode*/
+ case 0x0028: fKnownMode = 2; break; /*Alcolu, TMode*/
+ case 0x0811: fKnownMode = 2; break; /*TIGW1U, TMode*/
+ case 0x003E: fKnownMode = 2; /*NSN2U/CG2100, TMode*/
+ set_max_kcs_loops(URNLOOPS); /*longer KCS timeout*/
+ break;
+ default: break;
+ }
+ } else if (vend_id == VENDOR_NSC) { /*NSC*/
+ if (prod_id == 0x4311) fKnownMode = 1; /*TIGPT1U, No EMP*/
+ } /* else * other vend_id, leave defaults */
+ if (fKnownMode > 0) {
+ /* Adjust if we know that the user set the wrong one. */
+ if (fKnownMode == 1 && fSetTMode == 1) {
+ printf("Adjusting from Terminal Mode to Basic Mode\n");
+ fSetTMode = 0; fBMode = 1; fShared = 1;
+ } else if (fKnownMode == 2 && fBMode == 1) {
+ printf("Adjusting from Basic Mode to Terminal Mode\n");
+ fSetTMode = 1; fBMode = 0;
+ }
+ }
+ } /*end-else have device_id */
+
+ ret = ipmi_getpicmg( &SerRecord.data[0], 16, fdebug);
+ if (ret == 0) fpicmg = 1;
+
+ ret = ReadSELinfo();
+ if (ret == 0) { /* talking to BMC ok */
+
+ /* find the first Serial channel via Channel Info */
+ for (j = 1; j < MAXCHAN; j++) {
+ iData[0] = (uchar)j; /*channel #*/
+ rlen = sizeof(rData);
+ ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, 0);
+ if (ret != 0) break;
+ if (rData[1] == 4) { /* 4 = LAN type*/
+ if (fdebug) printf("chan[%d] = lan\n",j);
+ lan_ch = (uchar)j;
+ } else if (rData[1] == 5) { /* 5 = Serial type*/
+ if (fdebug) printf("chan[%d] = serial\n",j);
+ if (ser_ch != SER_CH) { /* user set it */
+ if (j == ser_ch) break;
+ } else { /* find the first serial channel */
+ ser_ch = (uchar)j;
+ break;
+ }
+ } else /* 7 = SMBus, 12 = System Interface */
+ if (fdebug) printf("chan[%d] = %d\n",j,rData[1]);
+ }
+ if (fdebug) printf("ser_ch = %d\n",ser_ch);
+ if (j >= MAXCHAN) {
+ printf("No serial channel support found (channel %d)\n",ser_ch);
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+ }
+
+ if (fdebug && fSetUser3 == 1)
+ printf("user %d/%d: username=%s, password=%p\n",
+ usernum,ser_user, rguser,rgpasswd);
+
+ if (fgetlan && !fcanonical) {
+ int ival;
+ printf("%s, GetLanEntry for channel %d ...\n",progname,lan_ch);
+ for (idx = 0; idx < NLAN; idx++)
+ {
+ ival = lanparams[idx].cmd;
+ if (ival == 8 || ival == 9) continue; /* not implemented */
+ if (ival >= 96 && ival <= 98) continue; /* not implemented */
+ if (ival == CMDID_CA1) {
+ ret = GetChanAcc(lan_ch, 0x40, &SerRecord);
+ } else {
+ ret = GetLanEntry((uchar)ival, &SerRecord);
+ }
+ if (ret == 0) { // Show the LAN record
+ uchar * pc; int sz;
+ pc = (uchar *)&SerRecord;
+ sz = lanparams[idx].sz;
+ printf("Lan Param(%d) %s%c ",ival,lanparams[idx].desc,bdelim);
+ if (ival == 16) { printf("%s \n",pc); /* string */
+ } else { /* print results for others */
+ for (i = 0; i < sz; i++) {
+ if (ival == 3 || ival == 6 || ival == 12 || ival == 14 ||
+ ival == 192)
+ printf("%d ",pc[i]); /* IP addresses in dec */
+ else printf("%02x ",pc[i]); /* show in hex */
+ }
+ /* if (ival == 4) { pc[0]: 01 = static, 02 = DHCP } */
+ printf("\n");
+ }
+ } else /* ret != 0 */
+ printf("GetLanEntry(%d), ret = %d\n",ival,ret);
+ } /*end for*/
+ }
+
+ printf("%s, GetSerEntry for channel %d ...\n",progname,ser_ch);
+ nalert = 1; ialert = 1;
+ ndial = 1; idial = 1;
+ ndest = 1; idest = 1;
+ for (idx = 0; idx < NSER; idx++) {
+ int ival;
+ ival = serparams[idx].cmd;
+ /*
+ * ival is either the Serial Param# or a temp id.
+ * Do the appropriate Get command, based on ival.
+ */
+ if (ival == CMDID_CA1) {
+ ret = GetChanAcc(ser_ch, 0x40, &SerRecord);
+ } else if (ival == CMDID_UA1) {
+ useridx = 1;
+ ret = GetUserAccess(useridx,(uchar *)&SerRecord,uname);
+ } else if (ival == CMDID_UA2) {
+ useridx = 2;
+ ret = GetUserAccess(useridx,(uchar *)&SerRecord,uname);
+ } else if (ival == CMDID_UA3) {
+ useridx = 3;
+ ret = GetUserAccess(useridx,(uchar *)&SerRecord,uname);
+ } else if (ival == CMDID_UA4) {
+ useridx = 4;
+ if (fIPMI20 == 0) continue; /* IPMI 1.5 only has 3 users */
+ ret = GetUserAccess(useridx,(uchar *)&SerRecord,uname);
+ } else if (ival == CMDID_MUX) {
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x00; /* just get MUX status */
+ ret = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ } else if (ival == CMDID_BOOT) {
+ SerRecord.data[0] = 0x03; /* Boot Param 3 */
+ SerRecord.data[1] = 0x00; /* Set Selector */
+ SerRecord.data[2] = 0x00; /* %%%% */
+ ret = GetMiscEntry(GET_BOOT_OPTIONS, &SerRecord, 3);
+ } else {
+ if (fcanonical) {
+ switch(ival) { /*only show certain parameters*/
+ case 3:
+ case 4:
+ case 6:
+ case 7:
+ case 8:
+ case 29:
+ break;
+ default:
+ continue; break;
+ }
+ }
+ if (vend_id == VENDOR_SUPERMICROX && ival == 8) continue;
+ if (vend_id == VENDOR_SUPERMICRO && ival == 8) continue;
+ if (ival == 17 || ival == 19) bset = ialert;
+ else if (ival == 21) bset = idial;
+ else if (ival == 23) bset = idest;
+ else bset = 0; /*default*/
+ ret = GetSerEntry((uchar)ival, bset, &SerRecord);
+ }
+ /*
+ * Now the Get command is done, check the status, and
+ * show the raw output.
+ */
+ if (ret == 0) { // Show the SER record
+ uchar * pc; int sz;
+ pc = (uchar *)&SerRecord;
+ sz = serparams[idx].sz;
+ /* save some input data for later reuse */
+ if (ival == 16) nalert = pc[0];
+ else if (ival == 20) ndial = pc[0];
+ else if (ival == 22) ndest = pc[0];
+ if (ival == CMDID_CA1) ;
+ else if (ival > CMDID_CA1)
+ printf("%s%c ",serparams[idx].desc,bdelim);
+ else
+ printf("Serial Param(%d) %s%c ",ival,serparams[idx].desc,bdelim);
+ if (ival == 1) { /* Auth Type support*/
+ authmask = pc[0]; /* auth type support mask */
+ mystr[0] = 0;
+ if (authmask & 0x01) strcat(mystr,"None ");
+ if (authmask & 0x02) strcat(mystr,"MD2 ");
+ if (authmask & 0x04) strcat(mystr,"MD5 ");
+ if (authmask & 0x10) strcat(mystr,"Pswd ");
+ if (authmask & 0x20) strcat(mystr,"OEM ");
+ printf("%02x %c %s\n",authmask,bdelim,mystr);
+ }
+ else if (ival == 10) { /* modem init string */
+ pc[sz] = 0;
+ printf("%02x %s\n",pc[0],&pc[1]);
+ }
+ else if (ival == 21) { /* modem dial string */
+ pc[sz] = 0;
+ printf("%02x %02x %s\n",pc[0],pc[1],&pc[2]);
+ }
+ else if ((ival >= 11 && ival <= 13) || ival == 15) { /* strings */
+ pc[sz] = 0;
+ printf("%s\n",pc);
+ }
+ else if (ival == 23) { /* Dest IP Address */
+ printf("%02x %d %d %d %d\n", pc[0], /*dest index*/
+ pc[1],pc[2],pc[3],pc[4]);
+ }
+ else if (ival == CMDID_CA1) { /* Channel Access */
+ ShowChanAccess(ser_ch,"Ser",pc[0],pc[1]);
+ }
+ else if (ival == CMDID_UA1 || ival == CMDID_UA2 ||
+ ival == CMDID_UA3 || ival == CMDID_UA4) {
+ // ShowUserAccess(useridx,pc[0],pc[1],pc[2],pc[3],uname);
+ } /*endif UA*/
+ else /* hex data */
+ {
+ for (i = 0; i < sz; i++) {
+ printf("%02x ",pc[i]); /* show in hex */
+ }
+ /*
+ * Raw hex data display is complete, now do post-processing.
+ * Interpret some hex data.
+ */
+ if (ival == 4) { /* Session Inactivity Timeout */
+ c = pc[0];
+ if (c == 0) strcpy(mystr,"infinite");
+ else sprintf(mystr,"%d sec",(c * 30));
+ printf(" %c %s",bdelim,mystr);
+ }
+ else if (ival == 7) { /*IPMI Msg Comm*/
+ uchar v;
+ char *flow; char *dtr; char *baud;
+ v = pc[0] & 0xc0;
+ switch(v) {
+ case 0x40: flow = "RTS/CTS"; break;
+ case 0x80: flow = "XON/XOFF"; break;
+ case 0x00:
+ default: flow = "no_flow";
+ }
+ if ((pc[0] & 0x20) == 0) dtr="no_DTR";
+ else dtr = "DTR";
+ baud = Baud2Str(pc[1]);
+ printf("%c %s, %s, %s",bdelim,flow,dtr,baud);
+ }
+ else if (ival == 19) { /*Dest Comm Settings*/
+ uchar v;
+ char *flow; char *baud;
+ uchar chsz,parity,stopb;
+ v = pc[1] & 0xc0;
+ switch(v) {
+ case 0x40: flow = "RTS/CTS"; break;
+ case 0x80: flow = "XON/XOFF"; break;
+ case 0x00:
+ default: flow = "no_flow";
+ }
+ if ((pc[1] & 0x10) == 0) stopb = 1;
+ else stopb = 2;
+ if ((pc[1] & 0x08) == 0) chsz = 8;
+ else chsz = 7;
+ v = pc[1] & 0x07;
+ switch(v) {
+ case 1: parity = 'O'; break;
+ case 2: parity = 'E'; break;
+ case 0:
+ default: parity = 'N';
+ }
+ baud = Baud2Str(pc[2]);
+ printf("%c %s, %d%c%d, %s",bdelim,flow,chsz,parity,stopb,baud);
+ }
+#ifdef TEST
+ /* This MUX reading is volatile and may not be accurate */
+ else if (ival == CMDID_MUX) {
+ /* Apparently this always shows 0x01 even if System. */
+ if (pc[0] & 0x01 == 1) printf("%c BMC",bdelim);
+ else printf("%c System",bdelim); /*BIOS*/
+ }
+#endif
+ printf("\n");
+ } /*end else hex*/
+ } /*endif show*/
+ if (ival == 17 || ival == 19) { /* alert params */
+ if (ialert < nalert) {
+ ialert++;
+ idx--; /* repeat this param*/
+ } else ialert = 1;
+ }
+ if (ival == 21) { /* dial param */
+ if (idial < ndial) {
+ idial++;
+ idx--; /* repeat this param*/
+ } else idial = 1;
+ }
+ if (ival == 23) { /* dest param */
+ if (idest < ndest) {
+ idest++;
+ idx--; /* repeat this param*/
+ } else idest = 1;
+ }
+ } /*end for(idx) serial params*/
+
+ for (i = 1; i <= show_users; i++)
+ ret = GetUserAccess((uchar)i,(uchar *)&SerRecord,uname);
+
+ if (!freadonly) { /* set serial channel parameters */
+ uchar access;
+ if (fBasebdOn) { /* -m0 */
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x03; /* force switch to Baseboard */
+ ret = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ printf("SetSerialMux(System), ret = %d, value = %02x\n",
+ ret,SerRecord.data[0]);
+ } else if (fTModeOn) { /* -m1 */
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x04; /* force switch to BMC for TMode */
+ ret = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ printf("SetSerialMux(BMC), ret = %d, value = %02x\n",
+ ret,SerRecord.data[0]);
+
+ } else if (fDisable) { /* -d */
+ /*
+ * DISABLE SERIAL CHANNEL ACCESS
+ */
+ if (vend_id == VENDOR_INTEL && fuser1admin) {
+ /* First, make sure null user (1) has admin privileges again */
+ SerRecord.data[0] = 0x90 | ser_ch; /*0x91*/
+ SerRecord.data[1] = 0x01; /*user 1*/
+ SerRecord.data[2] = ser_access; /* usu 0x04 admin access*/
+ SerRecord.data[3] = 0x00;
+ ret = SetMiscEntry(SET_USER_ACCESS, &SerRecord, 4);
+ printf("SetUserAccess(1/%02x), ret = %d\n",ser_access,ret);
+ }
+ if (usernum != 0) { /*disable usernum if specified*/
+ SerRecord.data[0] = 0x80 | ser_ch; /*0x81*/
+ SerRecord.data[1] = usernum;
+ SerRecord.data[2] = 0x0F; /*No access*/
+ SerRecord.data[3] = 0x00;
+ ret = SetMiscEntry(SET_USER_ACCESS, &SerRecord, 4);
+ printf("SetUserAccess(%d/none), ret = %d\n",usernum,ret);
+ }
+ ret = SetChanAcc(ser_ch, 0x80, 0x20); /*vol access=disabled*/
+ if (fdebug) printf("SetChanAcc(ser/disable), ret = %d\n",ret);
+ ret = SetChanAcc(ser_ch, 0x40, 0x20); /*nvol access=disabled*/
+ printf("SetChanAcc(ser/disable), ret = %d\n",ret);
+ ret = GetChanAcc(ser_ch, 0x40, &SerRecord);
+ access = SerRecord.data[0];
+ printf("GetChanAcc(ser/disable), ret = %d, new value = %02x\n",
+ ret,access);
+ if ((vend_id != VENDOR_SUPERMICROX) &&
+ (vend_id != VENDOR_SUPERMICRO)) {
+ /* Also disable the Serial Parameter 3: Connection Mode */
+ SerRecord.data[0] = 0x00; /* Connection Mode = none */
+ ret = SetSerEntry(3, &SerRecord,1);
+ printf("SetSerEntry(3/disable), ret = %d\n",ret);
+ }
+
+ } else if (fSetTMode || fBMode) {
+ /*
+ * ENABLE SERIAL CHANNEL ACCESS
+ * Enable: configure everything for TMode and/or BMode
+ *
+ * Set Serial/EMP Channel Access
+ * Use serial channel in shared mode
+ * 0x20 means alerting=off, disabled (system only)
+ * 0x22 means alerting=off, always avail
+ * which would only show BMC messages, not OS messages
+ * 0x23 means alerting=off, always avail + shared + user-auth on
+ * 0x2A means alerting=off, always avail + user-auth off
+ * 0x2B means alerting=off, always avail + shared + user-auth off
+ * 0x0B means alerting=on, always avail + shared + user-auth off
+ * SSU won't set 0x2B, but we need shared access mode.
+ */
+ if (fconsoleonly) {
+ access = ALWAYS_NOAUTH; /*0x2A*/
+ } else if (fnotshared) { /* serial IPMI, but no console (-e only) */
+ if (fSetTMode) access = ALWAYS_NOAUTH; /*0x2A*/
+ else access = ALWAYS_AUTH; /*0x22*/
+ } else { /* shared with BIOS console, normal */
+ if (fSetTMode) access = SHARED_NOAUTH; /*0x2B*/
+ else access = SHARED_AUTH; /*0x23*/
+ }
+ ret = SetChanAcc(ser_ch, 0x80, access);
+ if (fdebug) printf("SetChanAcc(ser/active), ret = %d\n",ret);
+ ret = SetChanAcc(ser_ch, 0x40, access);
+ printf("SetChanAcc(ser), ret = %d\n",ret);
+ ret = GetChanAcc(ser_ch, 0x80, &SerRecord);
+ if (fdebug) {
+ access = SerRecord.data[0];
+ printf("GetChanAcc(ser/active), ret = %d, new value = %02x\n",
+ ret,access);
+ }
+ ret = GetChanAcc(ser_ch, 0x40, &SerRecord);
+ access = SerRecord.data[0];
+ printf("GetChanAcc(ser), ret = %d, new value = %02x\n",
+ ret,access);
+ ShowChanAccess(ser_ch,"ser",access,SerRecord.data[1]);
+
+ /* Needed if (fSetTMode), otherwise extra. */
+ {
+ /* auth types: pswd, MD5, MD2, none */
+ if (authmask == 0) authmask = 0x17;
+ SerRecord.data[0] = (0x16 & authmask); /*Callback level*/
+ SerRecord.data[1] = (0x16 & authmask); /*User level */
+ SerRecord.data[2] = (0x16 & authmask); /*Operator level*/
+ SerRecord.data[3] = (0x16 & authmask); /*Admin level */
+ SerRecord.data[4] = 0x00; /*OEM level*/
+ ret = SetSerEntry(2, &SerRecord,5);
+ printf("SetSerEntry(2), ret = %d\n",ret);
+ }
+ if (fconsoleonly) SerRecord.data[0] = 0x81; /*direct, Basic only */
+ else if (fBMode) SerRecord.data[0] = 0x83; /*direct; PPP & Basic */
+ else SerRecord.data[0] = 0x87; /*direct; TMode, PPP, Basic*/
+ if ((vend_id != VENDOR_SUPERMICROX) &&
+ (vend_id != VENDOR_SUPERMICRO)) {
+ ret = SetSerEntry(3, &SerRecord,1);
+ printf("SetSerEntry(3), ret = %d\n",ret);
+ }
+ /*
+ * BMode inactivity timeout = 2 (* 30 sec = 60 sec)
+ * TMode inactivity timeout = 0 (infinite)
+ */
+ if (fBMode) SerRecord.data[0] = 0x02;
+ else SerRecord.data[0] = inactivity; /*usu 0, infinite*/
+ ret = SetSerEntry(4, &SerRecord,1);
+ printf("SetSerEntry(4), ret = %d\n",ret);
+ if ((vend_id != VENDOR_SUPERMICROX) &&
+ (vend_id != VENDOR_SUPERMICRO)) {
+ // SerRecord.data[0] = 0x02; /* enable inactivity, ignore DCD */
+ SerRecord.data[0] = 0x03; /* enable inactivity, enable DCD */
+ ret = SetSerEntry(6, &SerRecord,1);
+ printf("SetSerEntry(6), ret = %d\n",ret);
+ /* flow control: 60=RTS/CTS+DTR, 20=none+DTR */
+ SerRecord.data[0] = (bFlow << 6) | 0x20;
+ SerRecord.data[1] = newbaud; /* baud default = 19.2K bps */
+ ret = SetSerEntry(7, &SerRecord,2);
+ printf("SetSerEntry(7) baud %s, ret = %d\n",Baud2Str(newbaud),ret);
+ if (fBMode) {
+ SerRecord.data[0] = 0x1e; /* mux 2way control, GetChanAuth, PPP */
+ } else { /*TMode*/
+ // SerRecord.data[0] = 0x1e; /* mux 2way control,GetChanAuth,PPP */
+ SerRecord.data[0] = 0x16; /* mux 2way control, GetChanAuth,no PPP*/
+ /* 2way: <ESC>( and <ESC>Q */
+ }
+ if (fconsoleonly)
+ SerRecord.data[1] = 0x09; /* enable serial port sharing, hb=not */
+ else if (fBMode && !fShared) /* Basic Mode and NOT shared */
+ SerRecord.data[1] = 0x0a; /* enable serial port sharing,heartbeat*/
+ else
+ SerRecord.data[1] = 0x08; /* enable serial port sharing, hb=off */
+ ret = SetSerEntry(8, &SerRecord,2);
+ printf("SetSerEntry(8), ret = %d\n",ret);
+ }
+
+ if (fSetUser3) {
+ if (usernum == 0) usernum = ser_user; /* user 3 */
+ /*
+ * Set up admin user for Serial User (usu User# 3)
+ * Username: root
+ * Password: password
+ *
+ * cmdtool 20 18 45 3 72 6F 6F 74 0 0 0 0 0 0 0 0 0 0 0 0
+ * cmdtool 20 18 47 3 2 70 61 73 73 77 6F 72 64 0 0 0 0 0 0 0 0
+ * cmdtool 20 18 47 3 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ */
+ SerRecord.data[0] = usernum; /* user 3 */
+ memset(&SerRecord.data[1],0,16);
+ memcpy(&SerRecord.data[1],rguser,strlen(rguser));
+ ret = SetMiscEntry(SET_USER_NAME, &SerRecord, 17);
+ printf("SetUserName(%d), ret = %d\n",usernum,ret);
+ /* set password for user 3 */
+ SerRecord.data[0] = usernum;
+ SerRecord.data[1] = 0x02;
+ memset(&SerRecord.data[2],0,PSW_LEN);
+ memcpy(&SerRecord.data[2],rgpasswd,strlen(rgpasswd));
+ ret = SetMiscEntry(SET_USER_PASSWORD, &SerRecord, 2+PSW_LEN);
+ printf("SetUserPassword(%d,2), ret = %d\n",usernum,ret);
+ /* enable user 3 */
+ SerRecord.data[0] = usernum;
+ SerRecord.data[1] = 0x01;
+ memset(&SerRecord.data[2],0,PSW_LEN);
+ ret = SetMiscEntry(SET_USER_PASSWORD, &SerRecord, 2+PSW_LEN);
+ printf("SetUserPassword(%d,1), ret = %d\n",usernum,ret);
+
+ /* Testing User #3 password */
+ // cmdtool 20 18 47 3 3 70 61 73 73 77 6F 72 64 0 0 0 0 0 0 0 0
+ SerRecord.data[0] = usernum;
+ SerRecord.data[1] = 0x03;
+ memset(&SerRecord.data[2],0,PSW_LEN);
+ memcpy(&SerRecord.data[2],rgpasswd,strlen(rgpasswd));
+ ret = SetMiscEntry(SET_USER_PASSWORD, &SerRecord, 2+PSW_LEN);
+ printf("SetUserPassword(%d,3), ret = %d\n",usernum,ret);
+
+ /* Set User #3 access up w/ ADMIN privilege for serial channel */
+ // cmdtool 20 18 43 91 3 4 0
+ SerRecord.data[0] = 0x90 | ser_ch; /*0x91*/
+ SerRecord.data[1] = usernum; /* user 3 */
+ SerRecord.data[2] = ser_access; /*usu 0x04; Admin*/
+ SerRecord.data[3] = 0x00;
+ ret = SetMiscEntry(SET_USER_ACCESS, &SerRecord, 4);
+ printf("SetUserAccess(%d/%02x), ret = %d\n",usernum,ser_access,ret);
+
+ if (ipmi_reserved_user(vend_id,0x01) == 0) {
+ /* Set NULL user access up w/ USER privilege for serial channel */
+ // cmdtool 20 18 43 91 1 2 0
+ SerRecord.data[0] = 0x90 | ser_ch; /*0x91*/
+ SerRecord.data[1] = 0x01; /* user 1 (default) */
+ SerRecord.data[2] = 0x02; /* user privilege */
+ SerRecord.data[3] = 0x00;
+ ret = SetMiscEntry(SET_USER_ACCESS, &SerRecord, 4);
+ printf("SetUserAccess(1/user), ret = %d\n",ret);
+ }
+ } else {
+ /* No username specified, use NULL user 1 for Serial */
+ if (ipmi_reserved_user(vend_id,0x01) == 0) {
+ /* Set NULL user password, if specified */
+ if (fSetPsw) {
+ SerRecord.data[0] = 0x01; /*user 1*/
+ SerRecord.data[1] = 0x02;
+ memset(&SerRecord.data[2],0,PSW_LEN);
+ memcpy(&SerRecord.data[2],rgpasswd,strlen(rgpasswd));
+ ret = SetMiscEntry(SET_USER_PASSWORD, &SerRecord, 2+PSW_LEN);
+ printf("SetUserPassword(1,2), ret = %d\n",ret);
+ /* make sure user 1 is enabled */
+ SerRecord.data[0] = 0x01;
+ SerRecord.data[1] = 0x01;
+ memset(&SerRecord.data[2],0,PSW_LEN);
+ ret = SetMiscEntry(SET_USER_PASSWORD, &SerRecord, 2+PSW_LEN);
+ printf("SetUserPassword(1,1), ret = %d\n",ret);
+ }
+ /* Set NULL user access up w/ ADMIN privilege for serial channel */
+ // cmdtool 20 18 43 91 1 4 0
+ SerRecord.data[0] = 0x90 | ser_ch; /*0x91*/
+ SerRecord.data[1] = 0x01; /* user 1 */
+ SerRecord.data[2] = ser_access; /* admin */
+ SerRecord.data[3] = 0x00;
+ ret = SetMiscEntry(SET_USER_ACCESS, &SerRecord, 4);
+ printf("SetUserAccess(1/%02x), ret = %d\n",ser_access,ret);
+ }
+ }
+
+ if (fSetTMode) {
+ /*
+ * Set the TMode configuration:
+ * Enable line editing
+ * Delete seq = bksp-sp-bksp
+ * Enable echo
+ * Handshake (hb) = off
+ * Output newline seq = CR-LF
+ * Input newline seq = CR
+ */
+ if ((vend_id != VENDOR_SUPERMICROX) &&
+ (vend_id != VENDOR_SUPERMICRO)) {
+#ifdef TEST
+ SerRecord.data[0] = 0xA6; /* sets bit for volatile - wrong */
+ SerRecord.data[1] = 0x11;
+ ret = SetSerEntry(29, &SerRecord,2);
+#endif
+ SerRecord.data[0] = 0x66;
+ SerRecord.data[1] = 0x11;
+ ret = SetSerEntry(29, &SerRecord,2);
+ printf("SetSerEntry(29), ret = %d\n",ret);
+ }
+
+ /* Force mux switch to the BMC and start talking... */
+ /* Set Serial/Modem Mux */
+ /* cmdtool 20 30 12 1 4 */
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x02; /* was 0x04 to force switch to BMC */
+ i = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ printf("SetSerialMux(BMC), ret = %d, value = %02x\n",
+ i,SerRecord.data[0]);
+ } /*endif fSetTMode*/
+
+ else { /* fBMode */
+ if (fShared) {
+ uchar bval;
+ /* workaround for BMC bug w BIOS Console Redirect */
+ SerRecord.data[0] = 0x03; /* Boot Param 3 */
+ if (bootflags < 16) { /* user specified a boot flag */
+ SerRecord.data[1] = bootflags; /* Flags */
+ bval = SerRecord.data[1];
+ ret = SetMiscEntry(SET_BOOT_OPTIONS, &SerRecord, 2);
+ printf("SetBootOptions(3), new value = %02x, ret = %d\n",
+ bval,ret);
+ }
+
+ /* Force mux switch to the Baseboard initially */
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x03; /* force switch to Baseboard */
+ i = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ printf("SetSerialMux(System), ret = %d, value = %02x\n",
+ i,SerRecord.data[0]);
+ } else { /* not shared, BMode only */
+ /* Force mux switch to the BMC and start talking... */
+ SerRecord.data[0] = ser_ch; /* channel 1 = EMP */
+ SerRecord.data[1] = 0x04; /* 0x04 to force switch to BMC */
+ i = SetMiscEntry(SET_SER_MUX, &SerRecord, 2);
+ printf("SetSerialMux(BMC), ret = %d, value = %02x\n",
+ i,SerRecord.data[0]);
+ }
+ } /*end-else BMode*/
+ } /*end-else Enable (not Disable) */
+ else { /*not enable or disable BMode/TMode */
+ if (!fcanonical)
+ printf("Please specify a configuration mode (b,d,e,m,s,t)\n");
+ }
+ } /*endif not readonly */
+ } /* endif ok */
+do_exit:
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return(ret);
+} /* end main()*/
+
+/************************
+DPC configuration stuff on serial.
+16:25:08.165 outgoing: set system boot options[08] 20 00 E0 81 6C 08 02 02 07
+16:25:08.165 outgoing: set system boot options[08] 20 00 E0 81 70 08 06 01 0B 28 11 02 45 1F 96 3C 84
+16:25:08.165 outgoing: set system boot options[08] 20 00 E0 81 74 08 04 FF FF 01
+16:25:08.165 outgoing: set system boot options[08] 20 00 E0 81 78 08 03 00 FC
+16:25:08.245 INCOMING: SET SYSTEM BOOT OPTIONS[08] 81 04 7B 20 6C 08 -[00]- 6C
+16:25:08.245 INCOMING: SET SYSTEM BOOT OPTIONS[08] 81 04 7B 20 70 08 -[00]- 68
+16:25:08.245 outgoing: set system boot options[08] 20 00 E0 81 7C 08 05 80 00 4A 00 00 2C
+16:25:08.255 outgoing: chassis control[02] 20 00 E0 81 80 02 03 FA
+ ************************/
+/* end iserial.c */
diff --git a/util/isol.c b/util/isol.c
new file mode 100644
index 0000000..381668e
--- /dev/null
+++ b/util/isol.c
@@ -0,0 +1,1347 @@
+/*
+ * isol.c (was isolconsole.c)
+ * IPMI Serial-Over-LAN console application
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2007 Intel Corporation
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 10/12/06 Andy Cress - created, just a framework for now
+ * 02/08/07 Andy Cress - now working for IPMI LAN 2.0 SOL in Linux,
+ * still stdio problems in Windows
+ * 02/23/07 Andy Cress - fixed Windows stdin, still Windows output issues,
+ * need more in xlate_vt100_win().
+ * 04/06/07 Andy Cress - more vt100-to-windows translation,
+ * added -r for raw termio
+ * 04/19/07 Andy Cress - more vt100-to-windows translation,
+ * 05/08/07 Andy Cress - more logic for 1.5 SOL. Session opens but
+ * 1.5 SOL data packets are not yet working.
+ * 05/24/07 Andy Cress - Fix Enter key confusion in BIOS Setup (use CR+LF)
+ * 06/15/07 Andy Cress - More fixes to Windows translation (fUseWinCon)
+ * 08/20/07 Andy Cress - moved Windows translation to isolwin.c
+ * See ChangeLog for further changes
+ *
+ * NOTE: There are a few other options for Serial-Over-LAN console
+ * applications:
+ * ipmitool.sf.net has v2 sol console capability for Linux (BSD)
+ * Intel dpccli, a CLI console for Linux and Windows (proprietary)
+ * Intel ISM console for Windows (proprietary)
+ * Intel System Management Software (LANDesk) console, proprietary
+ * The Intel applications support both IPMI 1.5 and 2.0 SOL
+ * protocols.
+ */
+/*M*
+Copyright (c) 2007 Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#if defined(DOS)
+#include <dos.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+int i_sol(int argc, char **argv)
+{
+ printf("IPMI SOL console is not supported under DOS.\n");
+ return(1);
+}
+#else
+
+/* All other OSs: Linux, Windows, Solaris, BSD */
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <winsock.h>
+#include <io.h>
+#include "getopt.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <termios.h>
+#include <unistd.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ipmilanplus.h"
+
+#define ACTIVATE_PAYLOAD 0x48
+#define DEACTIVATE_PAYLOAD 0x49
+#define PAYLOAD_TYPE_SOL 0x01
+#define SOL_SERIAL_ALERT_MASK_DEFERRED 0x04
+#define SOL_BMC_ASSERTS_CTS_MASK_TRUE 0x00
+#define SOL_BMC_ASSERTS_CTS_MASK_FALSE 0x02
+#define IPMI_PAYLOAD_TYPE_SOL 0x01
+#define AUTHTYPE_RMCP_PLUS 0x06
+#define RV_END -2
+#define CH_CR '\r' /*0x0D =='\r'*/
+#define CH_LF '\n' /*0x0A =='\n' LineFeed(Down) */
+#define CH_ESC '\033' /*0x1B == ASCII Escape */
+#define CH_CTL '\316' /*0xCE == VT100 Control */
+#define CH_DEL '\177' /*0x7F == Delete key */
+#define CH_BS '\010' /*0x08 == Backspace */
+#define CH_TAB '\011' /*0x09 == Tab */
+#define CH_UP '\013' /*0x0B == Up Arrow */
+
+/* Input data buffer size: screen size (80*24) = 1920 */
+/* IPMI_BUF_SIZE = 1024, less RMCP+IPMI hdr */
+/* IDATA_SZ=2048 was too big, used =300 thru v2.1.0 */
+#define IDATA_SZ 512
+#define IPKT_SZ 512
+#define MAX_INTEL_DATA 203 /*sol_send >= 204 bytes gives error w Intel BMC*/
+#define MAX_DELL_DATA 46 /*sol_send >= 46 bytes gives error w Dell BMC*/
+#define MAX_KONTRON_DATA 74 /*sol_send >= 75 bytes gives error w Kontron BMC*/
+#define MAX_OTHER_DATA 45 /*use a small sol_send limit of 45 by default */
+
+typedef struct {
+ int type;
+ int len;
+ char *data;
+ } SOL_RSP_PKT;
+
+extern void tty_setraw(int mode); /*from ipmicmd.c*/
+extern void tty_setnormal(int mode); /*from ipmicmd.c*/
+/* extern int tty_getattr(int *lflag,int *oflag,int *iflag); *from ipmicmd.c*/
+extern SockType lan_get_fd(void); /*from ipmilan.c*/
+extern int lan_send_sol( uchar *payload, int len, SOL_RSP_PKT *rsp);
+extern int lan_recv_sol( SOL_RSP_PKT *rsp );
+extern int lan_keepalive(int type);
+extern void lan_get_sol_data(uchar fEnc, uchar iseed, uint32 *seed);
+extern void lan_set_sol_data(uchar fEnc, uchar auth, uchar iseed,
+ int insize, int outsize);
+/* lan2 routines, from ipmilanplus.c, even if not HAVE_LANPLUS: */
+extern int lan2_get_fd(void); /*from ipmilanplus.c*/
+extern int lan2_send_sol( uchar *payload, int len, SOL_RSP_PKT *rsp);
+extern int lan2_recv_sol( SOL_RSP_PKT *rsp );
+extern void lan2_set_sol_data(int in, int out, int port, void*hnd, char esc);
+extern int lan2_keepalive(int type, SOL_RSP_PKT *rsp);
+extern void lan2_recv_handler( void *rs );
+extern long lan2_get_latency( void ); /*from ipmilanplus.c*/
+extern void lanplus_set_recvdelay( int delay ); /*lib/lanplus/lanplus.c*/
+extern int lan2_send_break( SOL_RSP_PKT *rsp );
+
+extern char fdbglog; /*see ipmilanplus.c*/
+extern char log_name[]; /*see ipmicmd.c*/
+extern int is_lan2intel(int vend, int prod); /*see oem_intel.c*/
+void dbglog( char *pattn, ... ); /*local prototype*/
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "isol";
+static char fdebug = 0;
+static char fpicmg = 0;
+static char factivate = 0;
+static char fdeactivate = 0;
+static char fScript = 0;
+static char fTrace = 0;
+static char fprivset = 0;
+static char bDriver = 0;
+static uchar bSolVer = 0;
+static uchar bKeepAlive = 1; /*1=GetDeviceID, 2=empty SOL data*/
+static char sol_esc_len = 2; /* SOL escape seq ("~.") */
+static char sol_esc_ch = '~';
+static char sol_esc_pending = 0;
+static char sol_esc_fn[4] = {'.','b','d', '?'}; /* SOL escape functions */
+static char file_scr[80] = {""};
+static char file_trc[80] = {""};
+static char dbglog_name[40] = "isoldbg.log";
+static FILE *fp_scr = NULL;
+static FILE *fp_trc = NULL;
+static uchar ipmi_maj = 0;
+static uchar ipmi_min = 0;
+static int vend_id = 0; /* Manufacturer IANA vendor id */
+static int prod_id = 0;
+static uchar fSolEncryption = 1;
+static uchar fSolAuthentication = 1;
+static int sol_timeout = 30; /* default: send keepalive every 30 seconds */
+static time_t keepalive_start;
+static int max_bmc_data = MAX_OTHER_DATA;
+static int fgotrecv = 0;
+static int fsentok = 0;
+static uchar payload_instance = 1;
+char fUseWinCon = 1;
+uchar fCRLF = 0; /* 0=use CR, 1=use legacy CR+LF, 2=use LF (like raw) */
+uchar fRaw = 0;
+uchar bTextMode = 0;
+int sol_done = 0;
+int wait_time = 500; /*number of msec to wait*/
+int retry_time = 5; /*number of msec between retries*/
+
+static int sol_ver = 2; /*use IPMI 2.0 SOL by default*/
+static int sol_retries = 1; /*send retries for sol_input_handler*/
+static int sol_recvdelay = 0; /*if != 0, num us to delay before recv*/
+static uchar sol15_iseed = 0x01; /*initial seed count, usu 0 or 1 */
+static uint32 sol15_wseed = 0; /*32-bit seed value*/
+static long lan2_latency = 0; /*lan2 latency in msec */
+static long lan2_slow = 100; /*slow if latency > 100 msec */
+
+extern FILE *fplog; /*see ipmicmd.c*/
+#ifdef WIN32
+/* these routines are in isolwin.c */
+extern DWORD WINAPI input_thread( LPVOID lpParam);
+extern void console_open(char fdebugcmd);
+extern void console_close(void);
+extern void console_out(uchar *pdata, int len);
+extern int console_in(DWORD keydata, uchar *pdata, int len);
+extern int os_select(int infd, SockType sfd, fd_set *read_fds, fd_set *error_fds);
+extern int os_read(int fd, uchar *buf, int sz);
+extern void Ascii2KeyCode(uchar c, uchar *buf);
+#else
+
+/*======== start Linux ===============================*/
+int os_read(int fd, uchar *buf, int sz)
+{
+ int len = 0;
+ len = read(fd, buf, sz);
+ return(len);
+}
+
+int os_select(int infd, SockType sfd, fd_set *read_fds, fd_set *error_fds)
+{
+ int rv = 0;
+ struct timeval tv;
+
+ /* Linux handles both stdin & socket via select() */
+ FD_ZERO(read_fds);
+ FD_SET(infd, read_fds);
+ FD_SET(sfd, read_fds);
+ FD_ZERO(error_fds);
+ FD_SET(sfd, error_fds);
+ tv.tv_sec = 0;
+ tv.tv_usec = wait_time * 1000; /* 500000 usec, 500 msec, 0.5 sec*/
+ rv = select((int)(sfd + 1), read_fds, NULL, error_fds, &tv);
+ return rv;
+}
+
+void CheckTextMode(uchar *buffer, int sbuf)
+{
+ int c, i, j, imatch;
+ uchar pattern[5] = {CH_ESC,'[','0','0','m'}; /*was [0m */
+ int spattern = 5;
+
+ /* if CH_ESC,"[0m", TextMode change */
+ j = 0;
+ imatch = 0;
+ for (j = 0; j < sbuf; j++) {
+ if ((sbuf - j) < spattern && imatch == 0) break;
+ c = buffer[j];
+ if (c == pattern[imatch]) {
+ imatch++;
+ } else if (pattern[imatch] == '?') { /*wildcard char*/
+ imatch++;
+ } else if (pattern[imatch] == '0' && (c>='0' && c <='9')) { /*numeric*/
+ imatch++;
+ } else {
+ if (imatch > 0) {
+ if (j > 0) j--; /* try again with the first match char */
+ imatch = 0;
+ }
+ }
+ if (imatch == spattern) { /*match found*/
+ char mystr[5];
+ i = (j+1) - imatch; /*buffer[i] is the match */
+ // bTextMode = buffer[i+2] & 0x0f; /* usu 0 or 1 */
+ mystr[0] = buffer[i+2];
+ mystr[1] = buffer[i+3];
+ mystr[2] = 0;
+ bTextMode = atob(mystr);
+ dbglog("TextMode changed to %d\n",bTextMode);
+ }
+ else if (imatch > spattern) break;
+ }
+ return;
+}
+
+/*======== end Linux =================================*/
+#endif
+
+void printm( char *pattn, ... )
+{ /* all sol error/info messages go to log or stderr by default */
+ va_list arglist;
+ FILE *fp;
+ if (fdbglog && fplog != NULL) fp = fplog;
+ else fp = stderr;
+ va_start(arglist, pattn);
+ vfprintf(fp, pattn, arglist);
+ va_end(arglist);
+ fprintf(fp,"\r\n");
+}
+
+void dbglog( char *pattn, ... )
+{
+ va_list arglist;
+ int fadd = 0;
+ int l;
+#ifdef WIN32
+ FILE *fp;
+ // char _pattn[80];
+ if (fdebug == 0 && fdbglog == 0) return;
+ if (fdbglog && fplog != NULL) fp = fplog;
+ else fp = stderr;
+ l = (int)strlen(pattn);
+ if ((l >= 1) && (pattn[l-1] == '\n')) { /*check EOL chars*/
+ if (pattn[l-2] == '\r') fadd = 0;
+ else fadd = 0; /* '\n' only */
+ // else _pattn[l-1] = 0; /*truncate, add \r\n below, dangerous*/
+ } else fadd = 1; /*no line-end, so add it below*/
+ va_start(arglist, pattn);
+ vfprintf(fp, pattn, arglist);
+ va_end(arglist);
+ if (fadd) fprintf(fp,"\r\n");
+#else
+ char logtmp[LOG_MSG_LENGTH];
+ if (fdebug == 0 && fdbglog == 0) return;
+ l = strlen(pattn);
+ if ((l >= 1) && (pattn[l-1] == '\n')) fadd = 0;
+ else fadd = 1;
+ va_start( arglist, pattn );
+ vsnprintf(logtmp, LOG_MSG_LENGTH, pattn, arglist);
+ va_end( arglist );
+ if (fadd) strcat(logtmp,"\n");
+ if (fdbglog) print_log(logtmp);
+ else if (fdebug) fprintf( stderr, "%s", logtmp);
+#endif
+}
+
+void dbg_dump(char *tag, uchar *pdata, int len, int fascii)
+{
+ FILE *fp = NULL;
+ if (fdebug == 0 && fdbglog == 0) return;
+ if (fdbglog && (fplog != NULL)) fp = fplog;
+ dump_log(fp,tag,pdata,len,(char)fascii); /*uses fplog or fpdbg */
+}
+
+#ifdef OLD
+static void set_latency( struct timeval *t1, struct timeval *t2, long *latency)
+{
+ long nsec;
+ nsec = t2->tv_sec - t1->tv_sec;
+ if ((ulong)(nsec) > 1) nsec = 1;
+ *latency = nsec*1000 + (t2->tv_usec - t1->tv_usec)/1000;
+}
+#endif
+
+static int sol_send(uchar *buf, int len, SOL_RSP_PKT *rsp)
+{
+ int rv = 0;
+ if (bSolVer == 1) {
+ rv = lan_send_sol(buf, len, rsp);
+ } else {
+ rv = lan2_send_sol(buf, len, rsp);
+ if (rv == 0x01) rv = 0;
+ /* else bit-mapped error, 0x02 = need retry*/
+ }
+ return(rv);
+}
+
+static int sol_recv( SOL_RSP_PKT *rsp)
+{
+ int rv = 0;
+ if (bSolVer == 1) {
+ rv = lan_recv_sol( rsp );
+ } else
+ rv = lan2_recv_sol( rsp );
+ return(rv);
+}
+
+static SockType sol_get_fd(void)
+{
+ SockType fd = 0;
+ if (bSolVer == 1) {
+ fd = lan_get_fd();
+ } else
+ fd = lan2_get_fd();
+ return(fd);
+}
+
+/*
+ * sol_output_handler
+ * This routine is called both in isol.c and ipmilanplus.c/lan2_recv_handler
+ * whenever SOL data is received from the BMC for output to the console.
+ */
+void sol_output_handler(SOL_RSP_PKT *rsp)
+{
+ if (rsp == NULL) return;
+ if (rsp->type == PAYLOAD_TYPE_SOL)
+ {
+#ifdef WIN32
+ fgotrecv = 1;
+ if (fdbglog) dbg_dump("sol_output(console_out)",rsp->data,rsp->len,1);
+ console_out(rsp->data,rsp->len);
+#else
+ uchar *pdata;
+ int len;
+ int i;
+ uchar c;
+ // int mode;
+
+ fgotrecv = 1;
+ pdata = rsp->data;
+ len = rsp->len;
+ if (fdbglog) {
+ // dbglog("sol_output: len = %d\n",len);
+ dbg_dump("sol_output",pdata,len,1); /*like printlog*/
+ }
+ CheckTextMode(pdata,len);
+ for (i = 0; i < len; i++) {
+ c = pdata[i];
+ /* do special character handling here?
+ * CH_CR, 0xb0-0xb3, 0xdb */
+ putc(c, stdout);
+ }
+ fflush(stdout);
+#endif
+ if (fTrace) { fwrite(rsp->data,1,rsp->len,fp_trc); fflush(fp_trc); }
+ } else {
+ dbglog("sol_output: rsp.type=%x, rsp.len=%d\n", rsp->type, rsp->len);
+ }
+}
+
+static int sol_keepalive(int type)
+{
+ int rv = 0;
+ time_t end;
+
+ time(&end);
+ if (sol_timeout == 0) return(rv);
+ if ((end - keepalive_start) > sol_timeout) {
+ dbglog("sol_keepalive: timeout, lan%d\n",bSolVer); /*++++*/
+ if (bSolVer == 1) {
+ rv = lan_keepalive(type);
+ } else {
+ SOL_RSP_PKT rs;
+ rv = lan2_keepalive(type, &rs);
+ if (rv >= 0 && rs.len != 0) { /*handle any rsp data*/
+ if (rs.type == IPMI_PAYLOAD_TYPE_SOL) {
+ dbglog("keepalive: output_handler(%d)\n",rs.len);
+ sol_output_handler(&rs);
+ }
+ }
+ }
+ time(&keepalive_start); /*time in seconds*/
+ dbglog("sol_keepalive sent, rv = %d\n",rv);
+ flush_log();
+ }
+ return(rv);
+}
+
+static void sol_keepalive_reset(void)
+{
+ /* not idle, so reset the keepalive timer */
+ time(&keepalive_start); /*time in seconds*/
+}
+
+static int send_break( void )
+{
+ SOL_RSP_PKT rs;
+ int rv;
+
+ if (sol_ver == 1) return LAN_ERR_NOTSUPPORT;
+ rv = lan2_send_break(&rs);
+ dbglog("lan2_send_break rv=%d rs.len=%d\n", rv,rs.len);
+ return(rv);
+}
+
+static int send_ctlaltdel( void )
+{
+ uchar buf[8];
+ int rv, rlen;
+
+// #define TESTALT 1
+#ifdef TESTALT
+ SOL_RSP_PKT rs;
+ /* This doesn't work. Fix it later. */
+ /* Problem is that keycodes must be translated for serial console */
+ /* CtrlL = 0x0706, AltL = 0x0703, Del = 0x007f, MetaDel = 0x087f
+ * Del = keycode 0x53
+ * 1b 53 33 7e = alt+del
+ * 1b 4f 48 = ctl-alt-home
+ * 1b 4f 46 = ctl-alt-end
+ * 1b 53 33 3b 38 7e = ctl+alt+shift+del
+ * 1b 53 33 3b 33 7e = ctl+alt+ins
+ * 1b 53 33 3b 35 7e = ctl+alt+ins
+ * 1b 53 35 3b 37 7e = ctl+alt+pgup
+ * 1b 53 36 3b 37 7e = ctl+alt+pgdn
+ * Need to find a sequence at serial console that does a reboot
+ * when the command prompt is not up.
+ */
+ buf[0] = 0x1b;
+ buf[1] = 0x53;
+ buf[2] = 0x33;
+ buf[3] = 0x3b;
+ buf[4] = 0x36;
+ buf[5] = 0x7e;
+ rv = sol_send(buf, 6, &rs);
+ rlen = rs.len;
+#else
+ uchar rbuf[16];
+ uchar cc;
+
+ rlen = sizeof(rbuf);
+ buf[0] = 5; /*soft reset via ACPI */
+ rv = ipmi_cmdraw(CHASSIS_CTL,NETFN_CHAS,BMC_SA, PUBLIC_BUS, BMC_LUN,
+ buf,1,rbuf,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+#endif
+ dbglog("send_ctlaltdel rv=%d rlen=%d\n", rv,rlen);
+ return(rv);
+}
+
+static void show_esc_help( void )
+{
+ printf("%c?\r\n",sol_esc_ch);
+ printf("Supported SOL escape sequences:\r\n");
+ printf("\t%c. - terminate connection\r\n",sol_esc_ch);
+ printf("\t%cB - send break\r\n",sol_esc_ch);
+ printf("\t%cD - send ctl-alt-delete (chassis soft reset)\r\n",sol_esc_ch);
+ printf("\t%c? - show this help message\r\n",sol_esc_ch);
+ printf("\t%c%c - send the escape character by typing it twice\r\n",
+ sol_esc_ch, sol_esc_ch);
+}
+
+int sol_input_handler( uchar *input, int ilen)
+{
+ int rv = 0;
+ uchar payload[IPKT_SZ];
+ SOL_RSP_PKT rs;
+ int i, length, t;
+ static uchar lastc = 0;
+ char rvend = 0;
+ char fdoinput = 1;
+ uchar c;
+#ifdef WIN32
+ uchar c1, c2, c3;
+ unsigned long dwKeyCode;
+#endif
+
+ memset(&payload, 0, sizeof(payload));
+ length = 0;
+ rs.len = 0;
+
+ if ((fdebug > 2) && (ilen > 4))
+ dbg_dump("sol_input dump:",input,ilen,1);
+ // i = 0;
+ for (i = 0; i < ilen; i++)
+ {
+ if (fdebug > 2)
+ dbglog("sol_input keys[%d]: %02x %02x %02x %02x, ilen=%d\n",
+ i, input[i], input[i+1], input[i+2], input[i+3], ilen);
+ /* look for console escape sequences (~) */
+
+ if (sol_esc_pending) {
+ sol_esc_pending = 0;
+ /* next char in 2-char esc seq */
+#ifdef WIN32
+ if ( ((input[i+3] & 0x01) == 0) || /* h.o byte, if not keydown */
+ (i < 0)) { /* skip h.o. bytes in dwChar for windows */
+ fdoinput = 0; /*skip this input*/
+ sol_esc_pending = 1; /*if here, esc was pending*/
+ if (fdebug > 2)
+ dbglog("sol_input: skip, %02x!=X1 for i=%d\n",input[i+3],i);
+ } else
+#endif
+ switch(input[i]) {
+ case '.':
+ dbglog("sol_input RV_END (%02x %02x)\n",sol_esc_ch,input[i]);
+ rvend = 1;
+ fdoinput = 0;
+ break;
+ case 'b':
+ case 'B':
+ rv = send_break();
+ fdoinput = 0;
+ break;
+ case 'd':
+ case 'D':
+ rv = send_ctlaltdel();
+ fdoinput = 0;
+ break;
+ case '?':
+ show_esc_help();
+ fdoinput = 0;
+ break;
+ default:
+ /* includes entering "~~" to output '~' */
+ dbglog("sol_input sol_esc no match (%02x %02x/%c%c)\n",
+ sol_esc_ch,input[i], sol_esc_ch,input[i]);
+ fdoinput = 1;
+ break;
+ }
+ } else if (input[i] == sol_esc_ch) {
+ /* start of new sol_esc seq */
+ if (fdebug > 2)
+ dbglog("sol_input esc_pending (%02x %02x)\n",input[i],input[i+1]);
+ if ((sol_esc_len == 1) ||
+ ((ilen > (i+1)) && (input[i+1] == '.')) ) { /*then exit now*/
+ dbglog("sol_input RV_END (%02x %02x)\n",input[i],input[i+1]);
+ rvend = 1;
+ }
+ fdoinput = 0;
+ sol_esc_pending = 1;
+ }
+ else fdoinput = 1; /*send as normal input*/
+
+ if (fdoinput)
+ {
+ c = input[i];
+#ifdef WIN32
+ c1 = input[i+1];
+ c2 = input[i+2];
+ c3 = input[i+3];
+
+ dwKeyCode = (c << 24) | (c1 << 16) | (c2 << 8) | c3;
+ dbglog("sol_input[%d]: KeyCode=0x%08X, '%c'\n",
+ i, dwKeyCode, (0x20 <= c && c <= 0x7E ? c : '.') );
+
+ /* check Windows input to see if it should be sent */
+ t = console_in(dwKeyCode, &payload[length], sizeof(payload) - length);
+ if (t > 0) length += t;
+ lastc = c;
+#else
+ /*
+ * Linux end-of-line handling with fCRLF:
+ * (0) CR, (1) CR+LF, (2) LF
+ * Note that the CR+LF logic works for BIOS, but causes
+ * extra returns after Linux commands. Using -l sets CR+LF.
+ * Using bTextMode detects if bg color, as in BIOS Setup
+ * or other apps that need CR+LF.
+ *
+ * If stty has '-onlcr', then LF (fCRLF=2) is fine, but
+ * if stty has 'onlcr', LF causes two output lines,
+ * so CR is the default (fCRLF=0), which works for
+ * either 'onlcr' or '-onlcr'.
+ * Using -r (fRaw) has the same effect as LF (fCRLF=2).
+ */
+ if (c == CH_LF && !fRaw) { // input=enter/LF and not raw (-r)
+ if ((fCRLF == 1) || (bTextMode > 40)) { /*-l option or bg color*/
+ /*CR+LF: insert CR here, LF below*/
+ payload[length++] = CH_CR;
+ }
+ else if (fCRLF == 2) ; /*LF: same as raw, use CH_LF*/
+ else c = CH_CR; /* CR: switch LF to CR */
+ }
+ /* copy other data to payload */
+ payload[length++] = c;
+ lastc = c;
+ if (c == CH_CR || c == CH_LF)
+ dbglog("sol_input[%d] payload: %02x %02x, bTextMode=%d\n",
+ i,payload[0],payload[1],bTextMode);
+#endif
+ if (length >= max_bmc_data) { /*overflow, truncate*/
+ dbglog("sol_send: ilen(%d) >= BMC max data(%d), truncated\n",
+ ilen,max_bmc_data);
+ break;
+ } else if (length >= sizeof(payload)) { /*overflow, truncate*/
+ dbglog("sol_send: ilen(%d) >= buffer size(%d), truncated\n",
+ ilen,sizeof(payload));
+ break;
+ }
+ } /*endif fdoinput*/
+#ifdef WIN32
+ i += 3; /*increment to next dwKeyCode (3+1)*/
+#endif
+ } /*end-for input[ilen] */
+
+ if (length > 0) {
+ /* Send the SOL payload */
+ for (t = 0; t < sol_retries; t++)
+ {
+ if (t > 0)
+ os_usleep(0,(retry_time * 1000)); /*wait between retries 5000 us*/
+ rv = sol_send(payload, length, &rs);
+ dbglog("sol_send(%d,%d) rv=%d rs.len=%d\n", t,length,rv,rs.len);
+ if (rv >= 0) { /* rv ok */
+ if (rs.len != 0) { /* have some rsp data, so handle it */
+ if (rs.type == IPMI_PAYLOAD_TYPE_SOL) {
+ dbglog("output: handler(%d)\n",rs.len);
+ sol_output_handler(&rs);
+ } else {
+ dbglog("WARNING: after sol_send, rs.type=%d, not SOL\n",rs.type);
+ }
+ } /*endif have rsp data*/
+ rv = 0; /*recvd something, so dont retry */
+ }
+ if (rv == 0) break;
+ /* else retry again if rv < 0 or rv == 0x02 */
+ } /*end for loop*/
+ if (rv < 0) rv = LAN_ERR_DROPPED;
+ }
+ if (rvend) rv = RV_END;
+ return(rv);
+}
+
+static int send_activate_15sol(void)
+{
+ int rv = 0;
+ uchar actcmd;
+ uchar netfn;
+ uchar ibuf[64];
+ uchar rbuf[64];
+ int rlen;
+ uchar ilen, cc;
+
+ lan_get_sol_data(fSolEncryption,sol15_iseed,&sol15_wseed);
+ actcmd = (uchar)(ACTIVATE_SOL1 & 0x00ff);
+ netfn = NETFN_SOL;
+ if (fSolEncryption) ibuf[0] = 0x11; /* use encryption, activate SOL */
+ else ibuf[0] = 0x01; /*no encryptionn, no serial alerts, activate SOL */
+ memcpy(&ibuf[1],&sol15_wseed,4); /*32-bit seed*/
+ ilen = 5;
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmdraw(actcmd,netfn,BMC_SA, PUBLIC_BUS, BMC_LUN,
+ ibuf,ilen,rbuf,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ /* switch(cc) { case 0x80: SOL already active on another session
+ * case 0x81: SOL disabled
+ * case 0x82: SOL activation limit reached }
+ */
+ if (rv == 0) { /*success*/
+ dbg_dump("sol 15 act_resp",rbuf,rlen,0);
+ /* sol 15 act_resp (len=4): 0000: 00 01 64 64 */
+ /* 00=auth, 01=seed_cnt, 64=in_payload_sz, 64=out_payload_sz */
+ lan_set_sol_data(fSolEncryption,rbuf[0],rbuf[1], rbuf[2], rbuf[3]);
+ }
+ return(rv);
+}
+
+static int send_deactivate_15sol(void)
+{
+ int rv = -1;
+
+ uchar actcmd;
+ uchar netfn;
+ uchar ibuf[64];
+ uchar rbuf[64];
+ int rlen;
+ uchar ilen, cc;
+
+ /* SOL for IPMI 1.5 does not have an explicit deactivate, so
+ * use an activate with data0 = 00.
+ */
+ actcmd = (uchar)(ACTIVATE_SOL1 & 0x00ff);
+ netfn = NETFN_SOL;
+ if (fSolEncryption) ibuf[0] = 0x10; /* deactivate, use encryption */
+ else ibuf[0] = 0x00; /*deactivate*/
+ memcpy(&ibuf[1],&sol15_wseed,4); /*32-bit seed*/
+ ilen = 5;
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmdraw(actcmd,netfn,BMC_SA, PUBLIC_BUS, BMC_LUN,
+ ibuf,ilen,rbuf,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ dbg_dump("sol 15 deact_resp",rbuf,rlen,0); /* 80 00 32 ff */
+ return(rv);
+}
+
+int send_activate_sol(uchar verSOL)
+{
+ int rv = 0;
+ int in_payload_size, out_payload_size, udp_port;
+ uchar actcmd;
+ uchar netfn;
+ uchar ibuf[64];
+ uchar rbuf[64];
+ int rlen;
+ uchar ilen, cc;
+
+ sol_ver = verSOL;
+ /* activate SOL = 0x01, get SOL status = 0x05 */
+ if (verSOL == 1) {
+ rv = send_activate_15sol();
+ return(rv);
+ } else { /* use IPMI 2.0 method */
+ actcmd = ACTIVATE_PAYLOAD;
+ netfn = NETFN_APP;
+ ibuf[0] = PAYLOAD_TYPE_SOL;
+ ibuf[1] = payload_instance; /* payload instance */
+ ibuf[2] = SOL_SERIAL_ALERT_MASK_DEFERRED;
+ if (fSolEncryption) ibuf[2] |= 0x80;
+ if (fSolAuthentication) ibuf[2] |= 0x40;
+ if (vend_id == VENDOR_INTEL)
+ ibuf[2] |= SOL_BMC_ASSERTS_CTS_MASK_TRUE;
+ else ibuf[2] |= SOL_BMC_ASSERTS_CTS_MASK_FALSE;
+ ibuf[3] = 0;
+ ibuf[4] = 0;
+ ibuf[5] = 0;
+ ilen = 6;
+ }
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmdraw(actcmd,netfn,BMC_SA, PUBLIC_BUS, BMC_LUN,
+ ibuf,ilen,rbuf,&rlen,&cc,fdebug);
+ dbg_dump("sol act_cmd",ibuf,ilen,0);
+ dbglog("send_activate v2(%x,%x) rv = %d cc = %x\n",actcmd,netfn,rv,cc);
+ if (rv >= 0) {
+ rv = cc;
+ switch(cc) {
+ case 0x00:
+ if (rlen != 12) {
+ printm("Unexpected SOL response data received, len=%d\n",rlen);
+ rv = -1;
+ }
+ break;
+ case 0x80:
+ printm("SOL payload already active on another session\n");
+ break;
+ case 0x81:
+ printm("SOL payload disabled\n");
+ break;
+ case 0x82:
+ printm("SOL payload activation limit reached\n");
+ break;
+ case 0x83:
+ printm("Cannot activate SOL payload with encryption\n");
+ break;
+ case 0x84:
+ printm("Cannot activate SOL payload without encryption\n");
+ break;
+ default:
+ printm("Cannot activate SOL, ccode = 0x%02x\n",cc);
+ break;
+ }
+ }
+ if (rv == 0) { /* success, use the response data */
+ /* only here if response data is from IPMI 2.0 method */
+ dbg_dump("sol act_resp",rbuf,rlen,0);
+ in_payload_size = rbuf[4] + (rbuf[5] << 8);
+ out_payload_size = rbuf[6] + (rbuf[7] << 8);
+ udp_port = rbuf[8] + (rbuf[9] << 8);
+ dbglog("activate ok, in=%d out=%d port=%d\n",
+ in_payload_size, out_payload_size, udp_port);
+ if (bSolVer == 2)
+ lan2_set_sol_data(in_payload_size, out_payload_size, udp_port,
+ (void *)lan2_recv_handler, sol_esc_ch);
+ }
+ return(rv);
+}
+
+int send_deactivate_sol(uchar verSOL)
+{
+ int rv = 0;
+ uchar deactcmd;
+ uchar netfn;
+ uchar ibuf[64];
+ uchar rbuf[64];
+ int rlen;
+ uchar ilen, cc;
+
+ if (verSOL == 1) {
+ return(send_deactivate_15sol());
+ } else { /* use IPMI 2.0 method */
+ deactcmd = DEACTIVATE_PAYLOAD;
+ netfn = NETFN_APP;
+ ibuf[0] = PAYLOAD_TYPE_SOL; /* payload type */
+ ibuf[1] = payload_instance; /* payload instance */
+ ibuf[2] = 0;
+ ibuf[3] = 0;
+ ibuf[4] = 0;
+ ibuf[5] = 0;
+ ilen = 6;
+ }
+ rlen = sizeof(rbuf);
+ rv = ipmi_cmdraw(deactcmd,netfn,BMC_SA, PUBLIC_BUS, BMC_LUN,
+ ibuf,ilen,rbuf,&rlen,&cc,fdebug);
+ dbglog("sol deactivate rv = %d, cc = %x\n",rv,cc);
+ if (rv == 0 && cc != 0) rv = cc;
+ return(rv);
+}
+
+int sol_data_loop( void )
+{
+ int istdin;
+ int rv = 0;
+ uchar ibuf[IDATA_SZ];
+ uchar cbuf[IDATA_SZ];
+ int szibuf, szcbuf;
+ SockType fd;
+ int len;
+ fd_set read_fds;
+ fd_set error_fds;
+ static uchar lastc = 0;
+ int c;
+#ifdef WIN32
+ int c1;
+ time_t ltime1 = 0;
+ time_t ltime2 = 0;
+ HANDLE thnd;
+ istdin = 0;
+#else
+ long ltime1 = 0;
+ long ltime2 = 0;
+ istdin = fileno(stdin);
+#endif
+
+ /*
+ * OK, now loop and listen to
+ * stdin for user input
+ * interface fd for incoming SOL data
+ */
+ /* sizeof(ibuf/cbuf)=IDATA_SZ(512), max_bmc_data=203 for sol data */
+ szibuf = max_bmc_data;
+ szcbuf = max_bmc_data;
+ fd = sol_get_fd();
+ if (fScript) { /* open file_scr */
+ fp_scr = fopen(file_scr,"r");
+ if (fp_scr == NULL) {
+ printm("Cannot open %s, ignoring\n",file_scr);
+ fScript = 0;
+ }
+ }
+ if (fTrace) { /* open file_trc for writing */
+ fp_trc = fopen(file_trc,"a");
+ if (fp_trc == NULL) {
+ printm("Cannot open %s, ignoring\n",file_trc);
+ fTrace = 0;
+ }
+ }
+
+ dbglog("stdin = %d, intf->fd = %d\n",istdin,fd);
+ if (sol_esc_len == 1)
+ printf("[SOL session is running, use '%c' to end session.]\n",sol_esc_ch);
+ else
+ printf("[SOL session is running, use '%c.' to end, '%c?' for help.]\n",
+ sol_esc_ch, sol_esc_ch);
+
+ tty_setraw(2);
+ sol_keepalive_reset();
+#ifdef WIN32
+ thnd = CreateThread(NULL, 0, &input_thread, NULL, 0, NULL);
+ if (thnd == NULL) {
+ printm("CreateThread error, aborting\n");
+ rv = -1;
+ sol_done = 1;
+ }
+ console_open(fdebug);
+#else
+ if (bSolVer == 1) { /* jump start the session v1.5 data */
+ ibuf[0] = 0x1b; /*escape*/
+ ibuf[1] = '{';
+ rv = sol_input_handler(ibuf,2);
+ }
+#endif
+ if (fdbglog) time((time_t *)&ltime1);
+
+ while (sol_done == 0)
+ {
+ if (bKeepAlive > 0) { /* send KeepAlive if needed */
+ rv = sol_keepalive(bKeepAlive);
+ /* if keepalive error, try to keep going anyway */
+ }
+ if (fdebug > 2) dbglog("os_select(%d,%d) called\n",istdin,fd);
+
+ rv = os_select(istdin,fd, &read_fds, &error_fds);
+ if (rv < 0) {
+ dbglog("os_select(%d,%d) error %d\n",istdin,fd,rv);
+ perror("select");
+ sol_done = 1;
+ } else if (rv > 0) {
+ if (fdbglog) {
+ time((time_t *)&ltime2);
+ dbglog("select rv = %d sockfd=%x stdin=%x time=%ld\n", rv,
+ FD_ISSET(fd, &read_fds),FD_ISSET(istdin, &read_fds),
+ (ltime2 - ltime1));
+ }
+
+ if (FD_ISSET(fd, &read_fds)) {
+ SOL_RSP_PKT rs;
+ rs.len = 0;
+ /* receive output from BMC SOL */
+ rv = sol_recv(&rs);
+#ifdef WIN32
+ /* Windows sometimes gets rv = -1 here */
+ if (rv == -1) rv = -(WSAGetLastError());
+#endif
+ dbglog("output: recv rv = %d, len = %d\n",rv,rs.len);
+ if (rv < 0) {
+ dbglog("Error %d reading SOL socket\n",rv);
+ printm("Error %d reading SOL socket\n",rv);
+ sol_done = 1;
+ } else {
+ /*sol_output_handler sets fgotrecv*/
+ sol_output_handler(&rs);
+ sol_keepalive_reset();
+ /* go back to select until there is no more socket data */
+ continue;
+ }
+ } /*endif fd*/
+
+ if (FD_ISSET(fd, &error_fds)) {
+ dbglog("Error selecting SOL socket\n",rv);
+ } /*endif fd*/
+
+ if (FD_ISSET(istdin, &read_fds)) {
+ /* input from stdin (user) if not WIN32 */
+ memset(ibuf,0,szibuf);
+ len = os_read(istdin, ibuf, szibuf);
+ dbglog("stdin: read len=%d, %02x %02x %02x %02x\n",
+ len,ibuf[0],ibuf[1],ibuf[2],ibuf[3]);
+ if (len <= 0) {
+ dbglog("Error %d reading stdin\n",len);
+ printm("Error %d reading stdin\n",len);
+ sol_done = 1;
+ } else {
+ rv = sol_input_handler(ibuf,len);
+ dbglog("sol_input: handler rv = %d\n",rv);
+ if (rv < 0) {
+ sol_done = 1;
+ if (rv == RV_END) {
+ dbglog("sol_data RV_END\n");
+ printf("\n%s exit via user input \n",progname);
+ } /* else drop through to show_outcomes */
+ }
+ else sol_keepalive_reset();
+ }
+ } /*endif stdin*/
+
+ } /*endif select rv > 0 */
+ else if (fScript) { /*rv == 0*/
+ /* if we sent a script line, but no receive yet, keep waiting*/
+ if (fsentok && (fgotrecv == 0)) {
+ dbglog("sol_data script sentok, but no recv\n");
+ // continue;
+ }
+ fsentok = 0;
+ /* read input stream from script file */
+ memset(cbuf,0,szcbuf);
+ /* read one line at a time */
+ rv = 0;
+ for (len = 0; len < szcbuf; ) {
+ c = fgetc(fp_scr);
+ if (c == EOF) { rv = -2; break; }
+#ifdef WIN32
+ if ((c == '\n') && (lastc != '\r')) c1 = '\r'; /*Enter*/
+ else c1 = c;
+ Ascii2KeyCode((uchar)c1,&cbuf[len]);
+ len += 4;
+#else
+ cbuf[len++] = c;
+#endif
+ if (c == '\n') break;
+ lastc = (uchar)c;
+ }
+ dbglog("script: read len=%d, %02x %02x %02x\n",
+ len,cbuf[0],cbuf[1],cbuf[2]);
+ if (rv != 0 || len == 0) {
+ dbglog("Stop reading file %s, rv=%d\n",file_scr,rv);
+ fclose(fp_scr);
+ fScript = 0;
+ } else {
+ /* TODO: add processing for some wait/sleep/prompt commands */
+ rv = sol_input_handler(cbuf,len);
+ dbglog("input: handler rv = %d\n",rv);
+ if (rv < 0) {
+ sol_done = 1;
+ if (rv == RV_END) {
+ dbglog("sol_data RV_END\n");
+ printf("\n%s exit via user input \n",progname);
+ } else printf("Error %d processing input\n",rv);
+ } else {
+ fsentok = 1; /*sent a script line successfully*/
+ fgotrecv = 0; /*need to wait for recv*/
+ }
+ }
+ } /*endif fScript*/
+ } /*end while*/
+ if (rv == RV_END) rv = 0;
+#ifdef WIN32
+ os_usleep(0,5000); /*wait 5 ms for thread to close itself*/
+ CloseHandle(thnd);
+ console_close();
+#endif
+ tty_setnormal(2);
+ if (fScript) fclose(fp_scr); /* close file_scr */
+ if (fTrace) fclose(fp_trc); /* close file_trc */
+ return(rv);
+}
+
+static void show_usage(void)
+{
+ printf("Usage: %s [-acdeiolnrsvxz -NUPREFTVY]\n", progname);
+ printf(" where -a activate SOL console session\n");
+ printf(" -d deactivate SOL console session\n");
+ printf(" -c'^' set escape Char to '^', default='~'\n");
+ printf(" -e Encryption off for SOL session\n");
+ printf(" -i file Input script file\n");
+ printf(" -o file Output trace file\n");
+ printf(" -l Legacy mode for BIOS/DOS CR+LF\n");
+ printf(" -n 1 Payload instance Number, default=1\n");
+ printf(" -r Raw termio, no VT-ANSI translation\n");
+ printf(" -s NNN Slow link delay, default=100usec\n");
+#ifdef NOT_DOCUMENTED
+ printf(" -t N SOL send timeout reTries, default=1\n");
+ printf(" -u N Wait time in msec for tuning, default=500\n");
+#endif
+#ifdef WIN32
+ printf(" -w do not use Windows Console buffer, use stdio\n");
+#endif
+ printf(" -v debug log filename (default=isoldbg.log)\n");
+ printf(" -x show eXtra debug messages in debug log\n");
+ printf(" -z show even more debug messages\n");
+ print_lan_opt_usage();
+}
+
+#ifdef METACOMMAND
+int i_sol(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int i;
+ uchar devrec[16];
+ uchar bmcver[2];
+ int c;
+
+ printf("%s ver %s\n", progname,progver);
+
+ parse_lan_options('V',"2",0); /*default to user priv*/
+
+ while ( (c = getopt( argc, argv,"ac:dei:k:ln:o:rs:t:u:wv:xzEF:J:N:P:R:T:U:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'a': factivate = 1; break; /*activate*/
+ case 'd': fdeactivate = 1; break; /*deactivate*/
+ case 'c': /* escape char */
+ if (strncmp(optarg,"0x",2) == 0)
+ sol_esc_ch = htoi(&optarg[2]); /*hex char value*/
+ else if (optarg[0] >= '0' && optarg[0] <= '9')
+ sol_esc_ch = atob(optarg); /*decimal char value*/
+ else sol_esc_ch = optarg[0]; /*single ascii char*/
+ sol_esc_len = 1; /*set single-char esc sequence */
+ break;
+ case 'e': fSolEncryption = 0; break; /*encryption off*/
+ case 'k': i = atoi(optarg); /*sol keepalive timeout, default = 30*/
+ if (i < 0)
+ printf("Invalid keepalive timeout %d, ignoring.\n",i);
+ else sol_timeout = i;
+ if (i == 0) bKeepAlive = 0;
+ if (i == 32) bKeepAlive = 2; /*++++ for debug*/
+ break;
+ case 'l': fCRLF = 1; break; /*do legacy CR+LF translation*/
+ case 'i': strncpy(file_scr,optarg,sizeof(file_scr));
+ fScript = 1; break; /*script input file*/
+ case 'n': i = atoi(optarg); /* payload_instance */
+ if ((i <= 0) || (i > 255))
+ printf("Invalid payload instance %d, ignoring.\n",i);
+ else payload_instance = i;
+ break;
+ case 'o': strncpy(file_trc,optarg,sizeof(file_trc));
+ fTrace = 1; break; /*trace output file*/
+ case 'r': fRaw = 1; fCRLF = 0; fUseWinCon = 0;
+ break; /*raw termio, xlate off*/
+ case 's': sol_recvdelay = atoi(optarg); break; /*slow recv delay*/
+ case 't': sol_retries = atoi(optarg); break; /*timeout/retries*/
+ case 'u': wait_time = atoi(optarg); break; /*wait_time for tuning*/
+ case 'v': strncpy(dbglog_name,optarg,sizeof(dbglog_name));
+ fdbglog = 1; break; /*name of debug log file*/
+ case 'w': fUseWinCon = 0; break; /*do not use Console routines*/
+ case 'x':
+ if (fdebug == 0) fdebug = 2; /*only normal via dbglog */
+ else fdebug++; /* -xx = full, -xxx = max */
+ break;
+ case 'z': fdebug = 3; break; /*full debug messages */
+ case 'V': /* priv level */
+ fprivset = 1;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ show_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+
+ if (is_remote() == 0) { /* no node specified */
+ printf("Serial-Over-Lan Console requires a -N nodename\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+ if (fdeactivate && !fprivset)
+ parse_lan_options('V',"4",0); /*deactivate requires admin priv */
+
+ /* fdebug: 1=debug/no packets, 2=debug log only, 3=full debug, 4=max debug*/
+ if (fdebug > 1) fdbglog = 1;
+
+ if (factivate == 0 && fdeactivate == 0) {
+ show_usage();
+ printf("Error: Need either -a or -d for sol\n");
+ ret = ERR_BAD_PARAM;
+ goto do_exit;
+ }
+#ifdef WIN32
+ else if (factivate) {
+ if (fdebug) printf("%s activate, connecting ...\n", progname);
+ }
+#endif
+ if (fdbglog) {
+ // strcpy(log_name,dbglog_name);
+ open_log(dbglog_name);
+ dbglog("%s ver %s\r\n", progname,progver);
+ }
+
+ i = get_driver_type(); /*see if user explictly set type*/
+ if (i == DRV_UNKNOWN) bDriver = DRV_UNKNOWN; /*no driver type specified*/
+ else bDriver = (uchar)i;
+
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ bmcver[0] = devrec[2];
+ bmcver[1] = devrec[3];
+ switch(vend_id) {
+ case VENDOR_DELL: /*Dell == 0x0002A2*/
+ max_bmc_data = MAX_DELL_DATA; /*shorter max data*/
+ break;
+ case VENDOR_SUPERMICRO:
+ case VENDOR_LMC:
+ case VENDOR_PEPPERCON: /* 0x0028C5 Peppercon/Raritan*/
+ sol_timeout = 10; /* shorter 10 sec SOL keepalive timeout */
+ max_bmc_data = MAX_OTHER_DATA;
+ break;
+ case VENDOR_INTEL:
+ max_bmc_data = MAX_INTEL_DATA;
+ break;
+ case VENDOR_KONTRON:
+ max_bmc_data = MAX_KONTRON_DATA;
+ // bKeepAlive = 1;
+ break;
+ default:
+ max_bmc_data = MAX_OTHER_DATA;
+ break;
+ }
+ }
+
+ ret = ipmi_getpicmg(devrec,16,fdebug);
+ if (ret == 0) fpicmg = 1;
+
+ dbglog("driver=%d fdebug=%d vend_id=%x bmcver=%x.%x ipmi %d.%d\n",
+ bDriver,fdebug,vend_id,bmcver[0],bmcver[1],ipmi_maj,ipmi_min);
+ /* check for SOL support */
+ if (ipmi_maj >= 2) {
+ if ((bDriver == DRV_LAN) && (vend_id == VENDOR_INTEL)) {
+ /* user specified to use IPMI LAN 1.5 SOL on Intel */
+ bSolVer = 1; /*IPMI 1.5 SOL*/
+ } else {
+ bSolVer = 2; /*IPMI 2.0 SOL*/
+ if (get_driver_type() == DRV_LAN) { /*now using IPMI LAN 1.5*/
+ char *ptyp;
+ ipmi_close_(); /*close current IPMI LAN 1.5*/
+ if (is_lan2intel(vend_id,prod_id)) ptyp = "lan2i";
+ else ptyp = "lan2";
+ i = set_driver_type(ptyp); /*switch to IPMI LAN 2.0*/
+ }
+ }
+ } else if (ipmi_maj == 1) {
+ if (ipmi_min >= 5) bSolVer = 1; /* IPMI 1.5 */
+ else bSolVer = 0; /* IPMI 1.0 */
+ } else bSolVer = 0;
+ if (bSolVer == 0) {
+ printf("Serial Over Lan not supported for this IPMI version\n");
+ ret = LAN_ERR_NOTSUPPORT;
+ goto do_exit;
+ }
+#ifndef HAVE_LANPLUS
+ if (bSolVer == 2) {
+ printf("2.0 LanPlus module not available, trying 1.5 SOL instead\n");
+ bSolVer = 1;
+ }
+#endif
+ /* May also want to verify that SOL is implemented here */
+
+ /*
+ * Spawn a console raw terminal thread now, which will wait for the
+ * "Activating cmd (0x02)" on success
+ * Using globals: gnode,guser,gpswd, gauth_type, gpriv_level
+ */
+ if (fdeactivate) {
+ /* Request admin privilege by default, since deactivate requires it. */
+ ret = send_deactivate_sol(bSolVer);
+ dbglog("send_deactivate_sol rv = %d\n",ret);
+ } else if (factivate) {
+ ret = send_activate_sol(bSolVer);
+ dbglog("send_activate_sol(%d) rv = %d\n",bSolVer,ret);
+ if (bSolVer == 2) {
+ lan2_latency = lan2_get_latency();
+ retry_time = lan2_latency;
+ dbglog("lan2_latency = %ld msec (slow > %ld msec)\n",
+ lan2_latency,lan2_slow);
+ if ((sol_recvdelay == 0) && (lan2_latency > lan2_slow))
+ sol_recvdelay = 500; /* it is slow, set recvdelay */
+ if (sol_recvdelay != 0) {
+ dbglog("set_recvdelay to %dus\n",sol_recvdelay);
+ lanplus_set_recvdelay(sol_recvdelay);
+ }
+ } /*endif bSolVer==2*/
+ if (ret == 0) {
+ ret = sol_data_loop();
+ } /*endif activate ok*/
+ } /*endif do activate */
+
+do_exit:
+ if (ret != LAN_ERR_DROPPED) { /*if link dropped, no need to close*/
+ ipmi_close_();
+ os_usleep(0,(wait_time * 1000)); /*wait 0.5 sec for BMC teardown*/
+ }
+ if (fdebug) show_outcome(progname,ret);
+ if (fdbglog) close_log();
+ return(ret);
+} /* end main()*/
+#endif
+
+/* end isol.c */
diff --git a/util/isolwin.c b/util/isolwin.c
new file mode 100644
index 0000000..b8f7926
--- /dev/null
+++ b/util/isolwin.c
@@ -0,0 +1,293 @@
+/*
+ * isolwin.c
+ * IPMI Serial-Over-LAN console Windows terminal emulation
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 08/20/07 Andy Cress - extracted from isolconsole.c/WIN32,
+ * added os_usleep to input_thread
+ * 09/24/07 Andy Cress - various termio fixes, e.g. scroll(), BUF_SZ
+ */
+/*M*
+Copyright (c) 2006-2007, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <windows.h>
+#include <stdio.h>
+#include <winsock.h>
+#include <io.h>
+#include <conio.h>
+#include <string.h>
+#include <time.h>
+
+#define SockType SOCKET
+typedef struct {
+ int type;
+ int len;
+ char *data;
+ } SOL_RSP_PKT;
+
+extern void dbglog( char *pattn, ... ); /*from isolconsole.c*/
+extern void os_usleep(int s, int u); /*from ipmilan.c*/
+
+typedef unsigned char uchar;
+
+/*
+ * Global variables
+ */
+extern int sol_done;
+extern char fUseWinCon;
+extern uchar fRaw;
+extern uchar fCRLF; /* =1 to use legacy CR+LF translation for BIOS */
+extern uchar bTextMode;
+extern char fdebug; /*from isolconsole.c*/
+extern int wait_time; /*from isolconsole.c*/
+
+/*======== start Windows =============================*/
+ /* Windows os_read, os_select and supporting code */
+#define INBUF_SZ 128
+static DWORD rg_stdin[INBUF_SZ];
+static int n_stdin = 0;
+#define NSPECIAL 33
+static struct { uchar c; uchar code[4]; } special_keys[NSPECIAL] = {
+ ' ', {0x20,0x20,0x01,0x01},
+ '!', {0x21,0x31,0x01,0x21},
+ '"', {0x22,0xde,0x01,0x21},
+ '#', {0x23,0x33,0x01,0x21},
+ '$', {0x24,0x34,0x01,0x21},
+ '%', {0x25,0x35,0x01,0x21},
+ '&', {0x26,0x37,0x01,0x21},
+ 0x27, {0x27,0xde,0x01,0x01}, /*'''*/
+ '(', {0x28,0x39,0x01,0x21},
+ ')', {0x29,0x30,0x01,0x21},
+ '*', {0x2a,0x38,0x01,0x21},
+ '+', {0x2b,0xbb,0x01,0x21},
+ ',', {0x2c,0xbc,0x01,0x01},
+ '-', {0x2d,0xbd,0x01,0x01},
+ '.', {0x2e,0xbe,0x01,0x01},
+ '/', {0x2f,0xbf,0x01,0x01},
+ ':', {0x3a,0xba,0x01,0x21},
+ ';', {0x3b,0xba,0x01,0x01},
+ '<', {0x3c,0xbc,0x01,0x21},
+ '=', {0x3d,0xbb,0x01,0x01},
+ '>', {0x3e,0xbe,0x01,0x21},
+ '?', {0x3f,0xbf,0x01,0x21},
+ '@', {0x40,0x32,0x01,0x21},
+ '[', {0x5b,0xdb,0x01,0x01},
+ 0x5c, {0x5c,0xdc,0x01,0x01}, /*'\'*/
+ ']', {0x5d,0xdd,0x01,0x01},
+ '^', {0x5e,0x36,0x01,0x21},
+ '_', {0x5f,0xbd,0x01,0x21},
+ '`', {0x60,0xc0,0x01,0x01},
+ '{', {0x7b,0xdb,0x01,0x21},
+ '|', {0x7c,0xdc,0x01,0x21},
+ '}', {0x7d,0xdd,0x01,0x21},
+ '~', {0x7e,0xc0,0x01,0x21}
+};
+
+void Ascii2KeyCode(uchar c, uchar *buf)
+{
+ int i;
+ int j = 0;
+ /* Convert ascii chars from script file into KeyCodes*/
+ for (i = 0; i < NSPECIAL; i++)
+ if (c == special_keys[i].c) break;
+ if (i < NSPECIAL) { /* special chars */
+ buf[j++] = c;
+ buf[j++] = special_keys[i].code[1];
+ buf[j++] = special_keys[i].code[2];
+ buf[j++] = special_keys[i].code[3];
+ } else if (c < 0x0D) { /* control chars, like Ctl-c */
+ buf[j++] = c;
+ buf[j++] = (c | 0x40);
+ buf[j++] = 0x01;
+ buf[j++] = 0x41;
+ } else { /* alphanumeric chars */
+ buf[j++] = c;
+ if (c > 0x60)
+ buf[j++] = c - 0x20; /*drop 0x20 bit if upper case*/
+ else buf[j++] = c;
+ buf[j++] = 0x01;
+ buf[j++] = 0x01;
+ }
+}
+
+DWORD WINAPI input_thread( LPVOID lpParam)
+{
+ HANDLE hstdin;
+ DWORD rv = 0;
+ INPUT_RECORD inrecords[10];
+ DWORD nread;
+ DWORD oldmode;
+
+ hstdin = GetStdHandle(STD_INPUT_HANDLE);
+
+ GetConsoleMode(hstdin, &oldmode);
+ SetConsoleMode(hstdin, ENABLE_WINDOW_INPUT);
+
+ while (!sol_done)
+ {
+ DWORD dwResult = WaitForSingleObject(hstdin, wait_time * 2); /*1000 msec*/
+
+ if (dwResult != WAIT_OBJECT_0)
+ {
+ if (dwResult != WAIT_TIMEOUT)
+ dbglog("input_thread: Wait result = %x\n",dwResult);
+ continue;
+ }
+
+ if (ReadConsoleInput(hstdin, inrecords, 10, &nread))
+ {
+ DWORD index;
+
+ for (index = 0; index < nread; index++)
+ {
+ /* Pack the char info into a DWORD */
+ INPUT_RECORD *precord = &inrecords[index];
+ DWORD dwChar;
+
+ if (precord->EventType == KEY_EVENT)
+ {
+ if (precord->Event.KeyEvent.wVirtualKeyCode == VK_SHIFT ||
+ precord->Event.KeyEvent.wVirtualKeyCode == VK_CONTROL ||
+ precord->Event.KeyEvent.wVirtualKeyCode == VK_MENU ||
+ precord->Event.KeyEvent.wVirtualKeyCode == VK_CAPITAL)
+ {
+ continue;
+ }
+
+ dwChar = (((precord->Event.KeyEvent.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) != 0) << 31) |
+ (((precord->Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0) << 30) |
+ (((precord->Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED) != 0) << 29) |
+ (((precord->Event.KeyEvent.dwControlKeyState & NUMLOCK_ON) != 0) << 28) |
+ (((precord->Event.KeyEvent.dwControlKeyState & SCROLLLOCK_ON) != 0) << 27) |
+ (((precord->Event.KeyEvent.dwControlKeyState & CAPSLOCK_ON) != 0) << 26) |
+ (((precord->Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) != 0) << 25) |
+ ((precord->Event.KeyEvent.bKeyDown != 0) << 24) |
+ ((precord->Event.KeyEvent.wRepeatCount & 0xFF) << 16) |
+ ((precord->Event.KeyEvent.wVirtualKeyCode & 0xFF) << 8) |
+ (precord->Event.KeyEvent.uChar.AsciiChar & 0xFF);
+ }
+ else if (precord->EventType == WINDOW_BUFFER_SIZE_EVENT)
+ {
+ dwChar = ~0;
+ }
+ else
+ {
+ continue;
+ }
+ if (precord->Event.KeyEvent.bKeyDown == 0) {
+ if (fdebug > 2)
+ dbglog("input_thread: key up event (%08x)\n",dwChar);
+ continue;
+ }
+
+ if (n_stdin < INBUF_SZ) { /* rg_stdin[INBUF_SZ] */
+ if (fdebug > 2)
+ dbglog("input_thread: n=%d dwChar=%08x keystate=%x\n",
+ n_stdin, dwChar,
+ precord->Event.KeyEvent.dwControlKeyState);
+ rg_stdin[n_stdin++] = dwChar;
+ } else
+ dbglog("input_thread: overflow n=%d size=%d\n",
+ n_stdin,INBUF_SZ);
+ } /*end-for nread*/
+ } /*endif ReadConsoleInput*/
+ } /*end-while not sol_done*/
+
+ SetConsoleMode(hstdin, oldmode);
+
+ CloseHandle(hstdin);
+
+ return(rv);
+}
+
+int os_read(int fd, uchar *buf, int sz)
+{
+ int len = 0;
+
+ if (fd == 0) {
+ if (n_stdin > 0) {
+ /* get pending chars from stdin */
+ int cnt = n_stdin * sizeof(rg_stdin[0]);
+ if (fdebug > 2)
+ dbglog("os_read: stdin n=%d %04x %04x \n",
+ n_stdin,rg_stdin[0],rg_stdin[1]);
+ memcpy(buf, rg_stdin, cnt);
+ len = cnt;
+ n_stdin = 0;
+ memset((uchar *)&rg_stdin,0,cnt);
+ }
+ } else {
+ // ReadFile(fd, buf, sz, &len, NULL);
+ // len = _read(fd, buf, sz);
+ len = recv(fd, buf, sz, 0);
+ }
+ return(len);
+}
+
+int os_select(int infd, SockType sfd, fd_set *read_fds, fd_set *error_fds)
+{
+ int rv = 0;
+ struct timeval tv;
+
+ /* check the socket for new data via select */
+ /* Windows select only works on WSA sockets */
+ {
+ FD_ZERO(read_fds);
+ FD_SET(sfd, read_fds);
+ FD_ZERO(error_fds);
+ FD_SET(sfd, error_fds);
+ tv.tv_sec = 0;
+ tv.tv_usec = wait_time * 100; /* 50000 usec, 50 msec, 0.05 sec */
+ // rv = select(sfd + 1, read_fds, NULL, error_fds, &tv);
+ rv = select((int)(sfd+1), read_fds, NULL, error_fds, &tv);
+ if (rv < 0) {
+ rv = -(WSAGetLastError());
+ if (fdebug) dbglog("select(%d) error %d\r\n",sfd,rv);
+ }
+ else if (FD_ISSET(sfd, error_fds)) {
+ if (fdebug) dbglog("select(%d) error_fds rv=%d err=%d\r\n",sfd, rv,
+ WSAGetLastError());
+ }
+ if (rv > 0 && fdebug)
+ dbglog("select(%d) got socket data %d\r\n",sfd,rv);
+ }
+ if (infd == 0) { /* check stdin */
+ if (n_stdin > 0) {
+ FD_SET(infd, read_fds);
+ if (rv < 0) rv = 1;
+ else rv++;
+ }
+ }
+ return rv;
+}
+/*======== end Windows ===============================*/
+
+
+/*end solwin.c*/
diff --git a/util/itsol.c b/util/itsol.c
new file mode 100644
index 0000000..dc4d9fb
--- /dev/null
+++ b/util/itsol.c
@@ -0,0 +1,725 @@
+/*
+ * Copyright (c) 2005 Tyan Computer Corp. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#include <winsock.h>
+#include <io.h>
+#include <time.h>
+#include "getopt.h"
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+typedef uint32_t socklen_t;
+#define inet_ntop InetNtop
+#define inet_pton InetPton
+int InetPton(int af, char *pstr, void *addr); /*see ws2_32.dll*/
+char *InetNtop(int af, void *addr, char *pstr, int sz);
+char *InetNtop(int af, void *addr, char *pstr, int sz) { return NULL; };
+int gettimeofday(struct timeval *tv, struct timezone *tz);
+#undef POLL_OK
+
+#else
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#undef POLL_OK
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <stdint.h>
+#undef POLL_OK
+#else
+#include <getopt.h>
+#include <sys/poll.h>
+#define POLL_OK 1
+#endif
+
+#if defined (HAVE_SYS_TERMIOS_H)
+#include <sys/termios.h>
+#else
+// #if defined(HAVE_TERMIOS_H)
+#include <termios.h>
+#endif
+
+#endif
+
+#include "ipmicmd.h"
+#include "itsol.h"
+
+extern int verbose;
+extern char fdebug; /*from ipmicmd.c*/
+static char * progname = "itsol";
+static char * progver = "2.93";
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static char hostname[SZGNODE];
+static SockType sockfd = -1;
+static char sol_escape_char = '~';
+static struct timeval _start_keepalive;
+static int _in_raw_mode = 0;
+static int _altterm = 0;
+static SOCKADDR_T haddr;
+static int haddrlen = 0;
+static int hauth, hpriv, hcipher;
+#ifdef WIN32
+#define NI_MAXHOST 80
+#define NI_MAXSERV 80
+struct pollfd { int fd; short events; short revents; };
+struct winsize { int x; int y; };
+#else
+static struct termios _saved_tio;
+static struct winsize _saved_winsize;
+#endif
+
+
+static int
+ipmi_tsol_command(void * intf, char *recvip, int port, unsigned char cmd)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char data[6];
+ unsigned ip1, ip2, ip3, ip4;
+
+ if (sscanf(recvip, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) != 4) {
+ lprintf(LOG_ERR, "Invalid IP address: %s", recvip);
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(struct ipmi_rq));
+ req.msg.netfn = IPMI_NETFN_TSOL;
+ req.msg.cmd = cmd;
+ req.msg.data_len = 6;
+ req.msg.data = data;
+
+ memset(data, 0, sizeof(data));
+ data[0] = ip1;
+ data[1] = ip2;
+ data[2] = ip3;
+ data[3] = ip4;
+ data[4] = (port & 0xff00) >> 8;
+ data[5] = (port & 0xff);
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Unable to perform TSOL command");
+ return rv;
+ }
+ if (rv > 0) {
+ lprintf(LOG_ERR, "Unable to perform TSOL command: %s",
+ decode_cc(0,rv));
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+ipmi_tsol_start(void * intf, char *recvip, int port)
+{
+ return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_START);
+}
+
+static int
+ipmi_tsol_stop(void * intf, char *recvip, int port)
+{
+ return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_STOP);
+}
+
+static int
+ipmi_tsol_send_keystroke(void * intf, char *buff, int length)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ unsigned char data[16];
+ static unsigned char keyseq = 0;
+
+ memset(&req, 0, sizeof(struct ipmi_rq));
+ req.msg.netfn = IPMI_NETFN_TSOL;
+ req.msg.cmd = IPMI_TSOL_CMD_SENDKEY;
+ req.msg.data_len = length + 2;
+ req.msg.data = data;
+
+ memset(data, 0, sizeof(data));
+ data[0] = length + 1;
+ memcpy(data + 1, buff, length);
+ data[length + 1] = keyseq++;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (verbose) {
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Unable to send keystroke");
+ return rv;
+ }
+ if (rv > 0) {
+ lprintf(LOG_ERR, "Unable to send keystroke: %s",
+ decode_cc(0,rv));
+ return -1;
+ }
+ }
+
+ return length;
+}
+
+static int
+tsol_keepalive(void * intf)
+{
+ struct timeval end;
+ int rv;
+
+ gettimeofday(&end, 0);
+
+ if (end.tv_sec - _start_keepalive.tv_sec <= 30)
+ return 0;
+
+ // intf->keepalive(intf);
+ rv = lan_keepalive(1); /*1=getdevid, 2=empty sol*/
+
+ gettimeofday(&_start_keepalive, 0);
+
+ return rv;
+}
+
+static void
+print_escape_seq(void *intf)
+{
+ lprintf(LOG_NOTICE,
+ " %c. - terminate connection\r\n"
+ " %c^Z - suspend ipmiutil\r\n"
+ " %c^X - suspend ipmiutil, but don't restore tty on restart\r\n"
+ " %c? - this message\r\n"
+ " %c%c - send the escape character by typing it twice\r\n"
+ " (Note that escapes are only recognized immediately after newline.)\r",
+ sol_escape_char,
+ sol_escape_char,
+ sol_escape_char,
+ sol_escape_char,
+ sol_escape_char,
+ sol_escape_char);
+}
+
+#ifdef WIN32
+static int leave_raw_mode(void) { return(0); }
+static int enter_raw_mode(void) { return(0); }
+static void set_terminal_size(int rows, int cols) { return; }
+static void do_terminal_cleanup(void) {
+ int err;
+ err = get_LastError();
+ lprintf(LOG_ERR, "Exiting due to error %d", err);
+ show_LastError("",err);
+}
+static void suspend_self(int restore_tty) { return; }
+#else
+static int
+leave_raw_mode(void)
+{
+ if (!_in_raw_mode)
+ return -1;
+ else if (tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio) == -1)
+ lperror(LOG_ERR, "tcsetattr(stdin)");
+ else if (tcsetattr(fileno(stdout), TCSADRAIN, &_saved_tio) == -1)
+ lperror(LOG_ERR, "tcsetattr(stdout)");
+ else
+ _in_raw_mode = 0;
+
+ return 0;
+}
+
+static int
+enter_raw_mode(void)
+{
+ struct termios tio;
+
+ if (tcgetattr(fileno(stdout), &_saved_tio) < 0) {
+ lperror(LOG_ERR, "tcgetattr failed");
+ return -1;
+ }
+
+ tio = _saved_tio;
+
+ if (_altterm) {
+ tio.c_iflag &= (ISTRIP | IGNBRK );
+ tio.c_cflag &= ~(CSIZE | PARENB | IXON | IXOFF | IXANY);
+ tio.c_cflag |= (CS8 |CREAD) | (IXON|IXOFF|IXANY);
+ tio.c_lflag &= 0;
+ tio.c_cc[VMIN] = 1;
+ tio.c_cc[VTIME] = 0;
+ } else {
+ tio.c_iflag |= IGNPAR;
+ tio.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
+ tio.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL | IEXTEN);
+ tio.c_oflag &= ~OPOST;
+ tio.c_cc[VMIN] = 1;
+ tio.c_cc[VTIME] = 0;
+ }
+
+ if (tcsetattr(fileno(stdin), TCSADRAIN, &tio) < 0)
+ lperror(LOG_ERR, "tcsetattr(stdin)");
+ else if (tcsetattr(fileno(stdout), TCSADRAIN, &tio) < 0)
+ lperror(LOG_ERR, "tcsetattr(stdout)");
+ else
+ _in_raw_mode = 1;
+
+ return 0;
+}
+
+static void
+do_terminal_cleanup(void)
+{
+ if (_saved_winsize.ws_row > 0 && _saved_winsize.ws_col > 0)
+ ioctl(fileno(stdout), TIOCSWINSZ, &_saved_winsize);
+
+ leave_raw_mode();
+
+ if (errno)
+ lprintf(LOG_ERR, "Exiting due to error %d -> %s",
+ errno, strerror(errno));
+}
+
+static void
+set_terminal_size(int rows, int cols)
+{
+ struct winsize winsize;
+
+ if (rows <= 0 || cols <= 0)
+ return;
+
+ /* save initial winsize */
+ ioctl(fileno(stdout), TIOCGWINSZ, &_saved_winsize);
+
+ /* set new winsize */
+ winsize.ws_row = rows;
+ winsize.ws_col = cols;
+ ioctl(fileno(stdout), TIOCSWINSZ, &winsize);
+}
+
+static void
+suspend_self(int restore_tty)
+{
+ leave_raw_mode();
+
+ kill(getpid(), SIGTSTP);
+
+ if (restore_tty)
+ enter_raw_mode();
+}
+#endif
+
+static int
+do_inbuf_actions(void *intf, char *in_buff, int len)
+{
+ static int in_esc = 0;
+ static int last_was_cr = 1;
+ int i;
+
+ for(i = 0; i < len ;) {
+ if (!in_esc) {
+ if (last_was_cr &&
+ (in_buff[i] == sol_escape_char)) {
+ in_esc = 1;
+ memmove(in_buff, in_buff + 1, len - i - 1);
+ len--;
+ continue;
+ }
+ }
+ if (in_esc) {
+ if (in_buff[i] == sol_escape_char) {
+ in_esc = 0;
+ i++;
+ continue;
+ }
+
+ switch (in_buff[i]) {
+ case '.':
+ printf("%c. [terminated ipmiutil]\r\n",
+ sol_escape_char);
+ return -1;
+
+ case 'Z' - 64:
+ printf("%c^Z [suspend ipmiutil]\r\n",
+ sol_escape_char);
+ suspend_self(1); /* Restore tty back to raw */
+ break;
+
+ case 'X' - 64:
+ printf("%c^X [suspend ipmiutil]\r\n",
+ sol_escape_char);
+ suspend_self(0); /* Don't restore to raw mode */
+ break;
+
+ case '?':
+ printf("%c? [ipmiutil help]\r\n",
+ sol_escape_char);
+ print_escape_seq(intf);
+ break;
+ }
+
+ memmove(in_buff, in_buff + 1, len - i - 1);
+ len--;
+ in_esc = 0;
+
+ continue;
+ }
+
+ last_was_cr = (in_buff[i] == '\r' || in_buff[i] == '\n');
+
+ i++;
+ }
+
+ return len;
+}
+
+
+static void
+print_tsol_usage(void)
+{
+ lprintf(LOG_NOTICE, "Usage: tsol [recvip] [port=NUM] [ro|rw] [rows=NUM] [cols=NUM] [altterm]");
+ lprintf(LOG_NOTICE, " recvip Receiver IP Address [default=local]");
+ lprintf(LOG_NOTICE, " port=NUM Receiver UDP Port [default=%d]",
+ IPMI_TSOL_DEF_PORT);
+ lprintf(LOG_NOTICE, " ro|rw Set Read-Only or Read-Write [default=rw]");
+#ifdef POLL_OK
+ {
+ struct winsize winsize;
+ ioctl(fileno(stdout), TIOCGWINSZ, &winsize);
+ lprintf(LOG_NOTICE, " rows=NUM Set terminal rows [default=%d]",
+ winsize.ws_row);
+ lprintf(LOG_NOTICE, " cols=NUM Set terminal columns [default=%d]",
+ winsize.ws_col);
+ }
+#endif
+ lprintf(LOG_NOTICE, " altterm Alternate terminal setup [default=off]");
+}
+
+
+int
+ipmi_tsol_main(void * intf, int argc, char ** argv)
+{
+ char *recvip = NULL;
+ int result, i;
+ int ip1, ip2, ip3, ip4;
+ int read_only = 0, rows = 0, cols = 0;
+ int port = IPMI_TSOL_DEF_PORT;
+#ifdef POLL_OK
+ SOCKADDR_T sin, myaddr;
+ socklen_t mylen;
+ struct pollfd fds_wait[3], fds_data_wait[3], *fds;
+ int fd_socket;
+ int out_buff_fill, in_buff_fill;
+ char out_buff[IPMI_BUF_SIZE * 8], in_buff[IPMI_BUF_SIZE];
+ char buff[IPMI_BUF_SIZE + 4];
+ char mystr[NI_MAXHOST];
+#endif
+
+ if (! is_remote()) {
+ lprintf(LOG_ERR, "Error: Tyan SOL is only available over lan interface");
+ return -1;
+ }
+
+ for (i = 0; i<argc; i++) {
+ if (sscanf(argv[i], "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) == 4)
+ recvip = strdup_(argv[i]);
+ else if (sscanf(argv[i], "port=%d", &ip1) == 1)
+ port = ip1;
+ else if (sscanf(argv[i], "rows=%d", &ip1) == 1)
+ rows = ip1;
+ else if (sscanf(argv[i], "cols=%d", &ip1) == 1)
+ cols = ip1;
+ else if (strlen(argv[i]) == 2 && strncmp(argv[i], "ro", 2) == 0)
+ read_only = 1;
+ else if (strlen(argv[i]) == 2 && strncmp(argv[i], "rw", 2) == 0)
+ read_only = 0;
+ else if (strlen(argv[i]) == 7 && strncmp(argv[i], "altterm", 7) == 0)
+ _altterm = 1;
+ else if (strlen(argv[i]) == 4 && strncmp(argv[i], "help", 4) == 0) {
+ print_tsol_usage();
+ return 0;
+ }
+ else {
+ print_tsol_usage();
+ return 0;
+ }
+ }
+
+ get_lan_options(hostname,NULL,NULL,&hauth, &hpriv, &hcipher,NULL,NULL);
+ result = open_sockfd(hostname, &sockfd, &haddr, &haddrlen, 1);
+ if (result) {
+ lperror(LOG_ERR, "Connect to %s failed",hostname);
+ return result;
+ }
+
+#ifdef WIN32
+ /* TODO: implement terminal handling for Windows here. */
+ printf("Windows TSOL terminal handling not yet implemented\n");
+ if (recvip != NULL)
+ result = ipmi_tsol_stop(intf, recvip, port);
+ return LAN_ERR_NOTSUPPORT;
+#elif defined(MACOS)
+ printf("MacOS TSOL terminal handling not yet implemented\n");
+ if (recvip != NULL)
+ result = ipmi_tsol_stop(intf, recvip, port);
+ return LAN_ERR_NOTSUPPORT;
+#else
+ /*
+ * retrieve local IP address if not supplied on command line
+ */
+ if (recvip == NULL) {
+ set_lan_options(hostname,NULL,NULL,hauth, hpriv, hcipher,
+ (void *)&haddr,haddrlen);
+ result = ipmi_open(fdebug); /* must connect first */
+ if (result < 0)
+ return -1;
+
+ memset(&myaddr, 0, sizeof(myaddr));
+ memset(mystr, 0, sizeof(mystr));
+ mylen = sizeof(myaddr);
+ if (getsockname(sockfd, (struct sockaddr *)&myaddr, &mylen) < 0) {
+ lperror(LOG_ERR, "getsockname failed");
+ return -1;
+ }
+
+ recvip = (char *)inet_ntop(((struct sockaddr *)&myaddr)->sa_family, &myaddr, mystr, sizeof(mystr)-1);
+ if (recvip == NULL) {
+ lprintf(LOG_ERR, "Unable to find local IP address");
+ return -1;
+ }
+ }
+
+ printf("[Starting %sSOL with receiving address %s:%d]\r\n",
+ read_only ? "Read-only " : "", recvip, port);
+
+ set_terminal_size(rows, cols);
+ enter_raw_mode();
+
+ /*
+ * talk to smdc to start Console redirect - IP address and port as parameter
+ * ipmiutil -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x06 0xC0 0xA8 0xA8 0x78 0x1A 0x0A
+ */
+ result = ipmi_tsol_start(intf, recvip, port);
+ if (result < 0) {
+ leave_raw_mode();
+ lprintf(LOG_ERR, "Error starting SOL");
+ return -1;
+ }
+
+ printf("[SOL Session operational. Use %c? for help]\r\n",
+ sol_escape_char);
+
+ gettimeofday(&_start_keepalive, 0);
+
+ fd_socket = sockfd;
+ fds_wait[0].fd = fd_socket;
+ fds_wait[0].events = POLLIN;
+ fds_wait[0].revents = 0;
+ fds_wait[1].fd = fileno(stdin);
+ fds_wait[1].events = POLLIN;
+ fds_wait[1].revents = 0;
+ fds_wait[2].fd = -1;
+ fds_wait[2].events = 0;
+ fds_wait[2].revents = 0;
+
+ fds_data_wait[0].fd = fd_socket;
+ fds_data_wait[0].events = POLLIN | POLLOUT;
+ fds_data_wait[0].revents = 0;
+ fds_data_wait[1].fd = fileno(stdin);
+ fds_data_wait[1].events = POLLIN;
+ fds_data_wait[1].revents = 0;
+ fds_data_wait[2].fd = fileno(stdout);
+ fds_data_wait[2].events = POLLOUT;
+ fds_data_wait[2].revents = 0;
+
+ out_buff_fill = 0;
+ in_buff_fill = 0;
+ fds = fds_wait;
+
+ for (;;) {
+ result = poll(fds, 3, 15*1000);
+ if (result < 0)
+ break;
+
+ /* send keepalive packet */
+ tsol_keepalive(intf);
+
+ if ((fds[0].revents & POLLIN) && (sizeof(out_buff) > out_buff_fill)){
+ socklen_t sin_len = sizeof(sin);
+ result = recvfrom(fd_socket, buff, sizeof(out_buff) - out_buff_fill + 4, 0,
+ (struct sockaddr *)&sin, &sin_len);
+
+ /* read the data from udp socket, skip some bytes in the head */
+ if((result - 4) > 0 ){
+ int length = result - 4;
+#if 1
+ length = (unsigned char)buff[2] & 0xff;
+ length *= 256;
+ length += ((unsigned char)buff[3] & 0xff);
+ if ((length <= 0) || (length > (result - 4)))
+ length = result - 4;
+#endif
+ memcpy(out_buff + out_buff_fill, buff + 4, length);
+ out_buff_fill += length;
+ }
+ }
+ if ((fds[1].revents & POLLIN) && (sizeof(in_buff) > in_buff_fill)) {
+ result = read(fileno(stdin), in_buff + in_buff_fill,
+ sizeof(in_buff) - in_buff_fill); // read from keyboard
+ if (result > 0) {
+ int bytes;
+ bytes = do_inbuf_actions(intf, in_buff + in_buff_fill, result);
+ if(bytes < 0) {
+ result = ipmi_tsol_stop(intf, recvip, port);
+ do_terminal_cleanup();
+ return result;
+ }
+ if (read_only)
+ bytes = 0;
+ in_buff_fill += bytes;
+ }
+ }
+ if ((fds[2].revents & POLLOUT) && out_buff_fill) {
+ result = write(fileno(stdout), out_buff, out_buff_fill); // to screen
+ if (result > 0) {
+ out_buff_fill -= result;
+ if (out_buff_fill) {
+ memmove(out_buff, out_buff + result, out_buff_fill);
+ }
+ }
+ }
+ if ((fds[0].revents & POLLOUT) && in_buff_fill) {
+ /*
+ * translate key and send that to SMDC using IPMI
+ * ipmiutil cmd -N 192.168.168.227 -U Administrator 0x30 0x03 0x04 0x1B 0x5B 0x43
+ */
+ result = ipmi_tsol_send_keystroke(intf, in_buff,
+ MIN(in_buff_fill,14));
+ if (result > 0) {
+ gettimeofday(&_start_keepalive, 0);
+ in_buff_fill -= result;
+ if (in_buff_fill) {
+ memmove(in_buff, in_buff + result, in_buff_fill);
+ }
+ }
+ }
+ fds = (in_buff_fill || out_buff_fill )?
+ fds_data_wait : fds_wait;
+ }
+#endif
+
+ return 0;
+}
+
+#ifdef METACOMMAND
+int i_tsol(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+ set_loglevel(LOG_NOTICE);
+
+ while ( (c = getopt( argc, argv,"m:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 1; verbose = 1;
+ set_loglevel(LOG_DEBUG);
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ print_tsol_usage();
+ return ERR_USAGE;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rc = ipmi_tsol_main(intf, argc, argv);
+
+ ipmi_close_();
+ // show_outcome(progname,rc);
+ return rc;
+}
+/* end itsol.c */
+
diff --git a/util/itsol.h b/util/itsol.h
new file mode 100644
index 0000000..ec28d3f
--- /dev/null
+++ b/util/itsol.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2005 Tyan Computer Corp. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_TSOL_H
+#define IPMI_TSOL_H
+
+// #include <ipmitool/ipmi.h>
+
+#define IPMI_TSOL_CMD_SENDKEY 0x03
+#define IPMI_TSOL_CMD_START 0x06
+#define IPMI_TSOL_CMD_STOP 0x02
+#define IPMI_NETFN_TSOL 0x30
+
+#define IPMI_TSOL_DEF_PORT 6230
+
+#define IPMI_BUF_SIZE 1024 /* for ipmi_rs in defs.h */
+
+#define MIN(x,y) (((x) < (y)) ? (x) : (y))
+
+#ifdef HAVE_IPV6
+#define SOCKADDR_T struct sockaddr_storage
+#else
+#define SOCKADDR_T struct sockaddr_in
+#endif
+int get_LastError( void ); /* ipmilan.c */
+void show_LastError(char *tag, int err);
+void lprintf(int level, const char * format, ...); /*subs.c*/
+int lan_keepalive(int type); /*ipmilan.c*/
+void set_loglevel(int level);
+void lperror(int level, const char * format, ...);
+int ipmi_open(char fdebugcmd);
+int open_sockfd(char *node, SockType *sfd, SOCKADDR_T *daddr,
+ int *daddr_len, int foutput);
+
+int ipmi_tsol_main(void *, int, char **);
+
+#endif /* IPMI_TSOL_H */
diff --git a/util/iwdt.c b/util/iwdt.c
new file mode 100644
index 0000000..96d21c0
--- /dev/null
+++ b/util/iwdt.c
@@ -0,0 +1,415 @@
+/*
+ * wdt.c
+ *
+ * This tool reads and enables the watchdog timer via IPMI.
+ * Note that there are other methods for doing this, and the
+ * standard interface is for the driver to expose a /dev/watchdog
+ * device interface.
+ * WARNING: If you enable the watchdog, make sure you have something
+ * set up to keep resetting the timer at regular intervals, or it
+ * will reset your system.
+ * The Intel Server Management software does this automatically,
+ * and also continues to reset the timer as long as it is running.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2003-2006 Intel Corporation.
+ * Copyright (c) 2009 Kontron America, Inc.
+ *
+ * 02/25/03 Andy Cress - created
+ * 03/05/03 Andy Cress - added -d option to disable watchdog timer
+ * 06/11/03 Andy Cress - new ver 1.2 for EMSGSIZE fix
+ * 10/28/03 Andy Cress - fixed cc error in set_wdt (idata size),
+ * show action.
+ * 02/06/04 Andy Cress - added WIN32 flags
+ * 03/11/04 Andy Cress - 1.4 fixed cc=0xcc if pretimeout not zero.
+ * 05/05/04 Andy Cress - 1.5 call ipmi_close before exit
+ * 11/01/04 Andy Cress - 1.6 add -N / -R for remote nodes
+ * 11/16/04 Andy Cress - 1.7 add -U for remote username
+ * 12/02/04 Andy Cress - 1.8 add counter & pretimeout display in show_wdt
+ * added EFI ifdefs
+ * 04/13/06 Andy Cress - 1.9 fix -t if nsec > 255
+ * 06/22/06 Andy Cress - 1.10 add -a action and -l dontlog options
+ * 06/25/08 Andy Cress - 2.13 add -p for pre-timeout action
+ */
+/*M*
+Copyright (c) 2006, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "getopt.h"
+#elif defined(EFI)
+ // EFI: defined (EFI32) || defined (EFI64) || defined(EFIX64)
+ #ifndef NULL
+ #define NULL 0
+ #endif
+ #include <types.h>
+ #include <libdbg.h>
+ #include <unistd.h>
+ #include <errno.h>
+#elif defined(DOS)
+ #include <dos.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "getopt.h"
+#else
+/* Linux, Solaris, BSD */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <string.h>
+#include "ipmicmd.h"
+
+/*
+ * Global variables
+ */
+static char * progver = "2.93";
+static char * progname = "iwdt";
+static char fdebug = 0;
+static char fdontlog = 0;
+static char fcanonical = 0;
+static char bdelim = BDELIM; /* '|' */
+static uchar action = 1; /* default is Hard Reset */
+ /* 0 = "No action"
+ * 1 = "Hard Reset"
+ * 2 = "Power down"
+ * 3 = "Power cycle" */
+static uchar preaction = 0; /* default is None */
+ /* 1 = "SMI "
+ * 2 = "NMI "
+ * 3 = "Messaging Interrupt" */
+static uchar pretime = 0; /* usually 30 second default pre-timeout */
+static uchar ipmi_maj = 0;
+static uchar ipmi_min = 0;
+
+static int reset_wdt(void)
+{
+ uchar idata[4];
+ uchar rdata[16];
+ int rlen = 4;
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmd(WATCHDOG_RESET, idata, 0, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+}
+
+static int get_wdt(uchar *rdata, int rlen)
+{
+ uchar idata[4];
+ uchar ccode;
+ int ret;
+
+ ret = ipmi_cmd(WATCHDOG_GET, idata, 0, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end get_wdt()*/
+
+static int set_wdt(int val)
+{
+ uchar idata[6];
+ uchar rdata[16];
+ int rlen = 8;
+ uchar ccode, bl;
+ int ret, t;
+
+ t = val * 10; /* val is in sec, make timeout in 100msec */
+ if (fdontlog) bl = 0x80;
+ else bl = 0x00;
+ if ((ipmi_maj > 1) || /* IPMI 1.5 or greater */
+ (ipmi_maj == 1 && ipmi_min >= 5)) {
+ idata[0] = 0x44 | bl; /* DontLog=0, DontStop=1 & use SMS/OS */
+ } else idata[0] = 0x04 | bl; /* IPMI 1.0 or less */
+ idata[1] = (preaction << 4) | action; /* preaction/action */
+ idata[2] = 0; /* pretimeout: 0=disabled, or less than timeout */
+ if (preaction != 0) { /* enabled pretimeout */
+ idata[2] = pretime; /* pretimeout value in seconds */
+ } /*endif preaction/pretime */
+ idata[3] = 0x10; /* clear SMS/OS when done */
+ idata[4] = t & 0x00ff; /*timeout in 100msec: 0x4B0 = 1200. */
+ idata[5] = (t & 0xff00) >> 8;
+ ret = ipmi_cmd(WATCHDOG_SET, idata, 6, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end set_wdt()*/
+
+static int clear_wdt(void)
+{
+ uchar idata[6];
+ uchar rdata[16];
+ int rlen = 8;
+ uchar ccode = 0;
+ int ret;
+
+ idata[0] = 0x01; /* Use FRB2, stop timer */
+ idata[1] = 0x00; /* no action */
+ idata[2] = 30; /* pretimeout: 30 sec (disabled anyway) */
+ idata[3] = 0x02; /* clear FRB2*/
+ idata[4] = 0xB0;
+ idata[5] = 0x04;
+ ret = ipmi_cmd(WATCHDOG_SET, idata, 6, rdata, &rlen, &ccode, fdebug);
+ if (ret == 0 && ccode != 0) ret = ccode;
+ return(ret);
+} /*end clear_wdt()*/
+
+char *usedesc[6] = {"reserved", "BIOS FRB2", "BIOS/POST",
+ "OS Load", "SMS/OS", "OEM" };
+
+void show_wdt(uchar *wdt)
+{
+ uchar use;
+ char *pstr;
+ char *pstr2;
+ int i,j;
+
+ if (!fcanonical) {
+ printf("wdt data: ");
+ for (i=0; i<8; i++) printf("%02x ",wdt[i]);
+ printf("\n");
+ }
+
+ use = wdt[0] & 0x07;
+ if (use > 5) use = 0;
+ if ((wdt[0] & 0x40) == 0x40) pstr = "started";
+ else pstr = "stopped";
+ if ((wdt[0] & 0x80) == 0x80) pstr2 = "DontLog";
+ else pstr2 = "Logging";
+ if (fcanonical) {
+ printf("Watchdog timer state\t%c %s\n",bdelim,pstr);
+ printf(" Use with \t\t%c %s\n", bdelim,usedesc[use]);
+ printf(" Log mode \t\t%c %s\n", bdelim,pstr2);
+ } else {
+ printf("Watchdog timer is %s for use with %s. %s\n",pstr,usedesc[use],pstr2);
+ }
+ switch (wdt[1] & 0x70)
+ {
+ case 0x10: pstr = "SMI"; break;
+ case 0x20: pstr = "NMI"; break;
+ case 0x30: pstr = "MsgInt"; break;
+ default: pstr = "None";
+ }
+ if (fcanonical) {
+ printf(" Pretimeout\t\t%c %d seconds\n", bdelim,wdt[2]);
+ printf(" Pre-action\t\t%c %s\n", bdelim,pstr);
+ } else {
+ printf(" pretimeout is %d seconds, pre-action is %s\n",
+ wdt[2],pstr);
+ }
+ /* wdt[3] is the TimerUseExpFlags */
+ i = (wdt[4] + (wdt[5] << 8)) / 10;
+ j = (wdt[6] + (wdt[7] << 8)) / 10;
+ if (fcanonical) {
+ printf(" Timeout \t\t%c %d seconds\n", bdelim,i);
+ printf(" Counter \t\t%c %d seconds\n", bdelim,j);
+ } else {
+ printf(" timeout is %d seconds, counter is %d seconds\n",i,j);
+ }
+ switch (wdt[1] & 0x07)
+ {
+ case 0: pstr = "No action"; break;
+ case 1: pstr = "Hard Reset"; break;
+ case 2: pstr = "Power down"; break;
+ case 3: pstr = "Power cycle"; break;
+ default: pstr = "Reserved";
+ }
+ if (fcanonical) {
+ printf(" Action \t\t%c %s\n", bdelim,pstr);
+ } else {
+ printf(" action is %s\n",pstr);
+ }
+}
+
+
+#ifdef METACOMMAND
+int i_wdt(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int ret = 0;
+ int rv = 0;
+ int c;
+ uchar freadonly = 1;
+ uchar freset = 0;
+ uchar fdisable = 0;
+ uchar wdtbuf[8];
+ uchar devrec[16];
+ int t = 0;
+ int a;
+
+#if defined (EFI)
+ InitializeLib(_LIBC_EFIImageHandle, _LIBC_EFISystemTable);
+#else
+ printf("%s ver %s\n", progname,progver);
+#endif
+ parse_lan_options('V',"4",0); /*default to admin priv*/
+
+ while ((c = getopt(argc,argv,"cdelra:p:q:t:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch(c) {
+ case 'r': freset = 1; break; /* reset watchdog timer */
+ case 'l': fdontlog = 1; break; /* dont log the wdt events */
+ case 'a': a = atoi(optarg); /* set wd action */
+ if (a >= 0 && a < 4) action = (uchar)a;
+ freadonly = 0;
+ break;
+ case 'p': a = atoi(optarg); /* set wd preaction */
+ if (a >= 0 && a < 4) preaction = (uchar)a;
+ freadonly = 0;
+ break;
+ case 'q': a = atoi(optarg); /* set wd pretimeout */
+ if (a > 255) pretime = 255;
+ else if (a >= 5) pretime = (uchar)a;
+ /* else arg is out of bounds */
+ freadonly = 0;
+ break;
+ case 'c': fcanonical = 1; break; /* canonical output */
+ case 'd': fdisable = 1; break; /* disable wdt */
+ case 'e': freadonly = 0; break; /* enable wdt */
+ case 't': t = atoi(optarg); freadonly = 0; break; /*timeout*/
+ case 'x': fdebug = 1; break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ printf("Usage: %s [-acdelpqrx -t sec -NUPRETVF]\n", progname);
+ printf(" where -r reset watchdog timer\n");
+ printf(" -a N set watchdog Action (N=0,1,2,3)\n");
+ printf(" -c canonical output format\n");
+ printf(" -d disable watchdog timer\n");
+ printf(" -e enable watchdog timer\n");
+ printf(" -l don't Log watchdog events\n");
+ printf(" -p N set watchdog Preaction (N=0,1,2,3)\n");
+ printf(" -q N set watchdog pretimeout to N sec\n");
+ printf(" -t N set timeout to N seconds\n");
+ printf(" -x show eXtra debug messages\n");
+ print_lan_opt_usage();
+ ret = ERR_USAGE;
+ goto do_exit;
+ }
+ if (t == 0) t = 120; /* default timeout, 120 seconds*/
+ if ((pretime != 0) && (preaction == 0)) preaction = 2; /*default is NMI*/
+ if (preaction != 0) {
+ if (pretime == 0) {
+ if (t >= 280) { pretime = 255;
+ } else {
+ a = t * 10; /* t is in sec, make timeout(a) in 100msec */
+ pretime = (a - t)/10; /*90% of timeout, in seconds*/
+ }
+ }
+ if ((t - pretime) < 5) { /*if not enough difference*/
+ /* (timeout - pretimeout) must be >= 5 sec */
+ /* if val < 50 sec, 10% diff < 5 */
+ if (t < 20) pretime = 0; /* not enough headroom */
+ else pretime = t - 5;
+ }
+ }
+
+ ret = ipmi_getdeviceid(devrec,16,fdebug);
+ if (ret != 0) {
+ goto do_exit;
+ } else {
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+#ifndef EFI
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+#endif
+ }
+
+ ret = get_wdt(&wdtbuf[0],8);
+ if (ret != 0) {
+ printf("get_wdt error: ret = %x\n",ret);
+ goto do_exit;
+ }
+ show_wdt(wdtbuf);
+
+ if (fdisable) {
+ printf("Disabling watchdog timer ...\n");
+ ret = clear_wdt();
+ if (ret != 0) printf("clear_wdt error: ret = %x\n",ret);
+ ret = get_wdt(wdtbuf,8);
+ show_wdt(wdtbuf);
+ } else if (!freadonly) {
+ printf("Setting watchdog timer to %d seconds ...\n",t);
+ ret = set_wdt(t);
+ if (ret != 0) printf("set_wdt error: ret = %x\n",ret);
+ rv = get_wdt(wdtbuf,8);
+ show_wdt(wdtbuf);
+ /*
+ * If we set the wd timer, we need to set up a cron job, daemon,
+ * or script to reset the timer also. (e.g.: "sleep 1; wdt -r")
+ */
+ }
+ if (freset && !fdisable) {
+ printf("Resetting watchdog timer ...\n");
+ ret = reset_wdt();
+ if (ret == 0xC0) /*node busy*/
+ printf("Node busy: set the timeout longer.\n");
+#ifndef EFI
+ printf("reset_wdt: ret = %d\n",ret);
+ rv = get_wdt(wdtbuf,8);
+ show_wdt(wdtbuf);
+#endif
+ }
+#ifndef EFI
+ printf("\n");
+#endif
+do_exit:
+ ipmi_close_();
+ // show_outcome(progname,ret);
+ return (ret);
+} /* end main()*/
+
+/* end wdt.c */
diff --git a/util/md2.c b/util/md2.c
new file mode 100644
index 0000000..f1b4796
--- /dev/null
+++ b/util/md2.c
@@ -0,0 +1,99 @@
+/*
+ * md2.c
+ * Used in ipmilan.c
+ *
+ * 05/26/2006 ARCress - copied from freeipmi ipmi-md2.c,
+ * added md2_sum() subroutine, added WIN32 flag
+ * 08/14/2008 ARCress - moved md2 routines from md2.c to md2.h
+ */
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2002-2008, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <errno.h>
+
+#undef MD2_GPL
+#undef MD2_LIB
+#if defined(ALLOW_GNU)
+#define MD2_GPL 1 /*use md2.h GPL code*/
+#else
+/* if here, ALLOW_GPL is not defined, check for lanplus libcrypto. */
+#if defined(HAVE_LANPLUS)
+#define MD2_LIB 1 /*use MD2 version from lanplus libcrypto */
+#endif
+/* if libcrypto does not have EVP_md2, then skip MD2. */
+#if defined(SKIP_MD2)
+#undef MD2_LIB
+#endif
+#endif
+
+/* use GPL md2.h only if "configure --enable-gpl" set ALLOW_GPL */
+#ifdef MD2_GPL
+/*
+ * The md2.h contains some GPL code that may not be desired in some cases.
+ * If GPL is not desired, the md2.h can be deleted without modifying the
+ * configure/make process.
+ * If GPL is ok, then "configure --enable-gpl" should be used.
+ */
+#include "md2.h"
+#else
+/* else MD2_GPL is not set */
+
+#ifdef MD2_LIB
+/* Use EVP_md2() from the openssl libcrypto.so */
+#include <openssl/evp.h>
+void md2_sum(unsigned char *pdata, int sdata, unsigned char *digest)
+{
+ EVP_MD_CTX ctx;
+ unsigned int mdlen;
+ static int fmd2added = 0;
+ const EVP_MD *md = NULL;
+
+ md = EVP_md2();
+ if (fmd2added == 0) {
+ EVP_add_digest(md);
+ fmd2added = 1;
+ }
+ EVP_MD_CTX_init(&ctx);
+ EVP_DigestInit_ex(&ctx, md, NULL);
+ EVP_DigestUpdate(&ctx, pdata, sdata);
+ mdlen = 16;
+ EVP_DigestFinal_ex(&ctx, digest, &mdlen);
+ EVP_MD_CTX_cleanup(&ctx);
+}
+#endif
+
+#endif
+
+/*end md2.c */
diff --git a/util/md2.h b/util/md2.h
new file mode 100644
index 0000000..29c77fd
--- /dev/null
+++ b/util/md2.h
@@ -0,0 +1,269 @@
+/*
+ * md2.h
+ * Used in ipmilan.c
+ *
+ * 05/26/2006 ARCress - copied from freeipmi ipmi-md2.c,
+ * added md2_sum() subroutine, added WIN32 flag
+ * 08/14/2008 ARCress - moved md2 routines from md2.c to md2.h
+ */
+/*
+ Copyright (C) 2003 FreeIPMI Core Team
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ A copy of the GNU General Public License is available as
+ /usr/share/common-licenses/GPL-2 in the Debian distribution or on
+ the World Wide Web at http://www.gnu.org/copyleft/gpl.html. You can
+ also obtain it by writing to the Free Software Foundation, Inc.,
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+/* only include this file if MD2OK was defined */
+
+#ifdef WIN32
+#define u_int32_t unsigned int
+#define u_int8_t unsigned char
+#endif
+/* start ipmi-md2.h */
+#define IPMI_MD2_BLOCK_LEN 16
+#define IPMI_MD2_BUFFER_LEN 48
+#define IPMI_MD2_CHKSUM_LEN 16
+#define IPMI_MD2_DIGEST_LEN 16
+#define IPMI_MD2_PADDING_LEN 16
+#define IPMI_MD2_ROUNDS_LEN 18
+
+typedef struct __md2 {
+ u_int32_t magic;
+ u_int8_t l;
+ unsigned int mlen;
+ u_int8_t x[IPMI_MD2_BUFFER_LEN];
+ u_int8_t c[IPMI_MD2_CHKSUM_LEN];
+ u_int8_t m[IPMI_MD2_BLOCK_LEN];
+} ipmi_md2_t;
+
+int ipmi_md2_init(ipmi_md2_t *ctx);
+int ipmi_md2_update_data(ipmi_md2_t *ctx, u_int8_t *buf, unsigned int buflen);
+int ipmi_md2_finish(ipmi_md2_t *ctx, u_int8_t *digest, unsigned int digestlen);
+/* end ipmi-md2.h */
+
+static char padding[16][16] =
+ {
+ {0x01},
+ {0x02,0x02},
+ {0x03,0x03,0x03},
+ {0x04,0x04,0x04,0x04},
+ {0x05,0x05,0x05,0x05,0x05},
+ {0x06,0x06,0x06,0x06,0x06,0x06},
+ {0x07,0x07,0x07,0x07,0x07,0x07,0x07},
+ {0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08},
+ {0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09},
+ {0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A},
+ {0x0B,0x0B,0x0B,0x0B,0x0B,0x0B,0x0B,0x0B,0x0B,0x0B,0x0B},
+ {0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C},
+ {0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D,0x0D},
+ {0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E,0x0E},
+ {0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F},
+ {0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10}
+ };
+
+static unsigned char S[256] =
+ {
+ 0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01,
+ 0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13,
+ 0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,
+ 0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA,
+ 0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,
+ 0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,
+ 0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49,
+ 0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A,
+ 0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,
+ 0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,
+ 0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27,
+ 0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,
+ 0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1,
+ 0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6,
+ 0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
+ 0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1,
+ 0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20,
+ 0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,
+ 0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6,
+ 0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,
+ 0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,
+ 0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26,
+ 0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09,
+ 0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,
+ 0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,
+ 0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A,
+ 0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,
+ 0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39,
+ 0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4,
+ 0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
+ 0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A,
+ 0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14
+ };
+
+#define L ctx->l
+#define X ctx->x
+#define C ctx->c
+#define M ctx->m
+#define Mlen ctx->mlen
+#define IPMI_MD2_MAGIC 0xf00fd00d
+
+int
+ipmi_md2_init(ipmi_md2_t *ctx)
+{
+
+ if (ctx == NULL)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ ctx->magic = IPMI_MD2_MAGIC;
+
+ L = 0;
+ Mlen = 0;
+ memset(X, '\0', IPMI_MD2_BUFFER_LEN);
+ memset(C, '\0', IPMI_MD2_CHKSUM_LEN);
+ memset(M, '\0', IPMI_MD2_BLOCK_LEN);
+
+ return 0;
+}
+
+static void
+_ipmi_md2_update_digest_and_checksum(ipmi_md2_t *ctx)
+{
+ int j, k;
+ u_int8_t c, t;
+
+ /* Update X */
+
+ for (j = 0; j < IPMI_MD2_BLOCK_LEN; j++)
+ {
+ X[16+j] = M[j];
+ X[32+j] = (X[16+j] ^ X[j]);
+ }
+
+ t = 0;
+
+ for (j = 0; j < IPMI_MD2_ROUNDS_LEN; j++)
+ {
+ for (k = 0; k < IPMI_MD2_BUFFER_LEN; k++)
+ {
+ t = X[k] = (X[k] ^ S[t]);
+ }
+ t = (t + j) % 256;
+ }
+
+ /* Update C and L */
+
+ /* achu: Note that there is a typo in the RFC 1319 specification.
+ * In section 3.2, the line:
+ *
+ * Set C[j] to S[c xor L]
+ *
+ * should read:
+ *
+ * Set C[j] to C[j] xor S[c xor L].
+ */
+
+ for (j = 0; j < IPMI_MD2_BLOCK_LEN; j++)
+ {
+ c = M[j];
+ C[j] = C[j] ^ S[c ^ L];
+ L = C[j];
+ }
+}
+
+int
+ipmi_md2_update_data(ipmi_md2_t *ctx, u_int8_t *buf, unsigned int buflen)
+{
+
+ if (ctx == NULL || ctx->magic != IPMI_MD2_MAGIC || buf == NULL)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (buflen == 0)
+ return 0;
+
+ if ((Mlen + buflen) >= IPMI_MD2_BLOCK_LEN)
+ {
+ unsigned int bufcount;
+
+ bufcount = (IPMI_MD2_BLOCK_LEN - Mlen);
+ memcpy(M + Mlen, buf, bufcount);
+ _ipmi_md2_update_digest_and_checksum(ctx);
+
+ while ((buflen - bufcount) >= IPMI_MD2_BLOCK_LEN)
+ {
+ memcpy(M, buf + bufcount, IPMI_MD2_BLOCK_LEN);
+ bufcount += IPMI_MD2_BLOCK_LEN;
+ _ipmi_md2_update_digest_and_checksum(ctx);
+ }
+
+ Mlen = buflen - bufcount;
+ if (Mlen > 0)
+ memcpy(M, buf + bufcount, Mlen);
+ }
+ else
+ {
+ /* Not enough data to update X and C, just copy in data */
+ memcpy(M + Mlen, buf, buflen);
+ Mlen += buflen;
+ }
+
+ return buflen;
+}
+
+static void
+_ipmi_md2_append_padding_and_checksum(ipmi_md2_t *ctx)
+{
+ unsigned int padlen;
+ int padindex;
+
+ padlen = IPMI_MD2_PADDING_LEN - Mlen;
+ padindex = padlen - 1;
+
+ ipmi_md2_update_data(ctx, padding[padindex], padlen);
+
+ ipmi_md2_update_data(ctx, C, IPMI_MD2_CHKSUM_LEN);
+}
+
+int
+ipmi_md2_finish(ipmi_md2_t *ctx, u_int8_t *digest, unsigned int digestlen)
+{
+
+ if (ctx == NULL || ctx->magic != IPMI_MD2_MAGIC
+ || digest == NULL || digestlen < IPMI_MD2_DIGEST_LEN)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ _ipmi_md2_append_padding_and_checksum(ctx);
+ memcpy(digest, X, IPMI_MD2_DIGEST_LEN);
+
+ return IPMI_MD2_DIGEST_LEN;
+}
+
+/* added - ARCress */
+void md2_sum(unsigned char *pdata, int sdata, unsigned char *digest)
+{
+ ipmi_md2_t ctx;
+
+ ipmi_md2_init(&ctx);
+ ipmi_md2_update_data(&ctx, pdata, sdata);
+ ipmi_md2_finish(&ctx, digest, 16);
+}
+/*end md2.h */
diff --git a/util/md5.c b/util/md5.c
new file mode 100644
index 0000000..9f4db4e
--- /dev/null
+++ b/util/md5.c
@@ -0,0 +1,413 @@
+/*
+ * md5.c
+ * Used in ipmilan.c
+ *
+ * 05/26/2006 ARCress - copied from sf.net/projects/libmd5-rfc/,
+ * added md5-sum() subroutine.
+ */
+/*
+ Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ L. Peter Deutsch
+ ghost@aladdin.com
+
+ */
+/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
+/*
+ Independent implementation of MD5 (RFC 1321).
+
+ This code implements the MD5 Algorithm defined in RFC 1321, whose
+ text is available at
+ http://www.ietf.org/rfc/rfc1321.txt
+ The code is derived from the text of the RFC, including the test suite
+ (section A.5) but excluding the rest of Appendix A. It does not include
+ any code or documentation that is identified in the RFC as being
+ copyrighted.
+
+ The original and principal author of md5.c is L. Peter Deutsch
+ <ghost@aladdin.com>. Other authors are noted in the change history
+ that follows (in reverse chronological order):
+
+ 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
+ either statically or dynamically; added missing #include <string.h>
+ in library.
+ 2002-03-11 lpd Corrected argument list for main(), and added int return
+ type, in test program and T value program.
+ 2002-02-21 lpd Added missing #include <stdio.h> in test program.
+ 2000-07-03 lpd Patched to eliminate warnings about "constant is
+ unsigned in ANSI C, signed in traditional"; made test program
+ self-checking.
+ 1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+ 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+ 1999-05-03 lpd Original version.
+ */
+
+#include <string.h>
+
+/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+ md5_word_t count[2]; /* message length in bits, lsw first */
+ md5_word_t abcd[4]; /* digest buffer */
+ md5_byte_t buf[64]; /* accumulate block */
+} md5_state_t;
+
+void md5_init(md5_state_t *pms);
+void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+/* end md5.h */
+
+#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
+#ifdef ARCH_IS_BIG_ENDIAN
+# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+# define BYTE_ORDER 0
+#endif
+
+#define T_MASK ((md5_word_t)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3 0x242070db
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6 0x4787c62a
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9 0x698098d8
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13 0x6b901122
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16 0x49b40821
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19 0x265e5a51
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22 0x02441453
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25 0x21e1cde6
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28 0x455a14ed
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31 0x676f02d9
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35 0x6d9d6122
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38 0x4bdecfa9
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41 0x289b7ec6
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44 0x04881d05
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47 0x1fa27cf8
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50 0x432aff97
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53 0x655b59c3
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57 0x6fa87e4f
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60 0x4e0811a1
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63 0x2ad7d2bb
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+
+
+static void
+md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+{
+ md5_word_t
+ a = pms->abcd[0], b = pms->abcd[1],
+ c = pms->abcd[2], d = pms->abcd[3];
+ md5_word_t t;
+#if BYTE_ORDER > 0
+ /* Define storage only for big-endian CPUs. */
+ md5_word_t X[16];
+#else
+ /* Define storage for little-endian or both types of CPUs. */
+ md5_word_t xbuf[16];
+ const md5_word_t *X = NULL;
+#endif
+
+ {
+#if BYTE_ORDER == 0
+ /*
+ * Determine dynamically whether this is a big-endian or
+ * little-endian machine, since we can use a more efficient
+ * algorithm on the latter.
+ */
+ static const int w = 1;
+
+ if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
+#endif
+#if BYTE_ORDER <= 0 /* little-endian */
+ {
+ /*
+ * On little-endian machines, we can process properly aligned
+ * data without copying it.
+ */
+ if (!((data - (const md5_byte_t *)0) & 3)) {
+ /* data are properly aligned */
+ X = (const md5_word_t *)data;
+ } else {
+ /* not aligned */
+ memcpy(xbuf, data, 64);
+ X = xbuf;
+ }
+ }
+#endif
+#if BYTE_ORDER == 0
+ else /* dynamic big-endian */
+#endif
+#if BYTE_ORDER >= 0 /* big-endian */
+ {
+ /*
+ * On big-endian machines, we must arrange the bytes in the
+ * right order.
+ */
+ const md5_byte_t *xp = data;
+ int i;
+
+# if BYTE_ORDER == 0
+ X = xbuf; /* (dynamic only) */
+# else
+# define xbuf X /* (static only) */
+# endif
+ for (i = 0; i < 16; ++i, xp += 4)
+ xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+ }
+#endif
+ }
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+ /* Round 1. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + F(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 7, T1);
+ SET(d, a, b, c, 1, 12, T2);
+ SET(c, d, a, b, 2, 17, T3);
+ SET(b, c, d, a, 3, 22, T4);
+ SET(a, b, c, d, 4, 7, T5);
+ SET(d, a, b, c, 5, 12, T6);
+ SET(c, d, a, b, 6, 17, T7);
+ SET(b, c, d, a, 7, 22, T8);
+ SET(a, b, c, d, 8, 7, T9);
+ SET(d, a, b, c, 9, 12, T10);
+ SET(c, d, a, b, 10, 17, T11);
+ SET(b, c, d, a, 11, 22, T12);
+ SET(a, b, c, d, 12, 7, T13);
+ SET(d, a, b, c, 13, 12, T14);
+ SET(c, d, a, b, 14, 17, T15);
+ SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+ /* Round 2. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + G(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 1, 5, T17);
+ SET(d, a, b, c, 6, 9, T18);
+ SET(c, d, a, b, 11, 14, T19);
+ SET(b, c, d, a, 0, 20, T20);
+ SET(a, b, c, d, 5, 5, T21);
+ SET(d, a, b, c, 10, 9, T22);
+ SET(c, d, a, b, 15, 14, T23);
+ SET(b, c, d, a, 4, 20, T24);
+ SET(a, b, c, d, 9, 5, T25);
+ SET(d, a, b, c, 14, 9, T26);
+ SET(c, d, a, b, 3, 14, T27);
+ SET(b, c, d, a, 8, 20, T28);
+ SET(a, b, c, d, 13, 5, T29);
+ SET(d, a, b, c, 2, 9, T30);
+ SET(c, d, a, b, 7, 14, T31);
+ SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+ /* Round 3. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + H(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 5, 4, T33);
+ SET(d, a, b, c, 8, 11, T34);
+ SET(c, d, a, b, 11, 16, T35);
+ SET(b, c, d, a, 14, 23, T36);
+ SET(a, b, c, d, 1, 4, T37);
+ SET(d, a, b, c, 4, 11, T38);
+ SET(c, d, a, b, 7, 16, T39);
+ SET(b, c, d, a, 10, 23, T40);
+ SET(a, b, c, d, 13, 4, T41);
+ SET(d, a, b, c, 0, 11, T42);
+ SET(c, d, a, b, 3, 16, T43);
+ SET(b, c, d, a, 6, 23, T44);
+ SET(a, b, c, d, 9, 4, T45);
+ SET(d, a, b, c, 12, 11, T46);
+ SET(c, d, a, b, 15, 16, T47);
+ SET(b, c, d, a, 2, 23, T48);
+#undef SET
+
+ /* Round 4. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + I(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 6, T49);
+ SET(d, a, b, c, 7, 10, T50);
+ SET(c, d, a, b, 14, 15, T51);
+ SET(b, c, d, a, 5, 21, T52);
+ SET(a, b, c, d, 12, 6, T53);
+ SET(d, a, b, c, 3, 10, T54);
+ SET(c, d, a, b, 10, 15, T55);
+ SET(b, c, d, a, 1, 21, T56);
+ SET(a, b, c, d, 8, 6, T57);
+ SET(d, a, b, c, 15, 10, T58);
+ SET(c, d, a, b, 6, 15, T59);
+ SET(b, c, d, a, 13, 21, T60);
+ SET(a, b, c, d, 4, 6, T61);
+ SET(d, a, b, c, 11, 10, T62);
+ SET(c, d, a, b, 2, 15, T63);
+ SET(b, c, d, a, 9, 21, T64);
+#undef SET
+
+ /* Then perform the following additions. (That is increment each
+ of the four registers by the value it had before this block
+ was started.) */
+ pms->abcd[0] += a;
+ pms->abcd[1] += b;
+ pms->abcd[2] += c;
+ pms->abcd[3] += d;
+}
+
+void
+md5_init(md5_state_t *pms)
+{
+ pms->count[0] = pms->count[1] = 0;
+ pms->abcd[0] = 0x67452301;
+ pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+ pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+ pms->abcd[3] = 0x10325476;
+}
+
+void
+md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+{
+ const md5_byte_t *p = data;
+ int left = nbytes;
+ int offset = (pms->count[0] >> 3) & 63;
+ md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+ if (nbytes <= 0)
+ return;
+
+ /* Update the message length. */
+ pms->count[1] += nbytes >> 29;
+ pms->count[0] += nbits;
+ if (pms->count[0] < nbits)
+ pms->count[1]++;
+
+ /* Process an initial partial block. */
+ if (offset) {
+ int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+ memcpy(pms->buf + offset, p, copy);
+ if (offset + copy < 64)
+ return;
+ p += copy;
+ left -= copy;
+ md5_process(pms, pms->buf);
+ }
+
+ /* Process full blocks. */
+ for (; left >= 64; p += 64, left -= 64)
+ md5_process(pms, p);
+
+ /* Process a final partial block. */
+ if (left)
+ memcpy(pms->buf, p, left);
+}
+
+void
+md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+{
+ static const md5_byte_t pad[64] = {
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+ md5_byte_t data[8];
+ int i;
+
+ /* Save the length before padding. */
+ for (i = 0; i < 8; ++i)
+ data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+ /* Pad to 56 bytes mod 64. */
+ md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+ /* Append the length. */
+ md5_append(pms, data, 8);
+ for (i = 0; i < 16; ++i)
+ digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+/* added - ARCress */
+void md5_sum(unsigned char *pdata, int sdata, unsigned char *digest)
+{
+ md5_state_t state;
+
+ md5_init(&state);
+ md5_append(&state, pdata, sdata);
+ md5_finish(&state, digest);
+}
diff --git a/util/mem_if.c b/util/mem_if.c
new file mode 100644
index 0000000..c445138
--- /dev/null
+++ b/util/mem_if.c
@@ -0,0 +1,900 @@
+/*----------------------------------------------------------------------*
+ * mem_if.c
+ * Get SMBIOS Tables and associated data.
+ * This code is 64-bit safe.
+ * Note that for Windows, this should be compiled with /TP (as C++).
+ *
+ * 12/17/07 ARCress - created
+ * 02/26/08 ARCress - decode type 15 log structure
+ * 07/21/08 ARCress - fixed for 64-bit memory model
+ * 08/12/08 ARCress - trim out extra stuff, consolidated
+ *----------------------------------------------------------------------*/
+/*----------------------------------------------------------------------*
+The BSD License
+
+Copyright (c) 2002-2008, Intel Corporation
+Copyright (c) 2009 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------*/
+
+#ifdef WIN32
+#define _WIN32_DCOM
+#pragma once
+#include <windows.h>
+#include <stdio.h>
+#include <iostream> //deprecated iostream.h
+#include <Objbase.h> //ole32.lib
+#include <comutil.h>
+#include <Wbemcli.h> //Wbemcli.h,Wbemidl.h Wbemuuid.lib
+
+#elif defined(DOS)
+#include <dos.h>
+#include <stdlib.h>
+#include <string.h>
+
+#else // Linux or Solaris
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#endif
+#if defined(SOLARIS) || defined(BSD)
+#define EXEC_PAGESIZE 4096
+#endif
+
+#define DOS_MEM_RANGE_BASE 0xF0000 //starting memory range for smbios tables
+#define DOS_NUM_BYTES_TO_MAP 0x0FFFE //number bytes to map for smbios tables
+
+//smbios defines
+#define SMBIOS_STRING "_SM_" //server management bios string
+#define SMBIOS_MAJOR_REV 2 //major rev for smbios spec 2.3
+#define SMBIOS_MINOR_REV 1 //minor rev for smbios spce 2.3
+#define SMBIOS_STRUCTURE_TYPE_OFFSET 0 //offset in structure for type
+#define SMBIOS_STRUCTURE_LENGTH_OFFSET 1 //offset in structure for length
+#define SMBIOS_TABLE_LENGTH_OFFSET 0x5 //offset for length of table
+#define SMBIOS_MAJOR_REV_OFFSET 0x6 //offset for major rev of smbios
+#define SMBIOS_MINOR_REV_OFFSET 0x7 //offset for minor rev of smbios
+#define SMBIOS_TABLE_ENTRY_POINT_OFFSET 0x18 //offset for smbios structure table entry point
+#define SMBIOS_TABLE_SIZE_OFFSET 0x16 //offset for smbios structure table size
+#define NIBBLE_SIZE 4 //bit size of a nibble
+
+#ifdef WIN32
+extern "C" { char fsm_debug = 0; } /*=1 to show smbios debug messages*/
+#else
+char fsm_debug = 0; /*=1 to show smbios debug messages*/
+#endif
+static int s_iTableRev = 0; //static globabl var to store table revision
+
+#ifndef WIN32
+typedef int BOOL;
+typedef unsigned long ULONG;
+typedef unsigned char UCHAR;
+typedef unsigned short USHORT;
+
+BOOL MapPhysicalMemory(ULONG tdStartAddress, ULONG ulSize,
+ ULONG* ptdVirtualAddress);
+BOOL UnMapPhysicalMemory(ULONG tdVirtualAddress, ULONG ulSize);
+int OpenIMemoryInterface(void);
+int CloseIMemoryInterface(void);
+#endif // Linux, not __WINDOWS__
+
+#ifdef WIN32
+ /* Windows Memory routines */
+static BYTE m_byMajorVersion = 0;
+static BYTE m_byMinorVersion = 0;
+static BYTE * m_pbBIOSData = NULL;
+static DWORD m_dwLen = 0;
+
+extern "C" {
+
+int getSmBiosTables(UCHAR **ptableAddress)
+{
+ int bRet = 0;
+ HRESULT hres;
+ IWbemLocator *pLoc = 0;
+ IWbemServices *pSvc = 0;
+ IEnumWbemClassObject* pEnumerator = NULL;
+
+ // Initialize COM.
+ hres = CoInitializeEx(0, COINIT_MULTITHREADED);
+ if (FAILED(hres)) {
+ return bRet;
+ }
+
+ // Obtain the initial locator to Windows Management
+ // on a particular host computer.
+ hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
+ IID_IWbemLocator, (LPVOID *) &pLoc);
+ if (FAILED(hres)) {
+ CoUninitialize();
+ return bRet;
+ }
+
+
+ // Connect to the root\cimv2 namespace with the
+ // current user and obtain pointer pSvc
+ // to make IWbemServices calls.
+ hres = pLoc->ConnectServer(
+ _bstr_t(L"ROOT\\WMI"), // WMI namespace
+ NULL, // User name
+ NULL, // User password
+ 0, // Locale
+ NULL, // Security flags
+ 0, // Authority
+ 0, // Context object
+ &pSvc // IWbemServices proxy
+ );
+ if (FAILED(hres)) {
+ pLoc->Release();
+ CoUninitialize();
+ return bRet;
+ }
+
+ // Set the IWbemServices proxy so that impersonation
+ // of the user (client) occurs.
+ hres = CoSetProxyBlanket(
+ pSvc, // the proxy to set
+ RPC_C_AUTHN_WINNT, // authentication service
+ RPC_C_AUTHZ_NONE, // authorization service
+ NULL, // Server principal name
+ RPC_C_AUTHN_LEVEL_CALL, // authentication level
+ RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation level
+ NULL, // client identity
+ EOAC_NONE // proxy capabilities
+ );
+ if (FAILED(hres)) {
+ pSvc->Release();
+ pLoc->Release();
+ CoUninitialize();
+ return bRet; // Program has failed.
+ }
+
+ hres = pSvc->CreateInstanceEnum( L"MSSMBios_RawSMBiosTables", 0,
+ NULL, &pEnumerator);
+ if (FAILED(hres)) {
+ pSvc->Release();
+ pLoc->Release();
+ CoUninitialize();
+ return bRet; // Program has failed.
+ } else {
+ do {
+ IWbemClassObject* pInstance = NULL;
+ ULONG dwCount = NULL;
+
+ hres = pEnumerator->Next(WBEM_INFINITE, 1, &pInstance, &dwCount);
+ if (SUCCEEDED(hres))
+ {
+ VARIANT varBIOSData;
+ VariantInit(&varBIOSData);
+ CIMTYPE type;
+
+ hres = pInstance->Get(bstr_t("SmbiosMajorVersion"),0,&varBIOSData,&type,NULL);
+ if (FAILED(hres)) {
+ VariantClear(&varBIOSData);
+ } else {
+ m_byMajorVersion = (BYTE)varBIOSData.iVal;
+ VariantInit(&varBIOSData);
+ hres = pInstance->Get(bstr_t("SmbiosMinorVersion"),0,&varBIOSData,&type,NULL);
+ if(FAILED(hres)) {
+ VariantClear(&varBIOSData);
+ } else {
+ m_byMinorVersion = (BYTE)varBIOSData.iVal;
+ s_iTableRev = (m_byMajorVersion << 4) + m_byMinorVersion;
+
+ VariantInit(&varBIOSData);
+ hres = pInstance->Get(bstr_t("SMBiosData"),0,&varBIOSData,&type,NULL);
+ if(SUCCEEDED(hres)) {
+ if ( ( VT_UI1 | VT_ARRAY ) != varBIOSData.vt ) {
+ } else {
+ SAFEARRAY *parray = NULL;
+ parray = V_ARRAY(&varBIOSData);
+ BYTE* pbData = (BYTE*)parray->pvData;
+
+ m_dwLen = parray->rgsabound[0].cElements;
+
+ m_pbBIOSData = (BYTE *)malloc(m_dwLen);
+ memcpy(m_pbBIOSData,pbData,m_dwLen);
+ *ptableAddress = m_pbBIOSData;
+ bRet = m_dwLen;
+ }
+ }
+ VariantClear(&varBIOSData);
+ }
+ }
+ break;
+ }
+ } while (hres == WBEM_S_NO_ERROR);
+ }
+
+ // Cleanup
+ // ========
+ pSvc->Release();
+ pLoc->Release();
+ CoUninitialize();
+ return(bRet);
+} /*end getSmBiosTables*/
+
+int closeSmBios(UCHAR *ptableAddress, ULONG ulSmBiosLen)
+{
+ int rv = 0;
+ /* memory interface already closed */
+ free(ptableAddress);
+ return(rv);
+}
+
+} /*end extern C*/
+
+#else
+ /* Linux Memory routines */
+#define MEM_DRIVER "/dev/mem"
+#define FALSE 0
+#define TRUE 1
+//intialize static handle amd counter
+static int m_iDriver = 0;
+static int m_iCount = 0;
+
+//////////////////////////////////////////////////////////////////////////////
+// OpenIMemoryInterface
+//////////////////////////////////////////////////////////////////////////////
+// Name: OpenIMemoryInterface
+// Purpose: create handle to driver if first time
+// Context: static m_iDriver & m_iCount
+// Returns: int rv (0 = success)
+// Parameters: none
+// Notes:
+///////////////////////////////////////////////////////////////////////////////
+int OpenIMemoryInterface(void)
+{
+ int rv = -1;
+ //check to see if driver has been previously defined
+ if (!m_iDriver) { //open the driver
+ m_iDriver = open(MEM_DRIVER, O_RDONLY);
+ if (m_iDriver > 0) { //increment instance counter
+ m_iCount++;
+ } else { //couldn't open the driver...so make it zero again
+ m_iDriver = 0;
+ }
+ } else { //handle exists...so inc instance counter.
+ m_iCount++;
+ }
+ if (m_iDriver > 0) rv = 0;
+ return(rv);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// CloseIMemoryInterface
+// Name: destructor
+// Purpose: close driver handle and null out field
+// Context:
+// Returns:
+// Parameters: none
+// Notes:
+///////////////////////////////////////////////////////////////////////////////
+int CloseIMemoryInterface(void)
+{
+ int rv = 0;
+ //check if an instance has been created by looking at the counter
+ if (!m_iCount) {
+ m_iCount--; //decrement instance counter
+ if (m_iCount == 0) {
+ close(m_iDriver);
+ m_iDriver = 0; //and null it out
+ }
+ }
+ return(rv);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// MapPhysicalMemory
+///////////////////////////////////////////////////////////////////////////////
+// Name: MapPhysicalMemory
+// Purpose: given the starting address and size, the virtualize
+// memory is mapped.
+// Returns: True if success
+// Parameters: [IN] tdStartAddress = physical address to map
+// [IN] ulSize = number of bytes to map
+// [OUT] ptdVirtualAddress = ptr to virtual address
+///////////////////////////////////////////////////////////////////////////////
+BOOL MapPhysicalMemory(ULONG tdStartAddress,
+ ULONG ulSize,
+ ULONG* ptdVirtualAddress)
+{
+ long tdVirtualAddr = 0;
+ ULONG ulDiff;
+ //check if we have a valid driver handle
+ if (!m_iDriver) return FALSE; //error
+ //check for valid input params
+ if (!tdStartAddress || !ulSize) return FALSE; //error
+ //align the offset to a valid page boundary and adust its length
+ ulDiff = (ULONG)(tdStartAddress % EXEC_PAGESIZE);
+ if (fsm_debug) printf("MapPhys: tdStart=%lx, page=%x, diff=%lx\n",
+ tdStartAddress,EXEC_PAGESIZE,ulDiff);
+ tdStartAddress -= ulDiff;
+ ulSize += ulDiff;
+ tdVirtualAddr = (long)mmap((caddr_t)0,
+ (size_t)ulSize,
+ PROT_READ,
+ MAP_SHARED,
+ m_iDriver,
+ (off_t)tdStartAddress);
+ if (fsm_debug) printf("MapPhys: mmap(tdStart=%lx,size=%lx) = %lx\n",
+ tdStartAddress,ulSize,tdVirtualAddr);
+ if (tdVirtualAddr == -1)
+ return FALSE;
+ *ptdVirtualAddress = tdVirtualAddr + ulDiff;
+ return TRUE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// UnMapPhysicalMemory
+///////////////////////////////////////////////////////////////////////////////
+// Name: UnMapPhysicalMemory
+// Purpose: given the virtual address, unmaps it...frees memory.
+// Returns: True if success
+// Parameters: [IN] tdVirtualAddress = virtual address to unmap
+// [IN] ulSize = not needed for windows
+// Notes: none
+///////////////////////////////////////////////////////////////////////////////
+BOOL UnMapPhysicalMemory(ULONG tdVirtualAddress,
+ ULONG ulSize)
+{
+ ULONG ulDiff = 0;
+ ulDiff = (ULONG)(tdVirtualAddress % EXEC_PAGESIZE);
+ tdVirtualAddress -= ulDiff;
+ ulSize += ulDiff;
+ if (munmap((void *)tdVirtualAddress,ulSize) != 0) return FALSE;
+ return TRUE;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// getSmBiosTables
+// Purpose: returns smbios tables pointer
+// Returns: pointer to the virtual address where SMBIOS tables begins
+//////////////////////////////////////////////////////////////////////////////
+int getSmBiosTables(UCHAR **ptableAddress)
+{
+ ULONG tdStartAddress = DOS_MEM_RANGE_BASE;
+ ULONG ulSize = DOS_NUM_BYTES_TO_MAP;
+ ULONG ulSmBiosLen = 0;
+ ULONG tdVirtualAddress = 0;
+ int iInc;
+ UCHAR *pSmBios = NULL;
+ UCHAR ucCheckSum = 0;
+ UCHAR ucVal, ucVal1;
+ int rv;
+
+ if (fsm_debug) printf("getSmBiosTables start\n");
+ //get interface to Memory
+ rv = OpenIMemoryInterface();
+ if (fsm_debug) printf("OpenIMemoryInterface rv = %d\n",rv);
+
+ //map memory into user space
+ if ((rv != 0) ||
+ !MapPhysicalMemory(tdStartAddress,ulSize,&tdVirtualAddress))
+ {
+#ifdef SOLARIS
+ /* mmap always fails on Solaris, so skip the error message,
+ * unless in debug mode. */
+ if (fsm_debug)
+#endif
+ fprintf(stderr, "Cannot map memory.\n");
+ return ulSmBiosLen; /*==0*/
+ }
+
+ //now find the entry point for smbios
+ for(iInc=0; iInc < (long)ulSize; iInc+=sizeof(int) )
+ {
+ if (!memcmp((UCHAR *)(tdVirtualAddress+iInc),SMBIOS_STRING,sizeof(int)))
+ {
+ //cast entry point to a byte pointer
+ pSmBios = (UCHAR *)(tdVirtualAddress+iInc);
+ break;
+ }
+ }
+
+ if (pSmBios == NULL)
+ {
+ fprintf(stderr, "Can't find SMBIOS address entry point.\n");
+ UnMapPhysicalMemory(tdVirtualAddress,ulSize);
+ return ulSmBiosLen;
+ }
+
+ if (fsm_debug) {
+ printf("Found pSmBios=%p tdV=%lx, inc=%x\n",pSmBios,
+ tdVirtualAddress,iInc);
+ // dump_buf("SMBIOS",pSmBios,64,1);
+ }
+ //now sum up the bytes in the table for checksum checking
+ for(iInc=0; iInc<pSmBios[SMBIOS_TABLE_LENGTH_OFFSET]; iInc++)
+ ucCheckSum += pSmBios[iInc];
+
+ if (ucCheckSum)
+ {
+ UnMapPhysicalMemory(tdVirtualAddress,ulSize);
+ fprintf(stderr, "_SM_ Checksum != 0.\n");
+ return ulSmBiosLen;
+ }
+
+ //save smbios revision for future calls...bcd format
+ s_iTableRev = (pSmBios[SMBIOS_MAJOR_REV_OFFSET]<<NIBBLE_SIZE) | pSmBios[SMBIOS_MINOR_REV_OFFSET];
+
+ //find smbios table entry point and size of tables
+ memcpy(&tdStartAddress,&pSmBios[SMBIOS_TABLE_ENTRY_POINT_OFFSET],4);
+ //sizeof(ULONG));
+ memcpy(&ulSmBiosLen,&pSmBios[SMBIOS_TABLE_SIZE_OFFSET],sizeof(USHORT));
+ memcpy(&ucVal,&pSmBios[SMBIOS_TABLE_SIZE_OFFSET],sizeof(UCHAR));
+ memcpy(&ucVal1,&pSmBios[SMBIOS_TABLE_SIZE_OFFSET+1],sizeof(UCHAR));
+
+
+ //unmap physical memory (f0000-ffffe)
+ UnMapPhysicalMemory(tdVirtualAddress,ulSize);
+
+ if (!MapPhysicalMemory(tdStartAddress,ulSmBiosLen,&tdVirtualAddress)) {
+#ifdef SOLARIS
+ /* mmap always fails on Solaris, so skip the error message,
+ * unless in debug mode. */
+ if (fsm_debug)
+#endif
+ fprintf(stderr, "Cannot map memory.\n");
+ return 0;
+ }
+
+ if (fsm_debug) {
+ printf("MapMemory(%lx,%lx) ok = %lx\n",tdStartAddress,
+ ulSmBiosLen,tdVirtualAddress);
+ // dump_buf("Table",(UCHAR *)tdVirtualAddress,256,1);
+ }
+ //set size_t smbios tables starting address to ptr
+ *ptableAddress = (UCHAR*)tdVirtualAddress;
+
+ //Not doing this since the map is needed
+ // UnMapPhysicalMemory(tdVirtualAddress,ulSmBiosLen);
+ // rv = CloseIMemoryInterface();
+ return ulSmBiosLen;
+}
+
+int closeSmBios(UCHAR *ptableAddress, ULONG ulSmBiosLen)
+{
+ int rv;
+ UnMapPhysicalMemory((size_t)ptableAddress,ulSmBiosLen);
+ rv = CloseIMemoryInterface();
+ return(rv);
+}
+#endif // Linux (not WIN32)
+
+#ifdef WIN32
+extern "C" {
+#endif
+///////////////////////////////////////////////////////////////////////////////
+// getSmBiosRev
+// return the revision of smbios...in bcd format
+// Integer
+///////////////////////////////////////////////////////////////////////////////
+int getSmBiosRev()
+{
+ return s_iTableRev;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// get_IpmiStruct
+//////////////////////////////////////////////////////////////////////////////
+// Name: get_IpmiStruct
+// Purpose: find Type 38 record to get the IPMI Version.
+// Returns: 0 for success, or -1 if not found.
+// if success, all 4 parameters will have valid data
+//////////////////////////////////////////////////////////////////////////////
+int get_IpmiStruct(UCHAR *iftype, UCHAR *ver, UCHAR *sa, int *base, UCHAR *inc)
+{
+ UCHAR *VirtualAddress;
+ ULONG SMBiosLen = 0;
+ int length, j, i;
+ UCHAR Type;
+ int rv = -1;
+
+ SMBiosLen = getSmBiosTables( &VirtualAddress);
+ if ((SMBiosLen == 0) || !VirtualAddress) return rv;
+
+ for(i=0; i<(int)SMBiosLen; )
+ {
+ Type = VirtualAddress[i];
+ length = (int)VirtualAddress[i+1];
+
+ if (Type == 127) //end of table record
+ break;
+ else if (Type == 38) //Found the IPMI Device Information record
+ {
+ if (fsm_debug) {
+ int j;
+ printf("IPMI record: ");
+ for (j = i; j < i+length; j++)
+ printf("%02x ",VirtualAddress[j]);
+ printf("\n");
+ }
+ /*
+ * Byte 05h is the IPMI version as X.Y
+ * where X is bits 7:4 and Y bits 3:0
+ *
+ * KCS Iv sa nv base_addr
+ * 26 12 01 00 01 20 20 ff a3 0c 00 00 00 00 00 00 00 00
+ * IPMI 2.0 KCS, sa=0x20 Base=0x0ca2, spacing=1
+ * 26 12 73 00 01 20 20 ff a9 0c 00 00 00 00 00 00 40 00
+ * IPMI 2.0 KCS, sa=0x20 Base=0x0ca8, spacing=4
+ * 26 10 44 00 04 15 84 01 01 04 00 00 00 00 00 00
+ * IPMI v1.5 SMBus sa=0x42, base=0x0000000401
+ */
+ *iftype = VirtualAddress[i+4];
+ *ver = VirtualAddress[i+5];
+ *sa = VirtualAddress[i+6];
+ j = VirtualAddress[i+8] +
+ (VirtualAddress[i+9] << 8) +
+ (VirtualAddress[i+10] << 16) +
+ (VirtualAddress[i+11] << 24);
+ /*if odd, then subtract 1 from base addr*/
+ if (j & 0x01) j -= 1;
+ *base = j;
+ /* detect Register Spacing */
+ *inc = 1; /*default*/
+ if ((*iftype != 0x04) && (length >= 18)) {
+ switch(VirtualAddress[i+16] >>6) {
+ case 0x00: *inc = 1; break; /* 1-byte bound*/
+ case 0x01: *inc = 4; break; /* 4-byte bound*/
+ case 0x02: *inc = 16; break; /*16-byte bound*/
+ default: break; /**inc = 1; above*/
+ }
+ }
+ rv = 0;
+ break;
+ }
+
+ //Skip this record and go to the end of it.
+ for (j = i+length; j < (int)SMBiosLen; j++) {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j+1] == 0x00) {
+ i = j+2;
+ break;
+ }
+ }
+ }
+ closeSmBios(VirtualAddress,SMBiosLen);
+ return rv;
+} //getIPMI_struct
+
+///////////////////////////////////////////////////////////////////////////////
+// get_MemDesc
+//////////////////////////////////////////////////////////////////////////////
+// Name: get_MemDesc
+// Purpose: find Type 17 record to get the Memory Locator Description
+// Returns: 0 for success, or -1 if not found.
+// if success, the desc string will have valid data
+//////////////////////////////////////////////////////////////////////////////
+int get_MemDesc(UCHAR array, UCHAR dimm, char *desc, int *psize)
+{
+ UCHAR *VirtualAddress;
+ ULONG SMBiosLen = 0;
+ int length, j, i;
+ int iarray, idimm;
+ UCHAR Type;
+ int rv = -1;
+ char dimmstr[32];
+ char bankstr[32];
+
+ SMBiosLen = getSmBiosTables( &VirtualAddress);
+ if ((SMBiosLen == 0) || !VirtualAddress) return rv;
+ if (desc == NULL) return(-1);
+ bankstr[0] = 0;
+ dimmstr[0] = 0;
+
+ if (fsm_debug) printf("get_MemDesc(%d,%d)\n",array,dimm);
+ iarray = 0;
+ idimm = 0;
+ for(i=0; i<(int)SMBiosLen; )
+ {
+ Type = VirtualAddress[i];
+ length = (int)VirtualAddress[i+1];
+
+ if (Type == 127) //end of table record
+ break;
+ else if (Type == 16) //Found a Memory Array */
+ {
+ /* usually only one onboard memory array */
+ if (array == iarray) ; /*match*/
+ else iarray++;
+ }
+ else if (Type == 17) //Found a Memory Device */
+ {
+ int bank, k, n, nStr, nBLoc, sz;
+ if (dimm == idimm)
+ {
+ if (fsm_debug) {
+ printf("Memory record %d.%d: ",iarray,idimm);
+ for (j = i; j < (i+length+16); j++) {
+ if (((j-i) % 16) == 0) printf("\n");
+ printf("%02x ",VirtualAddress[j]);
+ }
+ printf("\n");
+ }
+ /*
+ * Memory Device record
+ * walk through strings to find Locator
+ */
+ sz = VirtualAddress[i+12] + (VirtualAddress[i+13] << 8); /*Size*/
+ bank = VirtualAddress[i+15]; /*Set*/
+ nStr = VirtualAddress[i+16]; /*Locator string num*/
+ nBLoc = VirtualAddress[i+17]; /*BankLocator string num*/
+ if (fsm_debug)
+ printf("bank=%d nStr=%d sz=%x\n",bank,nStr,sz);
+ k = i + length; /*hdr len (usu 0x1B)*/
+ n = 1; /* string number index */
+ for (j = k; j < (int)SMBiosLen; j++) {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j-1] == 0x00) break;
+ else if (VirtualAddress[j] == 0x00) {
+ if (fsm_debug) printf("str[%d] = %s\n",
+ n,&VirtualAddress[k]);
+ if (n == nBLoc) { /*bank string*/
+ strcpy(bankstr,(char *)&VirtualAddress[k]);
+ break; /*string number*/
+ }
+ if (n == nStr) {
+ strcpy(dimmstr,(char *)&VirtualAddress[k]);
+ }
+ n++; k = j + 1;
+ }
+ }
+ if ((desc != NULL) && (j < (int)SMBiosLen)) {
+ sprintf(desc,"%s/%s",bankstr,dimmstr);
+ rv = 0;
+ } else { /* have header, but not string */
+ char b;
+ if ((idimm % 2) == 0) b = 'A';
+ else b = 'B';
+ sprintf(desc,"DIMM%d%c",bank,b);
+ rv = 0;
+ }
+ *psize = sz;
+ break;
+ } else idimm++; /*else go to next dimm*/
+ }
+
+ //Skip this record and go to the end of it.
+ for (j = i+length; j < (int)SMBiosLen; j++) {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j+1] == 0x00) {
+ i = j+2;
+ break;
+ }
+ }
+ }
+ closeSmBios(VirtualAddress,SMBiosLen);
+ /* fill in a default if error */
+ if ((rv != 0) && (desc != NULL)) sprintf(desc,"DIMM[%d]",dimm);
+ return rv;
+} //get_MemDesc
+
+///////////////////////////////////////////////////////////////////////////////
+// get_BiosVersion
+//////////////////////////////////////////////////////////////////////////////
+// Name: get_BiosVersion
+// Purpose: finds Type 0 record and gets the BIOS ID string
+// Returns: -1 if not found and 0 if found. Param contains the string
+//////////////////////////////////////////////////////////////////////////////
+int get_BiosVersion(char *bios_str)
+{
+#define BIOS_VERSION 0x05 //Specifies string number of BIOS Ver string
+ UCHAR *VirtualAddress;
+ ULONG SMBiosLen = 0;
+ int recLength, j, i, k = 0, str_num;
+ UCHAR recType;
+ int rv = -1;
+
+ SMBiosLen = getSmBiosTables( &VirtualAddress);
+ if ((SMBiosLen == 0) || !VirtualAddress) return rv;
+ i=0;
+ while (i<(int)SMBiosLen)
+ {
+ recType = VirtualAddress[i];
+ recLength = (int)VirtualAddress[i+1];
+
+ // end of table record, error
+ if (recType == 127) return -1;
+ else if (recType == 0)
+ { // BIOS Information (Type 0) record found
+ //Set index j to the end of the formated part of record.
+ j = i + recLength;
+
+ //First grab string number of the BIOS Version string
+ //This non-zero number specifies which string at the end
+ //of the record is the BIOS Version string.
+ str_num = VirtualAddress[i + BIOS_VERSION];
+
+ //Now skip over strings at the end of the record till we
+ //get to the BIOS Version string
+ for (str_num--;str_num > 0; str_num--)
+ {
+ //Skipping over one string at a time
+ for (; VirtualAddress[j] != 0x00; j++);
+ j++; //Advance index past EOS.
+ }
+
+ //Copy the BIOS Version string into buffer from caller.
+ for (; VirtualAddress[j] != 0x00; j++)
+ {
+ bios_str[k++] = VirtualAddress[j];
+ }
+ bios_str[k] = '\0';
+ rv = 0;
+ break; /*exit while loop*/
+ } else {
+ //Not a Type 0, so skip to the end of this structure
+ for (j = i+recLength; j < (int)SMBiosLen; j++)
+ {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j+1] == 0x00)
+ {
+ i = j+2;
+ break;
+ }
+ }
+ }
+ } /*end while*/
+ closeSmBios(VirtualAddress,SMBiosLen);
+ return rv;
+}
+
+int get_ChassisSernum(char *chs_str, char fdbg)
+{
+#define CHASSIS_SERNUM 0x07 //Specifies string number of BIOS Ver string
+ UCHAR *VirtualAddress;
+ ULONG SMBiosLen = 0;
+ int recLength, j, i, k = 0, str_num;
+ UCHAR recType;
+ int rv = -1;
+
+ SMBiosLen = getSmBiosTables( &VirtualAddress);
+ if ((SMBiosLen == 0) || !VirtualAddress) return rv;
+ i=0;
+ while (i<(int)SMBiosLen)
+ {
+ recType = VirtualAddress[i];
+ recLength = (int)VirtualAddress[i+1];
+ if (recType == 127) return -1; // end of table record, error
+ else if (recType == 3)
+ { // Chassis Information (Type 3) record found
+ j = i + recLength;
+ str_num = VirtualAddress[i + CHASSIS_SERNUM];
+ for (str_num--;str_num > 0; str_num--)
+ {
+ for (; VirtualAddress[j] != 0x00; j++);
+ j++;
+ }
+ for (; VirtualAddress[j] != 0x00; j++)
+ { chs_str[k++] = VirtualAddress[j]; }
+ chs_str[k] = '\0';
+ /* also copy Chassis Manuf */
+ j = i + recLength;
+ memcpy(&chs_str[k+1],&VirtualAddress[j],20);
+ rv = 0;
+ break; /*exit while loop*/
+ } else {
+ //Not a Type 0, so skip to the end of this structure
+ for (j = i+recLength; j < (int)SMBiosLen; j++)
+ {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j+1] == 0x00)
+ {
+ i = j+2;
+ break;
+ }
+ }
+ }
+ } /*end while*/
+ closeSmBios(VirtualAddress,SMBiosLen);
+ return rv;
+}
+
+int get_SystemGuid(UCHAR *guid)
+{
+ UCHAR *VirtualAddress;
+ ULONG SMBiosLen = 0;
+ int recLength, i, j, n, k = 0;
+ UCHAR recType;
+ int rv = -1;
+
+ SMBiosLen = getSmBiosTables( &VirtualAddress);
+ if ((SMBiosLen == 0) || !VirtualAddress) return rv;
+ i=0;
+ while (i<(int)SMBiosLen)
+ {
+ recType = VirtualAddress[i];
+ recLength = (int)VirtualAddress[i+1];
+
+ // end of table record, error
+ if (recType == 127) return -1;
+ else if (recType == 1)
+ { // System Board Information (Type 1) record found
+ //Set index j to the end of the formated part of record.
+ j = i + recLength;
+ n = i + 8; /*UUID offset 8*/
+ //Copy the UUID string into buffer from caller.
+ for (k = 0; k < 16; k++)
+ {
+ guid[k] = VirtualAddress[n + k];
+ }
+ rv = 0;
+ break; /*exit while loop*/
+ } else {
+ //else skip to the end of this structure
+ for (j = i+recLength; j < (int)SMBiosLen; j++)
+ {
+ if (VirtualAddress[j] == 0x00 &&
+ VirtualAddress[j+1] == 0x00)
+ {
+ i = j+2;
+ break;
+ }
+ }
+ }
+ } /*end while*/
+ closeSmBios(VirtualAddress,SMBiosLen);
+ return rv;
+}
+#ifdef WIN32
+}
+#endif
+
+
+#ifdef COMP_BIN
+int
+main(int argc, char **argv)
+{
+ char biosver[80];
+ UCHAR ifs,ver,sa,inc;
+ int rv;
+ int base;
+
+ biosver[0] = 0;
+ rv = get_BiosVersion(biosver);
+ printf("get_BiosVersion rv=%d Ver=%s\n",rv,biosver);
+
+ rv = get_IpmiStruct( &ifs, &ver, &sa, &base, &inc);
+ printf("get_IpmiStruct rv=%d if=%02x ver=%02x sa=%02x base=%x, spacing=%d\n",
+ rv, ifs,ver,sa,base,inc);
+
+ rv = get_SystemGuid(biosver);
+ printf("get_SystemGuid rv=%d Ver=%s\n",rv,biosver);
+ // exit(rv);
+ return(rv);
+}
+#endif
+
+/* end mem_if.c */
diff --git a/util/mem_if_cpp.cpp b/util/mem_if_cpp.cpp
new file mode 100644
index 0000000..19468f2
--- /dev/null
+++ b/util/mem_if_cpp.cpp
@@ -0,0 +1,5 @@
+// mem_if_cpp.cpp
+// Include the actual mem_if source into this .cpp file.
+// This is a wrapper for build.exe to detect its type as C++.
+//
+#include "mem_if.c"
diff --git a/util/oem_dell.c b/util/oem_dell.c
new file mode 100644
index 0000000..1911d96
--- /dev/null
+++ b/util/oem_dell.c
@@ -0,0 +1,6095 @@
+/*
+ * oem_dell.c
+ * Handle Dell OEM command functions
+ *
+ * Change history:
+ * 08/17/2011 ARCress - included in ipmiutil source tree
+ *
+ */
+/******************************************************************
+Copyright (c) 2008, Dell Inc
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Dell Inc nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+******************************************************************/
+/*
+* Thursday Oct 7 17:30:12 2009
+* <deepaganesh_paulraj@dell.com>
+*
+* This code implements a dell OEM proprietary commands.
+* This Code is edited and Implemented the License feature for Delloem
+* Author Harsha S <Harsha_S1@dell.com>
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#define int8_t char
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+#define uint64_t unsigned long
+#include "getopt.h"
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <ctype.h>
+#include <limits.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <stdint.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+
+#include <time.h>
+#include "ipmicmd.h"
+#include "isensor.h"
+#include "ievents.h"
+#include "oem_dell.h"
+
+// #ifdef METACOMMAND is assumed
+extern int i_sol(int argc, char **argv); /*isol.c*/
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+extern void set_loglevel(int level);
+extern void printbuf(const uint8_t * buf, int len, const char * desc);
+
+#define IPMI_DELL_OEM_NETFN (uint8_t)(0x30)
+#define GET_CHASSIS_LED_STATE (uint8_t)(0x32)
+#define GET_IDRAC_VIRTUAL_MAC (uint8_t)(0xC9)
+// 11g Support Macros
+#define INVALID -1
+#define SHARED 0
+#define SHARED_WITH_FAILOVER_LOM2 1
+#define DEDICATED 2
+#define SHARED_WITH_FAILOVER_ALL_LOMS 3
+char ActiveLOM_String[6][10] = {"None","LOM1","LOM2","LOM3","LOM4","dedicated"};
+#define INVAILD_FAILOVER_MODE -2
+#define INVAILD_FAILOVER_MODE_SETTINGS -3
+#define INVAILD_SHARED_MODE -4
+
+#define INVAILD_FAILOVER_MODE_STRING "ERROR: Cannot set shared with failover lom same as current shared lom.\n"
+#define INVAILD_FAILOVER_MODE_SET "ERROR: Cannot set shared with failover loms when NIC is set to dedicated Mode.\n"
+#define INVAILD_SHARED_MODE_SET_STRING "ERROR: Cannot set shared Mode for Blades.\n"
+
+// 11g Support Strings for nic selection
+char NIC_Selection_Mode_String [4] [50] = { "shared",
+ "shared with failover lom2",
+ "dedicated",
+ "shared with Failover all loms"
+ };
+
+// 11g Support Macros (dups)
+//#define SHARED 0
+//#define SHARED_WITH_FAILOVER_LOM2 1
+//#define DEDICATED 2
+//#define SHARED_WITH_FAILOVER_ALL_LOMS 3
+
+// 12g Support Strings for nic selection
+char NIC_Selection_Mode_String_12g[] [50] = {
+ "dedicated",
+ "shared with lom1",
+ "shared with lom2",
+ "shared with lom3",
+ "shared with lom4",
+ "shared with failover lom1",
+ "shared with failover lom2",
+ "shared with failover lom3",
+ "shared with failover lom4",
+ "shared with failover all loms"
+ };
+
+static char * progver = "2.93";
+static char * progname = "idelloem";
+static int verbose = 0;
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static uchar *sdrcache = NULL;
+static char *sdrfile = NULL;
+static int argc_sav;
+static char **argv_sav;
+static int current_arg =0;
+uint8_t iDRAC_FLAG=0;
+LCD_MODE lcd_mode;
+static uint8_t LcdSupported=0;
+static uint8_t SetLEDSupported=0;
+
+volatile uint8_t IMC_Type = IMC_IDRAC_10G;
+
+
+const struct vFlashstr vFlash_completion_code_vals[] = {
+ {0x00, "SUCCESS"},
+ {0x01, "NO_SD_CARD"},
+ {0x63, "UNKNOWN_ERROR"},
+ {0x00, NULL}
+};
+
+
+POWER_HEADROOM powerheadroom;
+
+uint8_t PowercapSetable_flag=0;
+uint8_t PowercapstatusFlag=0;
+
+static void usage(void);
+
+/* LCD Function prototypes */
+static int ipmi_delloem_lcd_main (void * intf, int argc, char ** argv);
+static int ipmi_lcd_get_platform_model_name (void * intf,char* lcdstring,
+ uint8_t max_length,uint8_t field_type);
+static int ipmi_idracvalidator_command (void * intf);
+static int ipmi_lcd_get_configure_command_wh (void * intf);
+static int ipmi_lcd_get_configure_command (void * intf,uint8_t *command);
+static int ipmi_lcd_set_configure_command (void * intf, int command);
+static int ipmi_lcd_set_configure_command_wh (void * intf, uint32_t mode,
+ uint16_t lcdqualifier,uint8_t errordisp);
+static int ipmi_lcd_get_single_line_text (void * intf, char* lcdstring, uint8_t max_length);
+static int ipmi_lcd_get_info_wh(void * intf);
+static int ipmi_lcd_get_info(void * intf);
+static int ipmi_lcd_get_status_val(void * intf, LCD_STATUS* lcdstatus);
+static int IsLCDSupported ();
+static void CheckLCDSupport(void * intf);
+static void ipmi_lcd_status_print( LCD_STATUS lcdstatus);
+static int ipmi_lcd_get_status(void * intf );
+static int ipmi_lcd_set_kvm(void * intf, char status);
+static int ipmi_lcd_set_lock(void * intf, char lock);
+static int ipmi_lcd_set_single_line_text (void * intf, char * text);
+static int ipmi_lcd_set_text(void * intf, char * text, int line_number);
+static int ipmi_lcd_configure_wh (void * intf, uint32_t mode ,
+ uint16_t lcdqualifier, uint8_t errordisp,
+ int8_t line_number, char * text);
+static int ipmi_lcd_configure (void * intf, int command,
+ int8_t line_number, char * text);
+static void ipmi_lcd_usage(void);
+
+/* MAC Function prototypes */
+static int ipmi_delloem_mac_main (void * intf, int argc, char ** argv);
+static int make_int(const char *str, int *value);
+static void InitEmbeddedNICMacAddressValues ();
+static int ipmi_macinfo_drac_idrac_virtual_mac(void* intf,uint8_t NicNum);
+static int ipmi_macinfo_drac_idrac_mac(void* intf,uint8_t NicNum);
+static int ipmi_macinfo_10g (void* intf, uint8_t NicNum);
+static int ipmi_macinfo_11g (void* intf, uint8_t NicNum);
+static int ipmi_macinfo (void* intf, uint8_t NicNum);
+static void ipmi_mac_usage(void);
+
+/* LAN Function prototypes */
+static int ipmi_delloem_lan_main (void * intf, int argc, char ** argv);
+static int IsLANSupported ();
+static int get_nic_selection_mode (int current_arg, char ** argv);
+static int ipmi_lan_set_nic_selection (void* intf, uint8_t nic_selection);
+static int ipmi_lan_get_nic_selection (void* intf);
+static int get_nic_selection_mode_12g (void* intf,int iarg, char **argv, char *nic_set);
+static int ipmi_lan_get_active_nic (void* intf);
+static void ipmi_lan_usage(void);
+static int ipmi_lan_set_nic_selection_12g (void* intf, uint8_t* nic_selection);
+
+/* POwer monitor Function prototypes */
+static int ipmi_delloem_powermonitor_main (void * intf, int argc, char **argv);
+static void ipmi_time_to_str(time_t rawTime, char* strTime);
+static int ipmi_get_power_capstatus_command (void * intf);
+static int ipmi_set_power_capstatus_command (void * intf,uint8_t val);
+static int ipmi_powermgmt(void* intf);
+static int ipmi_powermgmt_clear(void* intf,uint8_t clearValue);
+static uint64_t watt_to_btuphr_conversion(uint32_t powerinwatt);
+static uint32_t btuphr_to_watt_conversion(uint64_t powerinbtuphr);
+static int ipmi_get_power_headroom_command (void * intf,uint8_t unit);
+static int ipmi_get_power_consumption_data(void* intf,uint8_t unit);
+static int ipmi_get_instan_power_consmpt_data(void* intf,
+ IPMI_INST_POWER_CONSUMPTION_DATA* instpowerconsumptiondata);
+static void ipmi_print_get_instan_power_Amps_data(IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata);
+static int ipmi_print_get_power_consmpt_data(void* intf,uint8_t unit);
+static int ipmi_get_avgpower_consmpt_history(void* intf,IPMI_AVGPOWER_CONSUMP_HISTORY* pavgpower );
+static int ipmi_get_peakpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstPeakpower);
+static int ipmi_get_minpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstMinpower);
+static int ipmi_print_power_consmpt_history(void* intf,int unit );
+static int ipmi_get_power_cap(void* intf,IPMI_POWER_CAP* ipmipowercap );
+static int ipmi_print_power_cap(void* intf,uint8_t unit );
+static int ipmi_set_power_cap(void* intf,int unit,int val );
+static void ipmi_powermonitor_usage(void);
+
+/* vFlash Function prototypes */
+static int ipmi_delloem_vFlash_main(void * intf, int argc, char ** argv);
+const char * get_vFlash_compcode_str(uint8_t vflashcompcode, const struct vFlashstr *vs);
+static int ipmi_get_sd_card_info(void* intf);
+static int ipmi_delloem_vFlash_process(void* intf, int current_arg, char ** argv);
+static void ipmi_vFlash_usage(void);
+
+
+/* windbg Function prototypes */
+volatile uint8_t windbgsession = 0;
+static int ipmi_delloem_windbg_main (void * intf, int argc, char ** argv);
+static int ipmi_windbg_start (void * intf);
+static int ipmi_windbg_end (void * intf);
+static void ipmi_windbg_usage (void);
+
+
+
+/* LED Function prototypes */
+
+static int ipmi_getsesmask(int, char **);
+static int CheckSetLEDSupport(void * intf);
+static int IsSetLEDSupported(void);
+static void ipmi_setled_usage(void);
+static int ipmi_delloem_setled_main(void *intf, int argc, char ** argv);
+static int ipmi_delloem_getled_main(void *intf, int argc, char ** argv);
+static int ipmi_setled_state (void * intf, int bayId, int slotId, int state);
+static int ipmi_getdrivemap (void * intf, int b, int d, int f, int *bayId, int *slotId);
+//extern int optind; /*from getopt*/
+
+static int ipmi_sol_activate(void *intf, int j, int k)
+{
+ char **args;
+ int rv, i, n;
+ int x = 0;
+ n = argc_sav;
+ args = argv_sav;
+ /* use the user-specified args, but switch to sol */
+ for (i = 0; i < n; i++) {
+ if (strcmp(args[i],"ipmiutil") == 0) { x = 1; }
+ else if (strcmp(args[i],"delloem") == 0) args[i] = "sol";
+ else if (strcmp(args[i],"windbg") == 0) args[i] = "-a";
+ else if (strcmp(args[i],"start") == 0) args[i] = "-a";
+ }
+ ipmi_close_();
+ if (x == 1) { args++; n--; }
+ optind = 0;
+ rv = i_sol(n, args);
+ return rv;
+}
+
+static int ipmi_sol_deactivate(void *intf)
+{
+ char **args;
+ int rv, i, n;
+ int x = 0;
+ n = argc_sav;
+ args = argv_sav;
+ /* use the user-specified args, but switch to sol */
+ for (i = 0; i < n; i++) {
+ if (strcmp(args[i],"ipmiutil") == 0) { x = 1; }
+ else if (strcmp(args[i],"delloem") == 0) args[i] = "sol";
+ else if (strcmp(args[i],"windbg") == 0) args[i] = "-d";
+ else if (strcmp(args[i],"end") == 0) args[i] = "-d";
+ }
+ ipmi_close_();
+ if (x == 1) { args++; n--; }
+ optind = 0;
+ rv = i_sol(n, args);
+ return rv;
+}
+
+static int sysinfo_param(const char *str) {
+ // SysInfo Parameters
+ // 1 = system firmware version
+ // 2 = system hostname
+ // 3 = primary operating system name (non-volatile)
+ // 4 = operating system name (volatile)
+ // 0xe3 = dell: os version
+ // 0xde = dell: url
+ if (!strcmp(str, "system_name")) return 0x02;
+ if (!strcmp(str, "primary_os_name")) return 0x03;
+ if (!strcmp(str, "os_name")) return 0x04;
+ if (!strcmp(str, "dell_os_version")) return 0xe4;
+ if (!strcmp(str, "dell_url")) return 0xde;
+ return strtoul(str, 0, 16);
+}
+
+static void ipmi_sysinfo_usage()
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " getsysinfo (os_name|primary_os_name|dell_os_version|dell_url)");
+ lprintf(LOG_NOTICE, " Retrieves system info from bmc for given argument");
+ lprintf(LOG_NOTICE, " setsysinfo (os_name|primary_os_name|dell_os_version|dell_url)");
+ lprintf(LOG_NOTICE, " Stores system Info for given argument to bmc");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " primary_os_name = primary operating system name");
+ lprintf(LOG_NOTICE, " os_name = secondary operating system name");
+ lprintf(LOG_NOTICE, " system_name = system hostname of server");
+ lprintf(LOG_NOTICE, " dell_os_version = running version of operating system (Dell)");
+ lprintf(LOG_NOTICE, " dell_url = url of bmc webserver (Dell)");
+
+ lprintf(LOG_NOTICE, "");
+}
+
+static int
+ipmi_delloem_sysinfo_main(void * intf, int argc, char ** argv)
+{
+ int param, isset;
+ char *str;
+ unsigned char infostr[256], *pos;
+ int j, ret;
+
+ /* Is this a setsysinfo or getsysinfo */
+ isset = !strncmp(argv[current_arg], "setsysinfo\0",10);
+
+ current_arg++;
+ if (argc < current_arg) {
+ usage();
+ return -1;
+ }
+ if (argc == 1 || strcmp(argv[current_arg], "help") == 0 ||
+ argc < (isset ? current_arg+2 : current_arg+1)) {
+ ipmi_sysinfo_usage();
+ return 0;
+ }
+ memset(infostr, 0, sizeof(infostr));
+
+ param = sysinfo_param(argv[current_arg++]);
+
+ if (isset) {
+ str = argv[current_arg];
+ j = strlen_(str);
+ ret = set_system_info(param,str,j);
+ } else {
+ pos = infostr;
+ j = sizeof(infostr);
+ ret = get_system_info(param,infostr,&j);
+ printf("%s\n", infostr);
+ }
+ return ret;
+}
+
+static void ipmi_password_policy_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " passwordpolicy <on | off>");
+ lprintf(LOG_NOTICE, " Set the OEM Password Policy Check on or off");
+ lprintf(LOG_NOTICE, " This parameter is write-only");
+ lprintf(LOG_NOTICE, "");
+}
+
+static int
+ipmi_delloem_password_policy(void * intf, int argc, char ** argv)
+{
+ int rv = 0;
+ int rsp_len;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ uint8_t bval;
+
+
+ current_arg++;
+ if (argc < current_arg) {
+ usage();
+ return -1;
+ }
+
+ if (strcmp(argv[current_arg], "on") == 0) {
+ bval = 0x01;
+ } else if (strcmp(argv[current_arg], "off") == 0) {
+ bval = 0x00;
+ } else { /* other or "help" */
+ ipmi_password_policy_usage();
+ return 0;
+ }
+
+ printf("Setting OEM Password Policy Check to %s ...\n", argv[current_arg]);
+ req.msg.netfn = 0x30; /*Dell OEM netfn*/
+ req.msg.lun = 0;
+ req.msg.cmd = 0x51;
+ req.msg.data_len = 1;
+ req.msg.data = data;
+ data[0] = bval;
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting OEM password policy: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ }
+ if (rv == 0) printf("successful\n");
+ /* This works for DELL C6220 with firmware >= 1.23 */
+
+ return(rv);
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_main
+*
+* Description: This function processes the delloem command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+int
+ipmi_delloem_main(void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ // ipmi_idracvalidator_command(intf);
+ // CheckLCDSupport (intf);
+ // CheckSetLEDSupport (intf);
+
+ if (argc == 0 || strncmp(argv[0], "help\0", 5) == 0)
+ {
+ usage();
+ return 0;
+ }
+
+ if (0 ==strncmp(argv[current_arg], "lcd\0", 4) )
+ {
+ rc = ipmi_delloem_lcd_main (intf,argc,argv);
+ }
+ /* mac address*/
+ else if (strncmp(argv[current_arg], "mac\0", 4) == 0)
+ {
+ rc = ipmi_delloem_mac_main (intf,argc,argv);
+ }
+ /* lan address*/
+ else if (strncmp(argv[current_arg], "lan\0", 4) == 0)
+ {
+ rc = ipmi_delloem_lan_main (intf,argc,argv);
+ }
+ /* SetLED support */
+ else if (strncmp(argv[current_arg], "setled\0", 7) == 0)
+ {
+ rc = ipmi_delloem_setled_main (intf,argc,argv);
+ }
+ else if (strncmp(argv[current_arg], "getled\0", 13) == 0)
+ {
+ rc = ipmi_delloem_getled_main (intf,argc,argv);
+ }
+ else if (strncmp(argv[current_arg], "passwordpolicy\0", 14) == 0)
+ {
+ rc = ipmi_delloem_password_policy (intf,argc,argv);
+ }
+ /*Powermanagement report processing*/
+ else if (strncmp(argv[current_arg], "powermonitor\0", 13) == 0)
+ {
+ rc = ipmi_delloem_powermonitor_main (intf,argc,argv);
+ }
+ /* vFlash Support */
+ else if (strncmp(argv[current_arg], "vFlash\0", 7) == 0)
+ {
+ rc = ipmi_delloem_vFlash_main (intf,argc,argv);
+ }
+ else if (strncmp(argv[current_arg], "windbg\0", 7) == 0)
+ {
+ rc = ipmi_delloem_windbg_main (intf,argc,argv);
+ }
+ else if ((strncmp(argv[current_arg], "getsysinfo\0", 10) == 0) ||
+ (strncmp(argv[current_arg], "setsysinfo\0", 10) == 0))
+ {
+ rc = ipmi_delloem_sysinfo_main (intf,argc,argv);
+ }
+ else
+ {
+ usage();
+ return ERR_USAGE;
+ }
+ return rc;
+}
+
+/*****************************************************************
+* Function Name: usage
+*
+* Description: This function prints help message for delloem command
+* Input:
+* Output:
+*
+* Return:
+*
+******************************************************************/
+
+static void usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, "usage: delloem <command> [option...]");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, "commands:");
+ lprintf(LOG_NOTICE, " lcd");
+ lprintf(LOG_NOTICE, " mac");
+ lprintf(LOG_NOTICE, " lan");
+ lprintf(LOG_NOTICE, " setled");
+ lprintf(LOG_NOTICE, " getled");
+ lprintf(LOG_NOTICE, " powermonitor");
+ lprintf(LOG_NOTICE, " windbg");
+ lprintf(LOG_NOTICE, " vFlash");
+ lprintf(LOG_NOTICE, " getsysinfo");
+ lprintf(LOG_NOTICE, " setsysinfo");
+ lprintf(LOG_NOTICE, " passwordpolicy");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, "For help on individual commands type:");
+ lprintf(LOG_NOTICE, "delloem <command> help");
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_lcd_main
+*
+* Description: This function processes the delloem lcd command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_lcd_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ current_arg++;
+ if (argc < current_arg)
+ {
+ usage();
+ return -1;
+ }
+
+
+ /* ipmitool delloem lcd info*/
+ if (argc == 1 || strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_lcd_usage();
+ return 0;
+ }
+ CheckLCDSupport (intf);
+ ipmi_idracvalidator_command(intf);
+ if (!IsLCDSupported()) {
+ printf("lcd is not supported on this system.\n");
+ return -1;
+ }
+ else if (strncmp(argv[current_arg], "info\0", 5) == 0)
+ {
+ if((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) )
+ rc = ipmi_lcd_get_info_wh(intf);
+ else
+ rc = ipmi_lcd_get_info(intf);
+ }
+ else if (strncmp(argv[current_arg], "status\0", 7) == 0)
+ {
+ rc = ipmi_lcd_get_status(intf);
+ }
+ /* ipmitool delloem lcd set*/
+ else if (strncmp(argv[current_arg], "set\0", 4) == 0)
+ {
+ uint8_t line_number = 0;
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (strncmp(argv[current_arg], "line\0", 5) == 0)
+ {
+ current_arg++;
+ if (argc <= current_arg) {usage();return -1;}
+ line_number = (uint8_t)strtoul(argv[current_arg], NULL, 0);
+ current_arg++;
+ if (argc <= current_arg) {usage();return -1;}
+ }
+
+
+ if ((strncmp(argv[current_arg], "mode\0", 5) == 0)&&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) ))
+ {
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (strncmp(argv[current_arg], "none\0", 5) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_NONE,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "modelname\0", 10) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_DEFAULT,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "userdefined\0", 12) == 0)
+ {
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();return -1;
+ }
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_USER_DEFINED,0xFF,0XFF, line_number, argv[current_arg]);
+ }
+ else if (strncmp(argv[current_arg], "ipv4address\0", 12) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_iDRAC_IPV4ADRESS ,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "macaddress\0", 11) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_IDRAC_MAC_ADDRESS,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "systemname\0", 11) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_OS_SYSTEM_NAME,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "servicetag\0", 11) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_SERVICE_TAG, 0xFF,0XFF,0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "ipv6address\0", 12) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_iDRAC_IPV6ADRESS ,0xFF,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "ambienttemp\0", 12) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_AMBEINT_TEMP, 0xFF,0XFF,0, NULL);
+
+ }
+ else if (strncmp(argv[current_arg], "systemwatt\0", 11) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_SYSTEM_WATTS , 0xFF,0XFF,0, NULL);
+
+ }
+ else if (strncmp(argv[current_arg], "assettag\0", 9) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_ASSET_TAG , 0xFF,0XFF,0, NULL);
+
+ }
+ else if (strncmp(argv[current_arg], "help\0", 5) == 0)
+ {
+ ipmi_lcd_usage();
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ }
+ }
+ else if ((strncmp(argv[current_arg], "lcdqualifier\0", 13)== 0) &&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) ) )
+ {
+
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+
+ if (strncmp(argv[current_arg], "watt\0", 5) == 0) {
+
+
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0x00,0XFF, 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "btuphr\0",7) == 0) {
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0x01,0XFF, 0, NULL);
+
+ } else if (strncmp(argv[current_arg], "celsius\0", 8) == 0) {
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0x02,0xFF, 0, NULL);
+ } else if (strncmp(argv[current_arg], "fahrenheit", 11) == 0) {
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0x03,0xFF, 0, NULL);
+
+ }else if (strncmp(argv[current_arg], "help\0", 5) == 0) {
+ ipmi_lcd_usage();
+ }
+ else {
+ ipmi_lcd_usage();
+ }
+ }
+ else if( (strncmp(argv[current_arg], "errordisplay\0", 13) == 0)&&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) ))
+ {
+
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+
+ if (strncmp(argv[current_arg], "sel\0", 4) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0xFF,IPMI_DELL_LCD_ERROR_DISP_SEL , 0, NULL);
+ }
+ else if (strncmp(argv[current_arg], "simple\0", 7) == 0)
+ {
+ rc = ipmi_lcd_configure_wh (intf, 0xFF,0xFF,IPMI_DELL_LCD_ERROR_DISP_VERBOSE , 0, NULL);
+
+ }
+ else if (strncmp(argv[current_arg], "help\0", 5) == 0)
+ {
+ ipmi_lcd_usage();
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ }
+ }
+
+ else if ((strncmp(argv[current_arg], "none\0", 5) == 0)&&(iDRAC_FLAG==0))
+ {
+ rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_NONE, 0, NULL);
+ }
+ else if ((strncmp(argv[current_arg], "default\0", 8) == 0)&&(iDRAC_FLAG==0))
+ {
+ rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_DEFAULT, 0, NULL);
+
+ }
+ else if ((strncmp(argv[current_arg], "custom\0", 7) == 0)&&(iDRAC_FLAG==0))
+ {
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_USER_DEFINED, line_number, argv[current_arg]);
+ }
+
+ else if (strncmp(argv[current_arg], "vkvm\0", 5) == 0)
+ {
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+
+ if (strncmp(argv[current_arg], "active\0", 7) == 0)
+ {
+ rc = ipmi_lcd_set_kvm (intf, 1);
+ }
+ else if (strncmp(argv[current_arg], "inactive\0", 9)==0)
+ {
+ rc = ipmi_lcd_set_kvm (intf, 0);
+
+ }
+ else if (strncmp(argv[current_arg], "help\0", 5) == 0)
+ {
+ ipmi_lcd_usage();
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ }
+
+ }
+ else if (strncmp(argv[current_arg], "frontpanelaccess\0", 17) == 0)
+ {
+ current_arg++;
+ if (argc <= current_arg)
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ if (strncmp(argv[current_arg], "viewandmodify\0", 14) == 0)
+ {
+ rc = ipmi_lcd_set_lock (intf, 0);
+ }
+ else if (strncmp(argv[current_arg], "viewonly\0", 9)==0)
+ {
+ rc = ipmi_lcd_set_lock (intf, 1);
+
+ }
+ else if (strncmp(argv[current_arg], "disabled\0", 9)==0)
+ {
+ rc = ipmi_lcd_set_lock (intf, 2);
+
+ }
+ else if (strncmp(argv[current_arg], "help\0", 5) == 0)
+ {
+ ipmi_lcd_usage();
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ }
+
+ }
+ else if( (strncmp(argv[current_arg], "help\0", 5) == 0)&&(iDRAC_FLAG==0))
+ {
+ ipmi_lcd_usage();
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ }
+ else
+ {
+ ipmi_lcd_usage();
+ return -1;
+ }
+ return(rc);
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_platform_model_name
+*
+* Description: This function retrieves the platform model name, or any other parameter
+* which stores data in the same format
+* Input: intf - pointer to interface
+* max_length - length of the platform model string
+* field_type - either hostname / platform model
+* Output: lcdstring - hostname / platform model string
+*
+* Return:
+*
+******************************************************************/
+static int
+ipmi_lcd_get_platform_model_name (void * intf,
+ char* lcdstring,
+ uint8_t max_length,
+ uint8_t field_type)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ IPMI_DELL_LCD_STRING * lcdstringblock;
+ int lcdstring_len = 0;
+ int bytes_copied = 0;
+
+ int ii;
+
+ for (ii = 0; ii < 4; ii++)
+ {
+ int bytes_to_copy;
+ memset (&req,0,sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter*/
+ data[1] = field_type;
+ data[2] = ii;
+ data[3] = 0;
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting platform model name: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ lcdstringblock = (IPMI_DELL_LCD_STRING *) (void *) rsp;
+
+ /* first block is different - 14 bytes*/
+ if (0 == ii) {
+ lcdstring_len = lcdstringblock->lcd_string.selector_0_string.length;
+
+ lcdstring_len = MIN (lcdstring_len,max_length);
+
+ bytes_to_copy = MIN(lcdstring_len, IPMI_DELL_LCD_STRING1_SIZE);
+ memcpy (lcdstring, lcdstringblock->lcd_string.selector_0_string.data, bytes_to_copy);
+ } else {
+ int string_offset;
+
+ bytes_to_copy = MIN(lcdstring_len - bytes_copied, IPMI_DELL_LCD_STRINGN_SIZE);
+ if (bytes_to_copy < 1)
+ break;
+ string_offset = IPMI_DELL_LCD_STRING1_SIZE + IPMI_DELL_LCD_STRINGN_SIZE * (ii-1);
+ memcpy (lcdstring+string_offset, lcdstringblock->lcd_string.selector_n_data, bytes_to_copy);
+ }
+
+
+ bytes_copied += bytes_to_copy;
+
+ if (bytes_copied >= lcdstring_len)
+
+ break;
+ }
+ return rv;
+}
+
+/*****************************************************************
+* Function Name: ipmi_idracvalidator_command
+*
+* Description: This function returns the iDRAC6 type
+* Input: intf - ipmi interface
+* Output:
+*
+* Return: iDRAC6 type 1 - whoville
+* 0 - others
+*
+******************************************************************/
+
+static int
+ipmi_idracvalidator_command (void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ memset (&req,0,sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = IPMI_DELL_IDRAC_VALIDATOR;
+ data[2] = 2;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv && fdebug) {
+ printf(" Error getting IMC type");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+ IMC_Type = rsp[10];
+ if( (IMC_Type == IMC_IDRAC_11G_MONOLITHIC) || (IMC_Type == IMC_IDRAC_11G_MODULAR) )
+ {
+ iDRAC_FLAG=IDRAC_11G;
+ }
+ else if( (IMC_Type == IMC_IDRAC_12G_MONOLITHIC) || (IMC_Type == IMC_IDRAC_12G_MODULAR) )
+ {
+ iDRAC_FLAG=IDRAC_12G;
+ }
+ else
+ {
+ iDRAC_FLAG=0;
+ }
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_configure_command_wh
+*
+* Description: This function returns current lcd configuration for Dell OEM LCD command
+* Input: intf - ipmi interface
+* Global: lcd_mode - lcd mode setting
+* Output:
+*
+* Return: returns the current lcd configuration
+* 0 = User defined
+* 1 = Default
+* 2 = None
+*
+******************************************************************/
+static int
+ipmi_lcd_get_configure_command_wh (void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD configuration: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ lcd_mode= *((LCD_MODE*)(&rsp[0]));
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_configure_command
+*
+* Description: This function returns current lcd configuration for Dell OEM LCD command
+* Input: intf - ipmi interface
+* Output: command - user defined / default / none / ipv4 / mac address /
+ system name / service tag / ipv6 / temp / system watt / asset tag
+*
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_configure_command (void * intf,
+ uint8_t *command)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD configuration: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ /* rsp->data[0] is the rev */
+ *command = rsp[1];
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_configure_command
+*
+* Description: This function updates current lcd configuration
+* Input: intf - ipmi interface
+* command - user defined / default / none / ipv4 / mac address /
+* system name / service tag / ipv6 / temp / system watt / asset tag
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_lcd_set_configure_command (void * intf, int command)
+{
+#define LSCC_DATA_LEN 2
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[2];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = 2;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+ data[1] = command; /* command - custom, default, none */
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting LCD configuration: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_configure_command
+*
+* Description: This function updates current lcd configuration
+* Input: intf - ipmi interface
+* mode - user defined / default / none
+* lcdqualifier - lcd quallifier id
+* errordisp - error number
+* Output:
+* Return:
+*
+******************************************************************/
+static int
+ipmi_lcd_set_configure_command_wh (void * intf,
+ uint32_t mode,
+ uint16_t lcdqualifier,
+ uint8_t errordisp)
+{
+#define LSCC_DATA_LEN 2
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[13];
+
+ ipmi_lcd_get_configure_command_wh(intf);
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = 13;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+
+ if(mode!=0xFF)
+ {
+
+ data[1] = mode&0xFF; /* command - custom, default, none*/
+ data[2]=(mode&0xFF00)>>8;
+ data[3]=(mode&0xFF0000)>>16;
+ data[4]=(mode&0xFF000000)>>24;
+ }
+ else
+ {
+ data[1] = (lcd_mode.lcdmode)&0xFF; /* command - custom, default, none*/
+ data[2]=((lcd_mode.lcdmode)&0xFF00)>>8;
+ data[3]=((lcd_mode.lcdmode)&0xFF0000)>>16;
+ data[4]=((lcd_mode.lcdmode)&0xFF000000)>>24;
+ }
+
+ if(lcdqualifier!=0xFF)
+ {
+ if(lcdqualifier==0x01)
+ {
+ data[5] =(lcd_mode.lcdqualifier)|0x01; /* command - custom, default, none*/
+
+ }
+ else if(lcdqualifier==0x00)
+ {
+ data[5] =(lcd_mode.lcdqualifier)&0xFE; /* command - custom, default, none*/
+ }
+ else if (lcdqualifier==0x03)
+ {
+ data[5] =(lcd_mode.lcdqualifier)|0x02; /* command - custom, default, none*/
+ }
+ else if (lcdqualifier==0x02)
+ {
+ data[5] =(lcd_mode.lcdqualifier)&0xFD;
+ }
+ }
+ else
+ {
+ data[5]=(uchar)lcd_mode.lcdqualifier;
+ }
+ if(errordisp!=0xFF)
+ {
+ data[11]=errordisp;
+ }
+ else
+ {
+ data[11]=lcd_mode.error_display;
+ }
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting LCD configuration: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_single_line_text
+*
+* Description: This function updates current lcd configuration
+* Input: intf - ipmi interface
+* lcdstring - new string to be updated
+* max_length - length of the string
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_single_line_text (void * intf, char* lcdstring, uint8_t max_length)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ IPMI_DELL_LCD_STRING * lcdstringblock;
+ int lcdstring_len = 0;
+ int bytes_copied = 0;
+ int ii;
+
+ for (ii = 0; ii < 4; ii++) {
+ int bytes_to_copy;
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter*/
+ data[1] = IPMI_DELL_LCD_STRING_SELECTOR;
+ data[2] = ii; /* block selector*/
+ data[3] = 0; /* set selector (n/a)*/
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting text data: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ lcdstringblock = (IPMI_DELL_LCD_STRING *) (void *) rsp;
+
+ /* first block is different - 14 bytes*/
+ if (0 == ii)
+ {
+ lcdstring_len = lcdstringblock->lcd_string.selector_0_string.length;
+
+ if (lcdstring_len < 1 || lcdstring_len > max_length)
+ break;
+
+ bytes_to_copy = MIN(lcdstring_len, IPMI_DELL_LCD_STRING1_SIZE);
+ memcpy (lcdstring, lcdstringblock->lcd_string.selector_0_string.data, bytes_to_copy);
+ }
+ else
+ {
+ int string_offset;
+
+ bytes_to_copy = MIN(lcdstring_len - bytes_copied, IPMI_DELL_LCD_STRINGN_SIZE);
+ if (bytes_to_copy < 1)
+ break;
+ string_offset = IPMI_DELL_LCD_STRING1_SIZE + IPMI_DELL_LCD_STRINGN_SIZE * (ii-1);
+ memcpy (lcdstring+string_offset, lcdstringblock->lcd_string.selector_n_data, bytes_to_copy);
+ }
+
+ bytes_copied += bytes_to_copy;
+ if (bytes_copied >= lcdstring_len)
+ break;
+ }
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_info_wh
+*
+* Description: This function prints current lcd configuration for whoville platform
+* Input: intf - ipmi interface
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_info_wh(void * intf)
+
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ uint8_t command = 0;
+ IPMI_DELL_LCD_CAPS* lcd_caps;
+ char lcdstring[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+ int rc;
+
+
+ printf("LCD info\n");
+
+ if (ipmi_lcd_get_configure_command_wh (intf) != 0)
+ {
+ return -1;
+ }
+ else
+ {
+ if (lcd_mode.lcdmode== IPMI_DELL_LCD_CONFIG_DEFAULT)
+ {
+ char text[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+
+ ipmi_lcd_get_platform_model_name(intf, text,
+ IPMI_DELL_LCD_STRING_LENGTH_MAX,
+ IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR);
+
+ if (text == NULL)
+ return -1;
+ printf(" Setting:Model name\n");
+ printf(" Line 1: %s\n", text);
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_CONFIG_NONE)
+ {
+ printf(" Setting: none\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_CONFIG_USER_DEFINED)
+ {
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter*/
+ data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+ data[2] = 0; /* set selector (n/a)*/
+ data[3] = 0; /* block selector (n/a)*/
+
+ printf(" Setting: User defined\n");
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD capabilities: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ lcd_caps = (IPMI_DELL_LCD_CAPS *)rsp;
+ if (lcd_caps->number_lines > 0)
+ {
+ memset(lcdstring, 0, IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+
+ rc = ipmi_lcd_get_single_line_text (intf, lcdstring, lcd_caps->max_chars[0]);
+ printf(" Text: %s\n", lcdstring);
+ }
+ else
+ {
+ printf(" No lines to show\n");
+ }
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_iDRAC_IPV4ADRESS)
+ {
+ printf(" Setting: IPV4 Address\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_IDRAC_MAC_ADDRESS)
+ {
+ printf(" Setting: MAC Address\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_OS_SYSTEM_NAME)
+ {
+ printf(" Setting: OS System Name\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_SERVICE_TAG)
+ {
+ printf(" Setting: System Tag\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_iDRAC_IPV6ADRESS)
+ {
+ printf(" Setting: IPV6 Address\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_AMBEINT_TEMP)
+ {
+ printf(" Setting: Ambient Temp\n");
+ if(lcd_mode.lcdqualifier&0x02)
+ printf(" Unit: F\n");
+ else
+ printf(" Unit: C\n");
+ }
+ else if (lcd_mode.lcdmode == IPMI_DELL_LCD_SYSTEM_WATTS)
+ {
+ printf(" Setting: System Watts\n");
+
+ if(lcd_mode.lcdqualifier&0x01)
+ printf(" Unit: BTU/hr\n");
+ else
+ printf(" Unit: Watt\n");
+
+ }
+ if(lcd_mode.error_display==IPMI_DELL_LCD_ERROR_DISP_SEL)
+ printf(" Error Display: SEL\n");
+ else if(lcd_mode.error_display==IPMI_DELL_LCD_ERROR_DISP_VERBOSE)
+ printf(" Error Display: Simple\n");
+ }
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_info
+*
+* Description: This function prints current lcd configuration for platform other than whoville
+* Input: intf - ipmi interface
+* Output:
+* Return:
+*
+******************************************************************/
+static int ipmi_lcd_get_info(void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ IPMI_DELL_LCD_CAPS * lcd_caps;
+ uint8_t command = 0;
+ char lcdstring[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+ int rc;
+
+ printf("LCD info\n");
+
+ if (ipmi_lcd_get_configure_command (intf, &command) != 0)
+ {
+ return -1;
+ }
+ else
+ {
+ if (command == IPMI_DELL_LCD_CONFIG_DEFAULT)
+ {
+ memset (lcdstring,0,IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+
+ ipmi_lcd_get_platform_model_name(intf, lcdstring, IPMI_DELL_LCD_STRING_LENGTH_MAX,
+ IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR);
+
+ printf(" Setting: default\n");
+ printf(" Line 1: %s\n", lcdstring);
+ }
+ else if (command == IPMI_DELL_LCD_CONFIG_NONE)
+ {
+ printf(" Setting: none\n");
+ }
+ else if (command == IPMI_DELL_LCD_CONFIG_USER_DEFINED)
+ {
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter */
+ data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+ data[2] = 0; /* set selector (n/a) */
+ data[3] = 0; /* block selector (n/a) */
+
+ printf(" Setting: custom\n");
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD capabilities: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ lcd_caps = (IPMI_DELL_LCD_CAPS *)(void *)rsp;
+ if (lcd_caps->number_lines > 0)
+ {
+ memset (lcdstring,0,IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+ rc = ipmi_lcd_get_single_line_text (intf, lcdstring, lcd_caps->max_chars[0]);
+ printf(" Text: %s\n", lcdstring);
+ }
+ else
+ {
+ printf(" No lines to show\n");
+ }
+ }
+ }
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_status_val
+*
+* Description: This function gets current lcd configuration
+* Input: intf - ipmi interface
+* Output: lcdstatus - KVM Status & Lock Status
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_status_val(void * intf, LCD_STATUS* lcdstatus)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter */
+ data[1] = IPMI_DELL_LCD_STATUS_SELECTOR;
+ data[2] = 0; /* block selector */
+ data[3] = 0;
+ /* set selector (n/a) */
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD status: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ /*lcdstatus= (LCD_STATUS* ) rsp->data; */
+
+ lcdstatus->vKVM_status=rsp[1];
+ lcdstatus->lock_status=rsp[2];
+
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: IsLCDSupported
+*
+* Description: This function returns whether lcd supported or not
+* Input:
+* Output:
+* Return:
+*
+******************************************************************/
+static int IsLCDSupported ()
+{
+ return LcdSupported;
+}
+
+/*****************************************************************
+* Function Name: CheckLCDSupport
+*
+* Description: This function checks whether lcd supported or not
+* Input: intf - ipmi interface
+* Output:
+* Return:
+*
+******************************************************************/
+static void CheckLCDSupport(void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ LcdSupported = 0;
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter */
+ data[1] = IPMI_DELL_LCD_STATUS_SELECTOR;
+ data[2] = 0; /* block selector */
+ data[3] = 0;
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) { return; }
+ LcdSupported = 1;
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_status_print
+*
+* Description: This function prints current lcd configuration KVM Status & Lock Status
+* Input: lcdstatus - KVM Status & Lock Status
+* Output:
+* Return:
+*
+******************************************************************/
+
+static void ipmi_lcd_status_print( LCD_STATUS lcdstatus)
+{
+ switch (lcdstatus.vKVM_status)
+ {
+ case 0x00:
+ printf("LCD KVM Status :Inactive\n");
+ break;
+ case 0x01:
+ printf("LCD KVM Status :Active\n");
+ break;
+ default:
+ printf("LCD KVM Status :Invalid Status\n");
+
+ break;
+ }
+
+ switch (lcdstatus.lock_status)
+ {
+ case 0x00:
+ printf("LCD lock Status :View and modify\n");
+ break;
+ case 0x01:
+ printf("LCD lock Status :View only\n");
+ break;
+ case 0x02:
+ printf("LCD lock Status :disabled\n");
+ break;
+ default:
+ printf("LCD lock Status :Invalid\n");
+ break;
+ }
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_get_status
+*
+* Description: This function gets current lcd KVM active status & lcd access mode
+* Input: intf - ipmi interface
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+static int
+ipmi_lcd_get_status(void * intf )
+{
+ int rc=0;
+ LCD_STATUS lcdstatus;
+
+ rc =ipmi_lcd_get_status_val( intf, &lcdstatus);
+ if (rc <0)
+ return -1;
+ ipmi_lcd_status_print(lcdstatus);
+
+ return rc;
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_kvm
+*
+* Description: This function sets lcd KVM active status
+* Input: intf - ipmi interface
+* status - Inactive / Active
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+static int
+ipmi_lcd_set_kvm(void * intf, char status)
+{
+#define LSCC_DATA_LEN 2
+ LCD_STATUS lcdstatus;
+ int rc=0;
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[5];
+ rc=ipmi_lcd_get_status_val(intf,&lcdstatus);
+ if (rc < 0)
+ return -1;
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = 5;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_STATUS_SELECTOR;
+ data[1] = status; /* active- incative*/
+ data[2] = lcdstatus.lock_status; /* full-veiw-locked */
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting LCD status: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return rc;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_lock
+*
+* Description: This function sets lcd access mode
+* Input: intf - ipmi interface
+* lock - View and modify / View only / Diabled
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+static int
+ipmi_lcd_set_lock(void * intf, char lock)
+{
+#define LSCC_DATA_LEN 2
+ LCD_STATUS lcdstatus;
+ int rc =0;
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[5];
+ rc=ipmi_lcd_get_status_val(intf,&lcdstatus);
+ if (rc < 0)
+ return -1;
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = 5;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_STATUS_SELECTOR;
+ data[1] = lcdstatus.vKVM_status; /* active- incative */
+ data[2] = lock; /* full- veiw-locked */
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting LCD status: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ return rc;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_single_line_text
+*
+* Description: This function sets lcd line text
+* Input: intf - ipmi interface
+* text - lcd string
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_set_single_line_text (void * intf, char * text)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[18];
+ int bytes_to_store = strlen_(text);
+ int bytes_stored = 0;
+ int ii;
+ int rc = 0;
+ if (bytes_to_store>IPMI_DELL_LCD_STRING_LENGTH_MAX)
+ {
+ lprintf(LOG_ERR, " Out of range Max limit is 62 characters");
+ return 1;
+
+ }
+ else
+ {
+ bytes_to_store = MIN(bytes_to_store, IPMI_DELL_LCD_STRING_LENGTH_MAX);
+ for (ii = 0; ii < 4; ii++) {
+ /*first block, 2 bytes parms and 14 bytes data*/
+ if (0 == ii) {
+ int size_of_copy =
+ MIN((bytes_to_store - bytes_stored), IPMI_DELL_LCD_STRING1_SIZE);
+ if (size_of_copy < 0) /* allow 0 string length*/
+ break;
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = size_of_copy + 4; /* chars, selectors and sizes*/
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_STRING_SELECTOR;
+ data[1] = ii; /* block number to use (0)*/
+ data[2] = 0; /*string encoding*/
+ data[3] = bytes_to_store; /* total string length*/
+ memcpy (data+4, text+bytes_stored, size_of_copy);
+ bytes_stored += size_of_copy;
+ } else {
+ int size_of_copy =
+ MIN((bytes_to_store - bytes_stored), IPMI_DELL_LCD_STRINGN_SIZE);
+ if (size_of_copy <= 0)
+ break;
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = size_of_copy + 2;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_LCD_STRING_SELECTOR;
+ data[1] = ii; /* block number to use (1,2,3)*/
+ memcpy (data+2, text+bytes_stored, size_of_copy);
+ bytes_stored += size_of_copy;
+ }
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error setting text data: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+ }
+ }
+ return rc;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_set_text
+*
+* Description: This function sets lcd line text
+* Input: intf - ipmi interface
+* text - lcd string
+* line_number- line number
+
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_set_text(void * intf, char * text, int line_number)
+{
+ int rc = 0;
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+ IPMI_DELL_LCD_CAPS * lcd_caps;
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0; /* get parameter*/
+ data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+ data[2] = 0; /* set selector (n/a)*/
+ data[3] = 0; /* block selector (n/a)*/
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf("Error getting LCD capabilities: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ lcd_caps = (IPMI_DELL_LCD_CAPS *)(void *)rsp;
+
+ if (lcd_caps->number_lines > 0) {
+ rc = ipmi_lcd_set_single_line_text (intf, text);
+ } else {
+ lprintf(LOG_ERR, "LCD does not have any lines that can be set");
+ rc = -1;
+ }
+
+
+ return rc;
+}
+
+/*****************************************************************
+* Function Name: ipmi_lcd_configure_wh
+*
+* Description: This function updates the current lcd configuration
+* Input: intf - ipmi interface
+* lcdqualifier- lcd quallifier
+* errordisp - error number
+* line_number-line number
+* text - lcd string
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_configure_wh (void * intf, uint32_t mode ,
+ uint16_t lcdqualifier, uint8_t errordisp,
+ int8_t line_number, char * text)
+{
+ int rc = 0;
+
+
+ if (IPMI_DELL_LCD_CONFIG_USER_DEFINED == mode)
+ /* Any error was reported earlier. */
+ rc = ipmi_lcd_set_text(intf, text, line_number);
+
+
+ if (rc == 0)
+
+ rc = ipmi_lcd_set_configure_command_wh (intf, mode ,lcdqualifier,errordisp);
+
+ return rc;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_configure
+*
+* Description: This function updates the current lcd configuration
+* Input: intf - ipmi interface
+* command- lcd command
+* line_number-line number
+* text - lcd string
+* Output:
+* Return: -1 on error
+* 0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_configure (void * intf, int command,
+ int8_t line_number, char * text)
+{
+ int rc = 0;
+
+ if (IPMI_DELL_LCD_CONFIG_USER_DEFINED == command)
+ rc = ipmi_lcd_set_text(intf, text, line_number);
+
+ if (rc == 0)
+ rc = ipmi_lcd_set_configure_command (intf, command);
+
+ return rc;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_lcd_usage
+*
+* Description: This function prints help message for lcd command
+* Input:
+* Output:
+*
+* Return:
+*
+******************************************************************/
+
+static void
+ipmi_lcd_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, "Generic DELL HW:");
+ lprintf(LOG_NOTICE, " lcd set {none}|{default}|{custom <text>}");
+ lprintf(LOG_NOTICE, " Set LCD text displayed during non-fault conditions");
+
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, "iDRAC 11g or iDRAC 12g:");
+ lprintf(LOG_NOTICE, " lcd set {mode}|{lcdqualifier}|{errordisplay}");
+ lprintf(LOG_NOTICE, " Allows you to set the LCD mode and user-definedstring.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd set mode {none}|{modelname}|{ipv4address}|{macaddress}|");
+ lprintf(LOG_NOTICE, " {systemname}|{servicetag}|{ipv6address}|{ambienttemp}");
+ lprintf(LOG_NOTICE, " {systemwatt }|{assettag}|{userdefined}<text>");
+ lprintf(LOG_NOTICE, " Allows you to set the LCD display mode to any of the preceding parameters");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd set lcdqualifier {watt}|{btuphr}|{celsius}|{fahrenheit}");
+ lprintf(LOG_NOTICE, " Allows you to set the unit for the system ambient temperature mode.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd set errordisplay {sel}|{simple}");
+ lprintf(LOG_NOTICE, " Allows you to set the error display.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd info");
+ lprintf(LOG_NOTICE, " Show LCD text that is displayed during non-fault conditions");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd set vkvm{active}|{inactive}");
+ lprintf(LOG_NOTICE, " Set vKVM active and inactive, message will be displayed on lcd");
+ lprintf(LOG_NOTICE, " when vKVM is active and vKVM session is in progress");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd set frontpanelaccess {viewandmodify}|{viewonly}|{disabled}");
+ lprintf(LOG_NOTICE, " Set LCD mode to view and modify, view only or disabled ");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lcd status");
+ lprintf(LOG_NOTICE, " Show LCD Status for vKVM display<active|inactive>");
+ lprintf(LOG_NOTICE, " and Front Panel access mode {viewandmodify}|{viewonly}|{disabled} ");
+ lprintf(LOG_NOTICE, "");
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_mac_main
+*
+* Description: This function processes the delloem mac command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+
+static int ipmi_delloem_mac_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ current_arg++;
+ if (argc > 1 && strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_mac_usage();
+ return 0;
+ }
+ ipmi_idracvalidator_command(intf);
+ if (argc == 1) /*( || (strncmp(argv[current_arg], "list\0", 5) == 0) )*/
+ {
+ rc = ipmi_macinfo(intf, 0xff);
+ }
+ else if (strncmp(argv[current_arg], "get\0", 4) == 0)
+ {
+ int currIdInt;
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_mac_usage();
+ return -1;
+ }
+ if(make_int(argv[current_arg],&currIdInt) < 0) {
+ lprintf(LOG_ERR, "Invalid NIC number. The NIC number should be between 0-8\n");
+ return -1;
+ }
+ if( (currIdInt > 8) || (currIdInt < 0) )
+ {
+ lprintf(LOG_ERR, "Invalid NIC number. The NIC number should be between 0-8\n");
+ return -1;
+ }
+ rc = ipmi_macinfo(intf, currIdInt);
+ }
+ else
+ {
+ ipmi_mac_usage();
+ }
+ return(rc);
+}
+
+
+/*****************************************************************
+* Function Name: make_int
+*
+* Description: This function convert string into integer
+* Input: str - decimal number string
+* Output: value - integer value
+* Return:
+*
+******************************************************************/
+static int make_int(const char *str, int *value)
+{
+ char *tmp=NULL;
+ *value = (int)strtol(str,&tmp,0);
+ if ( tmp-str != strlen(str) )
+ {
+ return -1;
+ }
+ return 0;
+}
+
+
+
+
+
+EmbeddedNICMacAddressType EmbeddedNICMacAddress;
+
+EmbeddedNICMacAddressType_10G EmbeddedNICMacAddress_10G;
+
+static void InitEmbeddedNICMacAddressValues ()
+{
+ uint8_t i;
+ uint8_t j;
+
+
+ for (i=0;i<MAX_LOM;i++)
+ {
+#ifdef LOM_OLD
+ EmbeddedNICMacAddress.LOMMacAddress[i].BladSlotNumber = 0;
+ EmbeddedNICMacAddress.LOMMacAddress[i].MacType = LOM_MACTYPE_RESERVED;
+ EmbeddedNICMacAddress.LOMMacAddress[i].EthernetStatus = LOM_ETHERNET_RESERVED;
+ EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber = 0;
+ EmbeddedNICMacAddress.LOMMacAddress[i].Reserved = 0;
+#else
+ EmbeddedNICMacAddress.LOMMacAddress[i].b0 = 0xF0;
+ EmbeddedNICMacAddress.LOMMacAddress[i].b1 = 0x00;
+#endif
+ for (j=0;j<MACADDRESSLENGH;j++)
+ {
+ EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[j] = 0;
+ EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j] = 0;
+ }
+ }
+}
+
+uint8_t UseVirtualMacAddress = 0;
+#define VIRTUAL_MAC_OFFSET (2)
+static int ipmi_macinfo_drac_idrac_virtual_mac(void* intf,uint8_t NicNum)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t VirtualMacAddress [MACADDRESSLENGH];
+ uint8_t input_length=0;
+ uint8_t j;
+ //uint8_t length;
+ uint8_t i;
+
+
+ if (0xff==NicNum || IDRAC_NIC_NUMBER==NicNum )
+ {
+ UseVirtualMacAddress = 0;
+
+ input_length = 0;
+ msg_data[input_length++] = 1; /*Get*/
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_IDRAC_VIRTUAL_MAC;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) { return rv; }
+
+ if( (IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type) ) {
+ // Get the Chasiss Assigned MAC Addresss for 12g Only
+ memcpy(VirtualMacAddress,&rsp[1],MACADDRESSLENGH);
+
+ for (i=0;i<MACADDRESSLENGH;i++)
+ {
+ if (0 != VirtualMacAddress [i])
+ {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ // Get the Server Assigned MAC Addresss for 12g Only
+ if(!UseVirtualMacAddress) {
+ memcpy(VirtualMacAddress,&rsp[1+MACADDRESSLENGH],MACADDRESSLENGH);
+
+ for (i=0;i<MACADDRESSLENGH;i++)
+ {
+ if (0 != VirtualMacAddress [i])
+ {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ }
+ } else {
+ memcpy(VirtualMacAddress,&rsp[VIRTUAL_MAC_OFFSET],MACADDRESSLENGH);
+
+ for (i=0;i<MACADDRESSLENGH;i++)
+ {
+ if (0 != VirtualMacAddress [i])
+ {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ }
+ if (0 == UseVirtualMacAddress)
+ return -1;
+ if (IMC_IDRAC_10G == IMC_Type)
+ printf ("\nDRAC MAC Address ");
+ else if ( (IMC_IDRAC_11G_MODULAR == IMC_Type) || (IMC_IDRAC_11G_MONOLITHIC== IMC_Type) )
+ printf ("\niDRAC6 MAC Address ");
+ else if ( (IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type) )
+ printf ("\niDRAC7 MAC Address ");
+
+ for (j=0;j<5;j++)
+ printf("%02x:",VirtualMacAddress[j]);
+ printf("%02x",VirtualMacAddress[j]); /*5*/
+
+ printf ("\n\r");
+
+ }
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_macinfo_drac_idrac_mac
+*
+* Description: This function retrieves the mac address of DRAC or iDRAC
+* Input: NicNum
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int ipmi_macinfo_drac_idrac_mac(void* intf,uint8_t NicNum)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+ uint8_t iDRAC6MacAddressByte[MACADDRESSLENGH];
+ uint8_t j;
+
+ ipmi_macinfo_drac_idrac_virtual_mac (intf,NicNum);
+
+
+ if ((0xff==NicNum || IDRAC_NIC_NUMBER==NicNum) && 0 == UseVirtualMacAddress)
+ {
+
+ input_length = 0;
+
+ msg_data[input_length++] = LAN_CHANNEL_NUMBER;
+ msg_data[input_length++] = MAC_ADDR_PARAM;
+ msg_data[input_length++] = 0x00;
+ msg_data[input_length++] = 0x00;
+
+ req.msg.netfn = TRANSPORT_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_LAN_PARAM_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting MAC Address: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ memcpy(iDRAC6MacAddressByte,&rsp[PARAM_REV_OFFSET],MACADDRESSLENGH);
+
+ if (IMC_IDRAC_10G == IMC_Type)
+ printf ("\n\rDRAC MAC Address ");
+ else if ((IMC_IDRAC_11G_MODULAR == IMC_Type) || (IMC_IDRAC_11G_MONOLITHIC== IMC_Type))
+ printf ("\n\riDRAC6 MAC Address ");
+ else if ((IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type))
+ printf ("\n\riDRAC7 MAC Address ");
+ else
+ printf ("\n\riDRAC6 MAC Address ");
+
+ for (j=0;j<5;j++)
+ printf("%02x:",iDRAC6MacAddressByte[j]);
+ printf("%02x",iDRAC6MacAddressByte[j]);
+
+ printf ("\n\r");
+ }
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_macinfo_10g
+*
+* Description: This function retrieves the mac address of LOMs
+* Input: intf - ipmi interface
+ NicNum - NIC number
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int ipmi_macinfo_10g (void* intf, uint8_t NicNum)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+
+ uint8_t j;
+ uint8_t i;
+
+ uint8_t Total_No_NICs = 0;
+
+
+ InitEmbeddedNICMacAddressValues ();
+
+ memset(msg_data, 0, sizeof(msg_data));
+ input_length = 0;
+ msg_data[input_length++] = 0x00; /* Get Parameter Command */
+ msg_data[input_length++] = EMB_NIC_MAC_ADDRESS_9G_10G; /* OEM Param */
+
+ msg_data[input_length++] = 0x00;
+ msg_data[input_length++] = 0x00;
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = APP_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_SYSTEM_INFO_CMD;
+ req.msg.data = msg_data;
+
+
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting MAC Address: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+ if (fdebug) dump_buf("GetMacResp_10G",rsp,rsp_len,0);
+
+ Total_No_NICs = (uint8_t) rsp[PARAM_REV_OFFSET]; /* Byte 1: Total Number of Embedded NICs */
+
+ if (IDRAC_NIC_NUMBER != NicNum)
+ {
+ if (0xff == NicNum)
+ {
+ printf ("\n\rSystem LOMs");
+ }
+ printf("\n\rNIC Number\tMAC Address\n\r");
+
+ memcpy(&EmbeddedNICMacAddress_10G,&rsp[PARAM_REV_OFFSET+TOTAL_N0_NICS_INDEX],Total_No_NICs* MACADDRESSLENGH);
+
+
+ /*Read the LOM type and Mac Addresses */
+
+ for (i=0;i<Total_No_NICs;i++)
+ {
+ if ((0xff==NicNum) || (i == NicNum) )
+ {
+ printf ("\n\r%d",i);
+ printf ("\t\t");
+ for (j=0;j<5;j++)
+ {
+ printf("%02x:",EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j]);
+ }
+ printf("%02x",EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j]);
+ }
+ }
+ printf ("\n\r");
+
+ }
+
+ ipmi_macinfo_drac_idrac_mac(intf,NicNum);
+
+
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_macinfo_11g
+*
+* Description: This function retrieves the mac address of LOMs
+* Input: intf - ipmi interface
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int ipmi_macinfo_11g (void* intf, uint8_t NicNum)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+ uint8_t len;
+ uint8_t j;
+ uint8_t offset;
+ uint8_t maxlen;
+ uint8_t loop_count;
+ uint8_t i;
+ uint8_t lom_mactype;
+ uint8_t lom_nicnum;
+ uint8_t lom_ethstat;
+ uint8_t *lom_mac;
+ // uint8_t LOMStatus = 0;
+ // uint8_t PlayingDead = 0;
+
+ offset = 0;
+ len = 8; /*eigher 8 or 16 */
+ maxlen = 64;
+ loop_count = maxlen / len;
+
+ InitEmbeddedNICMacAddressValues ();
+
+ memset(msg_data, 0, sizeof(msg_data));
+ input_length = 0;
+ msg_data[input_length++] = 0x00; /* Get Parameter Command */
+ msg_data[input_length++] = EMB_NIC_MAC_ADDRESS_11G; /* OEM Param */
+
+ msg_data[input_length++] = 0x00;
+ msg_data[input_length++] = 0x00;
+ msg_data[input_length++] = 0x00;
+ msg_data[input_length++] = 0x00;
+
+ memset(&req, 0, sizeof(req));
+
+ req.msg.netfn = APP_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_SYSTEM_INFO_CMD;
+ req.msg.data = msg_data;
+
+
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting MAC Address: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+
+ len = 8; /*eigher 8 or 16 */
+ maxlen = (uint8_t) rsp[0+PARAM_REV_OFFSET];
+ loop_count = maxlen / len;
+
+ if (IDRAC_NIC_NUMBER != NicNum)
+ {
+ if (0xff == NicNum)
+ {
+ printf ("\n\rSystem LOMs");
+ }
+ printf("\n\rNIC Number\tMAC Address\t\tStatus\n\r");
+
+
+ /*Read the LOM type and Mac Addresses */
+ offset=0;
+ for (i=0;i<loop_count;i++,offset=offset+len)
+ {
+ input_length = 4;
+ msg_data[input_length++] = offset;
+ msg_data[input_length++] = len;
+
+ req.msg.netfn = APP_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_SYSTEM_INFO_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting MAC Address: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x\n", rv);
+ return rv;
+ }
+ if (fdebug) {
+ printf("ipmi_macinfo_11g(%d) i=%d offset=%d\n",NicNum,i,offset);
+ dump_buf("GetMacResp",rsp,rsp_len,0);
+ }
+
+ memcpy(&(EmbeddedNICMacAddress.LOMMacAddress[i]),&rsp[PARAM_REV_OFFSET],len);
+
+#ifdef LOM_OLD
+ lom_ethstat = EmbeddedNICMacAddress.LOMMacAddress[i].EthernetStatus;
+ lom_mactype = EmbeddedNICMacAddress.LOMMacAddress[i].MacType;
+ lom_nicnum = EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber;
+ lom_mac = &EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[0];
+#else
+ lom_ethstat = ((EmbeddedNICMacAddress.LOMMacAddress[i].b0 & 0xc0) >> 6);
+ lom_mactype = ((EmbeddedNICMacAddress.LOMMacAddress[i].b0 & 0x30) >> 4);
+ /* lom_bladslot = (b0 & 0x0f); */
+ lom_nicnum = (EmbeddedNICMacAddress.LOMMacAddress[i].b1 & 0x1f);
+ lom_mac = &EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[0];
+ if (fdebug) {
+ printf("\n\rlom_ethstat=%x lom_mactype=%x lom_nicnum=%x\n",
+ lom_ethstat,lom_mactype,lom_nicnum);
+ printf("MacAdrB=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ lom_mac[0], lom_mac[1], lom_mac[2],
+ lom_mac[3], lom_mac[4], lom_mac[5]);
+ printf("\n\rrsp_mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+ rsp[3], rsp[4], rsp[5], rsp[6], rsp[7], rsp[8]);
+ }
+ lom_mac = &rsp[3];
+#endif
+
+ if (LOM_MACTYPE_ETHERNET == lom_mactype)
+ {
+
+ if ( (0xff==NicNum) || (NicNum == lom_nicnum) )
+ {
+ printf ("\n\r%d",lom_nicnum);
+ printf ("\t\t");
+ for (j=0;j<5;j++)
+ printf("%02x:",lom_mac[j]);
+ printf("%02x",lom_mac[j]);
+
+ if (LOM_ETHERNET_ENABLED == lom_ethstat)
+ printf ("\tEnabled");
+ else
+ printf ("\tDisabled");
+ }
+ }
+
+ }
+ printf ("\n\r");
+
+ }
+
+ ipmi_macinfo_drac_idrac_mac(intf,NicNum);
+
+ return 0;
+
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_macinfo
+*
+* Description: This function retrieves the mac address of LOMs
+* Input: intf - ipmi interface
+* Output:
+* Return:
+*
+******************************************************************/
+
+static int ipmi_macinfo (void* intf, uint8_t NicNum)
+{
+ if (IMC_IDRAC_10G == IMC_Type)
+ {
+ return ipmi_macinfo_10g (intf,NicNum);
+ }
+ else if ((IMC_IDRAC_11G_MODULAR == IMC_Type || IMC_IDRAC_11G_MONOLITHIC== IMC_Type ) ||
+ (IMC_IDRAC_12G_MODULAR == IMC_Type || IMC_IDRAC_12G_MONOLITHIC== IMC_Type ) )
+ {
+ return ipmi_macinfo_11g (intf,NicNum);
+ }
+ else
+ {
+ lprintf(LOG_ERR, " Error in getting MAC Address : Not supported platform");
+ return 0;
+ }
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_mac_usage
+*
+* Description: This function prints help message for mac command
+* Input:
+* Output:
+*
+* Return:
+*
+******************************************************************/
+
+static void
+ipmi_mac_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " mac list");
+ lprintf(LOG_NOTICE, " Lists the MAC address of LOMs");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " mac get <NIC number>");
+ lprintf(LOG_NOTICE, " Shows the MAC address of specified LOM. 0-7 System LOM, 8- DRAC/iDRAC.");
+ lprintf(LOG_NOTICE, "");
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_lan_main
+*
+* Description: This function processes the delloem lan command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_lan_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ int nic_selection = 0;
+ char nic_set[2] = {0};
+ current_arg++;
+ if (argv[current_arg] == NULL || strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_lan_usage();
+ return 0;
+ }
+ ipmi_idracvalidator_command(intf);
+ if (!IsLANSupported())
+ {
+ printf("lan is not supported on this system.\n");
+ return -1;
+ }
+ else if (strncmp(argv[current_arg], "set\0", 4) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_lan_usage();
+ return -1;
+ }
+ if(iDRAC_FLAG == IDRAC_12G) {
+ nic_selection = get_nic_selection_mode_12g(intf,current_arg,argv,nic_set);
+ if (INVALID == nic_selection)
+ {
+ ipmi_lan_usage();
+ return -1;
+ } else if(INVAILD_FAILOVER_MODE == nic_selection) {
+ printf(INVAILD_FAILOVER_MODE_STRING);
+ return 0;
+ } else if(INVAILD_FAILOVER_MODE_SETTINGS == nic_selection){
+ printf(INVAILD_FAILOVER_MODE_SET);
+ return 0;
+ } else if(INVAILD_SHARED_MODE == nic_selection){
+ printf(INVAILD_SHARED_MODE_SET_STRING);
+ return 0;
+ }
+
+ rc = ipmi_lan_set_nic_selection_12g(intf,nic_set);
+ }
+ else
+ {
+ nic_selection = get_nic_selection_mode(current_arg,argv);
+
+ if (INVALID == nic_selection)
+ {
+ ipmi_lan_usage();
+ return -1;
+ }
+ if(IMC_IDRAC_11G_MODULAR == IMC_Type) {
+ printf(INVAILD_SHARED_MODE_SET_STRING);
+ return 0;
+ }
+ rc = ipmi_lan_set_nic_selection(intf,nic_selection);
+ }
+ return 0;
+ }
+ else if (strncmp(argv[current_arg], "get\0", 4) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ rc = ipmi_lan_get_nic_selection(intf);
+ return rc;
+ }
+ else if (strncmp(argv[current_arg], "active\0", 7) == 0)
+ {
+ rc = ipmi_lan_get_active_nic(intf);
+ return rc;
+ }
+ else
+ {
+ ipmi_lan_usage();
+ }
+
+ }
+ else
+ {
+ ipmi_lan_usage();
+ return -1;
+ }
+ return(rc);
+}
+
+
+static int IsLANSupported ()
+{
+ if (IMC_IDRAC_11G_MODULAR == IMC_Type)
+ return 0;
+ return 1;
+}
+
+
+int get_nic_selection_mode_12g (void* intf,int current_arg, char ** argv, char *nic_set)
+{
+ int failover = 0;
+
+ // First get the current settings.
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+
+ input_length = 0;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+
+ req.msg.cmd = GET_NIC_SELECTION_12G_CMD;
+
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting NIC selection: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ nic_set[0] = rsp[0];
+ nic_set[1] = rsp[1];
+
+
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "dedicated\0", 10))
+ {
+ nic_set[0] = 1;
+ nic_set[1] = 0;
+ return 0;
+ }
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "shared\0", 7))
+ {
+
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "with\0", 5))
+ {
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "failover\0", 9))
+ {
+ failover = 1;
+ }
+ if(failover)
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom1\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(failover) {
+ if(nic_set[0] == 2)
+ {
+ return INVAILD_FAILOVER_MODE;
+ } else if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 2;
+ }
+ else {
+ nic_set[0] = 2;
+ if(nic_set[1] == 2)
+ nic_set[1] = 0;
+ }
+ return 0;
+ }
+ else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom2\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(failover) {
+ if(nic_set[0] == 3)
+ {
+ return INVAILD_FAILOVER_MODE;
+ } else if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 3;
+ }
+ else {
+ nic_set[0] = 3;
+ if(nic_set[1] == 3)
+ nic_set[1] = 0;
+
+ }
+ return 0;
+ }
+ else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom3\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(failover) {
+ if(nic_set[0] == 4)
+ {
+ return INVAILD_FAILOVER_MODE;
+ } else if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 4;
+ }
+ else {
+ nic_set[0] = 4;
+ if(nic_set[1] == 4)
+ nic_set[1] = 0;
+ }
+ return 0;
+ }
+ else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom4\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(failover) {
+ if(nic_set[0] == 5)
+ {
+ return INVAILD_FAILOVER_MODE;
+ } else if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 5;
+ }
+ else {
+ nic_set[0] = 5;
+ if(nic_set[1] == 5)
+ nic_set[1] = 0;
+ }
+ return 0;
+ }
+ else if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "none\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(failover) {
+ if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 0;
+ }
+ return 0;
+ }
+ else if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "all\0", 4))
+ {
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "loms\0", 5))
+ {
+ if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+ {
+ return INVAILD_SHARED_MODE;
+ }
+ if(nic_set[0] == 1) {
+ return INVAILD_FAILOVER_MODE_SETTINGS;
+ }
+ nic_set[1] = 6;
+ return 0;
+ }
+
+ return INVALID;
+
+}
+
+
+static int get_nic_selection_mode (int current_arg, char ** argv)
+{
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "dedicated\0", 10))
+ {
+ return DEDICATED;
+ }
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "shared\0", 7))
+ {
+ if (NULL == argv[current_arg+1] )
+ return SHARED;
+ }
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "with\0", 5))
+ {
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "failover\0", 9))
+ {
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom2\0", 5))
+ {
+ return SHARED_WITH_FAILOVER_LOM2;
+ }
+ else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "all\0", 4))
+ {
+ }
+ else
+ return INVALID;
+
+ current_arg++;
+ if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "loms\0", 5))
+ {
+ return SHARED_WITH_FAILOVER_ALL_LOMS;
+ }
+
+ return INVALID;
+
+}
+
+
+static int ipmi_lan_set_nic_selection_12g (void* intf, uint8_t* nic_selection)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+
+ input_length = 0;
+
+ msg_data[input_length++] = nic_selection[0];
+ msg_data[input_length++] = nic_selection[1];
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = SET_NIC_SELECTION_12G_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in setting NIC selection: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+ printf("configured successfully");
+
+ return 0;
+}
+
+
+static int ipmi_lan_set_nic_selection (void* intf, uint8_t nic_selection)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+ //uint8_t j;
+
+ input_length = 0;
+
+ msg_data[input_length++] = nic_selection;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = SET_NIC_SELECTION_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in setting NIC selection: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+ printf("configured successfully");
+
+ return 0;
+}
+
+static int ipmi_lan_get_nic_selection (void* intf)
+{
+ uint8_t nic_selection=-1;
+ uint8_t nic_selection_failover = 0;
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+ //uint8_t j;
+
+ input_length = 0;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ if(iDRAC_FLAG == IDRAC_12G)
+ req.msg.cmd = GET_NIC_SELECTION_12G_CMD;
+ else
+ req.msg.cmd = GET_NIC_SELECTION_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting NIC selection: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+ nic_selection = rsp[0];
+
+ if(iDRAC_FLAG == IDRAC_12G)
+ {
+
+ nic_selection_failover = rsp[1];
+ if ((nic_selection < 6) && (nic_selection > 0) && (nic_selection_failover < 7))
+ {
+ if(nic_selection == 1) {
+ printf ("%s\n",NIC_Selection_Mode_String_12g[nic_selection-1]);
+ } else if(nic_selection) {
+ printf ("Shared LOM : %s\n",NIC_Selection_Mode_String_12g[nic_selection-1]);
+ if(nic_selection_failover == 0)
+ printf ("Failover LOM : None\n");
+ else if(nic_selection_failover >= 2 && nic_selection_failover <= 6)
+ printf ("Failover LOM : %s\n",NIC_Selection_Mode_String_12g[nic_selection_failover + 3]);
+ }
+
+ }
+ else
+ {
+ lprintf(LOG_ERR, " Error Outof bond Value received (%d) (%d) \n",nic_selection,nic_selection_failover);
+ return -1;
+ }
+ }
+ else
+ {
+ printf ("%s\n",NIC_Selection_Mode_String[nic_selection]);
+ }
+
+ return 0;
+}
+
+static int ipmi_lan_get_active_nic (void* intf)
+{
+ uint8_t active_nic=0;
+ uint8_t current_lom =0;
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[30];
+ uint8_t input_length=0;
+
+ input_length = 0;
+
+ msg_data[input_length++] = 0; /*Get current LOM*/
+ msg_data[input_length++] = 0; /*Reserved*/
+ msg_data[input_length++] = 0; /*Reserved*/
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_ACTIVE_NIC_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting Current LOM: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+ current_lom = rsp[0];
+
+ input_length = 0;
+
+ msg_data[input_length++] = 1; //Get Link status
+ msg_data[input_length++] = 0; //Reserved
+ msg_data[input_length++] = 0; //Reserved
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_ACTIVE_NIC_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error in getting Active LOM Status: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ active_nic = rsp[1];
+ if (current_lom < 5 && active_nic)
+ printf ("\n%s\n",ActiveLOM_String[current_lom]);
+ else
+ printf ("\n%s\n",ActiveLOM_String[5]);
+
+ return 0;
+}
+
+
+static void
+ipmi_lan_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lan set <Mode> ");
+ lprintf(LOG_NOTICE, " sets the NIC Selection Mode :");
+ lprintf(LOG_NOTICE, " on iDRAC12g :");
+
+ lprintf(LOG_NOTICE, " dedicated, shared with lom1, shared with lom2,shared with lom3,shared ");
+ lprintf(LOG_NOTICE, " with lom4,shared with failover lom1,shared with failover lom2,shared ");
+ lprintf(LOG_NOTICE, " with failover lom3,shared with failoverlom4,shared with Failover all ");
+ lprintf(LOG_NOTICE, " loms, shared with Failover None).");
+ lprintf(LOG_NOTICE, " on other systems :");
+ lprintf(LOG_NOTICE, " dedicated, shared, shared with failoverlom2,");
+ lprintf(LOG_NOTICE, " shared with Failover all loms.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lan get ");
+ lprintf(LOG_NOTICE, " on iDRAC12g :");
+ lprintf(LOG_NOTICE, " returns the current NIC Selection Mode (dedicated, shared with lom1, shared ");
+ lprintf(LOG_NOTICE, " with lom2, shared with lom3, shared with lom4,shared with failover lom1,");
+ lprintf(LOG_NOTICE, " shared with failover lom2,shared with failover lom3,shared with failover ");
+ lprintf(LOG_NOTICE, " lom4,shared with Failover all loms,shared with Failover None).");
+ lprintf(LOG_NOTICE, " on other systems :");
+ lprintf(LOG_NOTICE, " dedicated, shared, shared with failover,");
+ lprintf(LOG_NOTICE, " lom2, shared with Failover all loms.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " lan get active");
+ lprintf(LOG_NOTICE, " Get the current active LOMs (LOM1, LOM2, LOM3, LOM4, NONE).");
+ lprintf(LOG_NOTICE, "");
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_powermonitor_main
+*
+* Description: This function processes the delloem powermonitor command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_powermonitor_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ current_arg++;
+ if (argc > 1 && strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_powermonitor_usage();
+ return 0;
+ }
+ ipmi_idracvalidator_command(intf);
+ if (argc == 1)
+ {
+ rc = ipmi_powermgmt(intf);
+ }
+ else if (strncmp(argv[current_arg], "status\0", 7) == 0)
+ {
+ rc = ipmi_powermgmt(intf);
+ }
+
+ else if (strncmp(argv[current_arg], "clear\0", 6) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+ else if (strncmp(argv[current_arg], "peakpower\0", 10) == 0)
+ {
+ rc = ipmi_powermgmt_clear(intf, 1);
+ }
+ else if (strncmp(argv[current_arg], "cumulativepower\0", 16) == 0)
+ {
+ rc = ipmi_powermgmt_clear(intf, 0);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+
+ }
+
+
+ else if (strncmp(argv[current_arg], "powerconsumption\0", 17) == 0)
+ {
+ current_arg++;
+
+ if (argv[current_arg] == NULL)
+ {
+
+ rc=ipmi_print_get_power_consmpt_data(intf,watt);
+
+ }
+ else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+ {
+
+ rc = ipmi_print_get_power_consmpt_data(intf, watt);
+ }
+ else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+ {
+ rc = ipmi_print_get_power_consmpt_data(intf, btuphr);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+ }
+ else if (strncmp(argv[current_arg], "powerconsumptionhistory\0", 23) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ rc=ipmi_print_power_consmpt_history(intf,watt);
+
+ }
+ else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+ {
+ rc = ipmi_print_power_consmpt_history(intf, watt);
+ }
+ else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+ {
+ rc = ipmi_print_power_consmpt_history(intf, btuphr);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+
+ }
+
+ else if (strncmp(argv[current_arg], "getpowerbudget\0", 15) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ rc=ipmi_print_power_cap(intf,watt);
+
+ }
+ else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+ {
+ rc = ipmi_print_power_cap(intf, watt);
+ }
+ else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+ {
+ rc = ipmi_print_power_cap(intf, btuphr);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+
+ }
+
+ else if (strncmp(argv[current_arg], "setpowerbudget\0", 15) == 0)
+ {
+ int val;
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+ if (strchr(argv[current_arg], '.'))
+ {
+ lprintf(LOG_ERR, " Cap value in Watts, Btu/hr or percent should be whole number");
+ return -1;
+ }
+ make_int(argv[current_arg],&val);
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_powermonitor_usage();
+ }
+ else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+ {
+ rc=ipmi_set_power_cap(intf,watt,val);
+ }
+ else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+ {
+ rc=ipmi_set_power_cap(intf, btuphr,val);
+ }
+ else if (strncmp(argv[current_arg], "percent\0", 8) == 0)
+ {
+ rc=ipmi_set_power_cap(intf,percent,val);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+
+ }
+
+ else if (strncmp(argv[current_arg], "enablepowercap\0", 15) == 0)
+ {
+ rc = ipmi_set_power_capstatus_command(intf,1);
+ }
+
+ else if (strncmp(argv[current_arg], "disablepowercap\0", 16) == 0)
+ {
+ rc = ipmi_set_power_capstatus_command(intf,0);
+ }
+ else
+ {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+ if (sdrcache != NULL) free_sdr_cache(sdrcache);
+ return(rc);
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_time_to_str
+*
+* Description: This function converts ipmi time format into gmtime format
+* Input: rawTime - ipmi time format
+* Output: strTime - gmtime format
+*
+* Return:
+*
+******************************************************************/
+
+static void
+ipmi_time_to_str(time_t rawTime, char* strTime)
+{
+ struct tm * tm;
+ char *temp;
+ tm = gmtime(&rawTime);
+
+ temp = asctime(tm);
+
+ strcpy(strTime,temp);
+}
+
+#ifdef NOT_USED
+static int ipmi_get_sensor_reading(void *intf ,
+ unsigned char sensorNumber,
+ SensorReadingType* pSensorReadingData);
+/*****************************************************************
+* Function Name: ipmi_get_sensor_reading
+*
+* Description: This function retrieves a raw sensor reading
+* Input: sensorOwner - sensor owner id
+* sensorNumber - sensor id
+* intf - ipmi interface
+* Output: sensorReadingData - ipmi response structure
+* Return: 1 on error
+* 0 if successful
+*
+******************************************************************/
+static int
+ipmi_get_sensor_reading(void *intf ,
+ unsigned char sensorNumber,
+ SensorReadingType* pSensorReadingData)
+{
+ struct ipmi_rq req;
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len;
+ int rc = 0;
+ // uint8_t save_addr;
+
+ memset(&req, 0, sizeof (req));
+ req.msg.netfn = IPMI_NETFN_SE;
+ req.msg.lun = 0;
+ req.msg.cmd = (uint8_t)(GET_SENSOR_READING | 0x0ff);
+ req.msg.data = &sensorNumber;
+ req.msg.data_len = 1;
+
+ if (NULL == pSensorReadingData)
+ return -1;
+ memset(pSensorReadingData,0, sizeof(SensorReadingType));
+
+ rc = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rc) return 1;
+
+ memcpy(pSensorReadingData, rsp, sizeof(SensorReadingType));
+
+ /* if sensor messages are disabled, return error*/
+ if ((!(rsp[1]& 0xC0)) || ((rsp[1] & 0x20))) {
+ rc =1;
+ }
+ return rc;
+}
+#endif
+
+
+/*****************************************************************
+* Function Name: ipmi_get_power_capstatus_command
+*
+* Description: This function gets the power cap status
+* Input: intf - ipmi interface
+* Global: PowercapSetable_flag - power cap status
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int
+ipmi_get_power_capstatus_command (void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[2];
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_DELL_POWER_CAP_STATUS;
+ req.msg.data_len = 2;
+ req.msg.data = data;
+ data[0] = 01;
+ data[1] = 0xFF;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting powercap status: ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",
+ rv,decode_cc(0,rv));
+ return rv;
+ }
+ if (rsp[0]&0x02)
+ PowercapSetable_flag=1;
+ if(rsp[0]&0x01)
+ PowercapstatusFlag=1;
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_set_power_capstatus_command
+*
+* Description: This function sets the power cap status
+* Input: intf - ipmi interface
+* val - power cap status
+* Output:
+*
+* Return:
+*
+******************************************************************/
+
+static int
+ipmi_set_power_capstatus_command (void * intf,uint8_t val)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[2];
+ if(ipmi_get_power_capstatus_command(intf) < 0)
+ return -1;
+
+ if (PowercapSetable_flag!=1)
+ {
+ lprintf(LOG_ERR, " Can not set powercap on this system");
+ return -1;
+ }
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_DELL_POWER_CAP_STATUS;
+ req.msg.data_len = 2;
+ req.msg.data = data;
+
+ data[0] = 00;
+ data[1] = val;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error setting powercap status: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv; //return unlicensed Error code
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_powermgmt
+*
+* Description: This function print the powermonitor details
+* Input: intf - ipmi interface
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_powermgmt(void* intf)
+{
+ time_t now;
+ struct tm* tm;
+ char* dte;
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t msg_data[2];
+ uint32_t cumStartTimeConv;
+ uint32_t cumReadingConv;
+ uint32_t maxPeakStartTimeConv;
+ uint32_t ampPeakTimeConv;
+ uint16_t ampReadingConv;
+ uint32_t wattPeakTimeConv;
+ uint32_t wattReadingConv;
+ uint32_t bmctimeconv;
+ uint32_t * bmctimeconvval;
+
+ IPMI_POWER_MONITOR* pwrMonitorInfo;
+
+
+ char cumStartTime[26];
+ char maxPeakStartTime[26];
+ char ampPeakTime[26];
+ char wattPeakTime[26];
+ char bmctime[26];
+
+ // float cumReading;
+ int ampReading;
+ int wattReading;
+ int ampReadingRemainder;
+ // int round;
+ // int round2;
+ int remainder;
+
+ now = time(0);
+ tm = gmtime(&now);
+ dte = asctime(tm);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_CMD_GET_SEL_TIME;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting BMC time info ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ bmctimeconvval=(uint32_t*)rsp;
+#if WORDS_BIGENDIAN
+ bmctimeconv=BSWAP_32(*bmctimeconvval);
+#else
+ bmctimeconv=*bmctimeconvval;
+#endif
+
+ /* get powermanagement info*/
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0x0;
+ req.msg.cmd = GET_PWRMGMT_INFO_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+
+ memset(msg_data, 0, 2);
+ msg_data[0] = 0x07;
+ msg_data[1] = 0x01;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting power management info ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ pwrMonitorInfo = (IPMI_POWER_MONITOR*)rsp;
+
+#if WORDS_BIGENDIAN
+ cumStartTimeConv = BSWAP_32(pwrMonitorInfo->cumStartTime);
+ cumReadingConv = BSWAP_32(pwrMonitorInfo->cumReading);
+ maxPeakStartTimeConv = BSWAP_32(pwrMonitorInfo->maxPeakStartTime);
+ ampPeakTimeConv = BSWAP_32(pwrMonitorInfo->ampPeakTime);
+ ampReadingConv = BSWAP_16(pwrMonitorInfo->ampReading);
+ wattPeakTimeConv = BSWAP_32(pwrMonitorInfo->wattPeakTime);
+ wattReadingConv = BSWAP_16(pwrMonitorInfo->wattReading);
+#else
+ cumStartTimeConv = pwrMonitorInfo->cumStartTime;
+ cumReadingConv = pwrMonitorInfo->cumReading;
+ maxPeakStartTimeConv = pwrMonitorInfo->maxPeakStartTime;
+ ampPeakTimeConv = pwrMonitorInfo->ampPeakTime;
+ ampReadingConv = pwrMonitorInfo->ampReading;
+ wattPeakTimeConv = pwrMonitorInfo->wattPeakTime;
+ wattReadingConv = pwrMonitorInfo->wattReading;
+#endif
+
+ ipmi_time_to_str(cumStartTimeConv, cumStartTime);
+
+ ipmi_time_to_str(maxPeakStartTimeConv, maxPeakStartTime);
+ ipmi_time_to_str(ampPeakTimeConv, ampPeakTime);
+ ipmi_time_to_str(wattPeakTimeConv, wattPeakTime);
+ ipmi_time_to_str(bmctimeconv, bmctime);
+
+ now = time(0);
+
+
+ remainder = (cumReadingConv % 1000);
+ cumReadingConv = cumReadingConv / 1000;
+ remainder = (remainder + 50) / 100;
+
+ ampReading = ampReadingConv;
+ ampReadingRemainder = ampReading%10;
+ ampReading = ampReading/10;
+
+ wattReading = wattReadingConv;
+
+ printf("Power Tracking Statistics\n");
+ printf("Statistic : Cumulative Energy Consumption\n");
+ printf("Start Time : %s", cumStartTime);
+ printf("Finish Time : %s", bmctime);
+ printf("Reading : %d.%d kWh\n\n", cumReadingConv, remainder);
+
+ printf("Statistic : System Peak Power\n");
+ printf("Start Time : %s", maxPeakStartTime);
+ printf("Peak Time : %s", wattPeakTime);
+ printf("Peak Reading : %d W\n\n", wattReading);
+
+ printf("Statistic : System Peak Amperage\n");
+ printf("Start Time : %s", maxPeakStartTime);
+ printf("Peak Time : %s", ampPeakTime);
+ printf("Peak Reading : %d.%d A\n", ampReading, ampReadingRemainder);
+
+
+ return 0;
+
+}
+/*****************************************************************
+* Function Name: ipmi_powermgmt_clear
+*
+* Description: This function clears peakpower / cumulativepower value
+* Input: intf - ipmi interface
+* clearValue - peakpower / cumulativepower
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int
+ipmi_powermgmt_clear(void* intf,uint8_t clearValue)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t clearType;
+ uint8_t msg_data[3];
+
+ if (clearValue) {
+ clearType = 2;
+ } else {
+ clearType = 1;
+ }
+
+ /* clear powermanagement info*/
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = CLEAR_PWRMGMT_INFO_CMD;
+ req.msg.data = msg_data;
+ req.msg.data_len = 3;
+
+
+ memset(msg_data, 0, 3);
+ msg_data[0] = 0x07;
+ msg_data[1] = 0x01;
+ msg_data[2] = clearType;
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error clearing power values: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ return 0;
+
+}
+
+/*****************************************************************
+* Function Name: watt_to_btuphr_conversion
+*
+* Description: This function converts the power value in watt to btuphr
+* Input: powerinwatt - power in watt
+*
+* Output: power in btuphr
+*
+* Return:
+*
+******************************************************************/
+static uint64_t watt_to_btuphr_conversion(uint32_t powerinwatt)
+{
+ uint64_t powerinbtuphr;
+ powerinbtuphr=(uint64_t)(3.413*powerinwatt);
+
+ return(powerinbtuphr);
+}
+
+/*****************************************************************
+* Function Name: btuphr_to_watt_conversion
+*
+* Description: This function converts the power value in btuphr to watt
+* Input: powerinbtuphr - power in btuphr
+*
+* Output: power in watt
+*
+* Return:
+*
+******************************************************************/
+static uint32_t btuphr_to_watt_conversion(uint64_t powerinbtuphr)
+{
+ uint32_t powerinwatt;
+ /*returning the floor value*/
+ powerinwatt= (uint32_t)(powerinbtuphr/3.413);
+ return (powerinwatt);
+}
+
+/*****************************************************************
+* Function Name: ipmi_get_power_headroom_command
+*
+* Description: This function prints the Power consumption information
+* Input: intf - ipmi interface
+* unit - watt / btuphr
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_get_power_headroom_command (void * intf,uint8_t unit)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint64_t peakpowerheadroombtuphr;
+ uint64_t instantpowerhearoom;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_PWR_HEADROOM_CMD;
+ req.msg.data_len = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting power headroom status: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ if(verbose>1)
+ printf("power headroom Data : %x %x %x %x ",
+ /*need to look into */ rsp[0], rsp[1], rsp[2], rsp[3]);
+ powerheadroom= *(( POWER_HEADROOM *)rsp);
+#if WORDS_BIGENDIAN
+ powerheadroom.instheadroom = BSWAP_16(powerheadroom.instheadroom);
+ powerheadroom.peakheadroom = BSWAP_16(powerheadroom.peakheadroom);
+#endif
+
+ printf ("Headroom\n\r");
+ printf ("Statistic Reading\n\r");
+
+ if(unit == btuphr)
+ {
+ peakpowerheadroombtuphr=watt_to_btuphr_conversion(powerheadroom.peakheadroom);
+ instantpowerhearoom= watt_to_btuphr_conversion(powerheadroom.instheadroom);
+
+ printf ("System Instantaneous Headroom : %ld BTU/hr\n",instantpowerhearoom);
+ printf ("System Peak Headroom : %ld BTU/hr\n",peakpowerheadroombtuphr);
+ }
+ else
+ {
+ printf ("System Instantaneous Headroom : %ld W\n",powerheadroom.instheadroom);
+ printf ("System Peak Headroom : %ld W\n",powerheadroom.peakheadroom);
+ }
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_get_power_consumption_data
+*
+* Description: This function updates the instant Power consumption information
+* Input: intf - ipmi interface
+* Output: power consumption current reading
+* Assumption value will be in Watt.
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_get_power_consumption_data(void* intf,uint8_t unit)
+{
+ int rc = 0;
+ SensorReadingType sensorReadingData;
+ uint8_t rsp[IPMI_RSPBUF_SIZE];
+ struct sdr_record_list *sdr = NULL;
+ uchar sdrbuf[SDR_SZ];
+ double readingf, warningf, failuref;
+ int readingbtuphr=0;
+ int warning_threshbtuphr=0;
+ int failure_thresbtuphr=0;
+ int status=0;
+ int sensor_number = 0;
+
+ if (sdrfile != NULL) {
+ rc = get_sdr_file(sdrfile,&sdrcache);
+ if (rc) printf ("Error 0x%02x: Cannot get SDRs from %s\n",rc,sdrfile);
+ } else if (sdrcache == NULL) {
+ rc = get_sdr_cache(&sdrcache);
+ if (rc) printf ("Error 0x%02x: Cannot get SDRs\n",rc);
+ }
+
+ rc = find_sdr_by_tag(sdrbuf, sdrcache, "System Level", fdebug);
+ if (rc != 0)
+ {
+ printf ("Error %d: Cannot access the System Level sensor data\n",rc);
+ return rc;
+ }
+ sdr = (struct sdr_record_list *)sdrbuf;
+
+ sensor_number = sdrbuf[7]; // sdr->record.full->keys.sensor_num;
+ if (fdebug) printf("calling GetSensorReading(%x)\n",sensor_number);
+ rc = GetSensorReading(sensor_number, sdrbuf,
+ (uchar *)&sensorReadingData.sensorReading);
+ if (rc != 0)
+ printf("Error %d getting sensor %x reading\n",rc,sensor_number);
+
+ rc = GetSensorThresholds( sensor_number, rsp);
+ if (fdebug) printf("GetSensorThresholds(%x) rc = %d\n",sensor_number,rc);
+ if (rc == 0)
+ {
+ readingf = RawToFloat(sensorReadingData.sensorReading,sdrbuf);
+ warningf = RawToFloat(rsp[4], sdrbuf);
+ failuref = RawToFloat(rsp[5], sdrbuf);
+ readingbtuphr = (int)readingf;
+ warning_threshbtuphr = (int)warningf;
+ failure_thresbtuphr = (int)failuref;
+
+ if (fdebug) {
+ printf("Reading 0x%02x = %.2f, Warning 0x%02x = %.2f, Failure 0x%02x = %.2f\n",
+ sensorReadingData.sensorReading, readingf,
+ rsp[4], warningf, rsp[5], failuref);
+ }
+
+ printf ("System Board System Level\n\r");
+ if (unit==btuphr)
+ {
+ readingbtuphr= watt_to_btuphr_conversion(readingbtuphr);
+ warning_threshbtuphr= watt_to_btuphr_conversion(warning_threshbtuphr);
+ failure_thresbtuphr= watt_to_btuphr_conversion( failure_thresbtuphr);
+
+ printf ("Reading : %d BTU/hr\n",readingbtuphr);
+ printf ("Warning threshold : %d BTU/hr\n",warning_threshbtuphr);
+ printf ("Failure threshold : %d BTU/hr\n",failure_thresbtuphr);
+ }
+ else
+ {
+ printf ("Reading : %d W \n",readingbtuphr);
+ printf ("Warning threshold : %d W \n",(warning_threshbtuphr));
+ printf ("Failure threshold : %d W \n",(failure_thresbtuphr));
+ }
+ }
+ else
+ {
+ printf ("Error %d: Cannot access the System Level threshold data\n",rc);
+ return -1;
+ }
+ return status;
+}
+
+
+
+
+/*****************************************************************
+* Function Name: ipmi_get_instan_power_consmpt_data
+*
+* Description: This function updates the instant Power consumption information
+* Input: intf - ipmi interface
+* Output: instpowerconsumptiondata - instant Power consumption information
+*
+* Return:
+*
+******************************************************************/
+
+static int ipmi_get_instan_power_consmpt_data(void* intf,
+ IPMI_INST_POWER_CONSUMPTION_DATA* instpowerconsumptiondata)
+{
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req={0};
+
+ uint8_t msg_data[2];
+
+
+ /*get instantaneous power consumption command*/
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_PWR_CONSUMPTION_CMD;
+
+ req.msg.data = msg_data;
+ req.msg.data_len = 2;
+
+
+
+ memset(msg_data, 0, 2);
+
+ msg_data[0] = 0x0A;
+ msg_data[1] = 0x00;
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting power consumption data: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ * instpowerconsumptiondata = * ( (IPMI_INST_POWER_CONSUMPTION_DATA*) (rsp));
+#if WORDS_BIGENDIAN
+ instpowerconsumptiondata->instanpowerconsumption = BSWAP_16(instpowerconsumptiondata->instanpowerconsumption);
+ instpowerconsumptiondata->instanApms = BSWAP_16(instpowerconsumptiondata->instanApms);
+ instpowerconsumptiondata->resv1 = BSWAP_16(instpowerconsumptiondata->resv1);
+#endif
+
+ return 0;
+
+
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_print_get_instan_power_Amps_data
+*
+* Description: This function prints the instant Power consumption information
+* Input: instpowerconsumptiondata - instant Power consumption information
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static void ipmi_print_get_instan_power_Amps_data(IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata)
+{
+ uint16_t intampsval=0;
+ uint16_t decimalampsval=0;
+
+
+ if (instpowerconsumptiondata.instanApms>0)
+ {
+ decimalampsval=(instpowerconsumptiondata.instanApms%10);
+ intampsval=instpowerconsumptiondata.instanApms/10;
+ }
+ printf("\nAmperage value: %d.%d A \n",intampsval,decimalampsval);
+}
+/*****************************************************************
+* Function Name: ipmi_print_get_power_consmpt_data
+*
+* Description: This function prints the Power consumption information
+* Input: intf - ipmi interface
+* unit - watt / btuphr
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_print_get_power_consmpt_data(void* intf,uint8_t unit)
+{
+
+ int rc = 0;
+ IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata = {0,0,0,0};
+ // int i;
+ //uint16_t inputwattageL=0;
+ //int sensorIndex = 0;
+ //uint32_t readingbtuphr;
+ //uint32_t warning_threshbtuphr;
+ //uint32_t failure_thresbtuphr;
+
+ printf ("\nPower consumption information\n");
+
+
+ rc=ipmi_get_power_consumption_data(intf,unit);
+ if (-1 == rc)
+ return rc;
+
+ rc=ipmi_get_instan_power_consmpt_data(intf,&instpowerconsumptiondata);
+ if (-1 == rc)
+ return rc;
+
+ ipmi_print_get_instan_power_Amps_data(instpowerconsumptiondata);
+
+
+ rc=ipmi_get_power_headroom_command(intf,unit);
+
+ if (-1 == rc)
+ return rc;
+
+ return rc;
+
+
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_get_avgpower_consmpt_history
+*
+* Description: This function updates the average power consumption information
+* Input: intf - ipmi interface
+* Output: pavgpower- average power consumption information
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_get_avgpower_consmpt_history(void* intf,IPMI_AVGPOWER_CONSUMP_HISTORY* pavgpower )
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = 0xeb;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting average power consumption data: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ if (verbose > 1)
+ {
+ printf("Average power consumption history Data :%x %x %x %x %x %x %x %x\n\n",
+ rsp[0], rsp[1], rsp[2], rsp[3],
+ rsp[4], rsp[5], rsp[6], rsp[7]);
+
+ }
+
+ *pavgpower = *( (IPMI_AVGPOWER_CONSUMP_HISTORY*) rsp);
+#if WORDS_BIGENDIAN
+ pavgpower->lastminutepower = BSWAP_16(pavgpower->lastminutepower);
+ pavgpower->lasthourpower = BSWAP_16(pavgpower->lasthourpower);
+ pavgpower->lastdaypower = BSWAP_16(pavgpower->lastdaypower);
+ pavgpower->lastweakpower = BSWAP_16(pavgpower->lastweakpower);
+#endif
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_get_peakpower_consmpt_history
+*
+* Description: This function updates the peak power consumption information
+* Input: intf - ipmi interface
+* Output: pavgpower- peak power consumption information
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_get_peakpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstPeakpower)
+{
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = 0xec;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting peak power consumption history: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ if (verbose > 1)
+ {
+ printf("Peak power consmhistory Data : %x %x %x %x %x %x %x %x %x %x\n %x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
+ rsp[0], rsp[1], rsp[2], rsp[3],
+ rsp[4], rsp[5], rsp[6], rsp[7],
+ rsp[8], rsp[9], rsp[10], rsp[11],
+ rsp[12], rsp[13], rsp[14], rsp[15],
+ rsp[16], rsp[17], rsp[18], rsp[19],
+ rsp[20], rsp[21], rsp[22], rsp[23]
+ );
+
+ }
+ *pstPeakpower =* ((IPMI_POWER_CONSUMP_HISTORY*)rsp);
+#if WORDS_BIGENDIAN
+ pstPeakpower->lastminutepower = BSWAP_16(pstPeakpower->lastminutepower);
+ pstPeakpower->lasthourpower = BSWAP_16(pstPeakpower->lasthourpower);
+ pstPeakpower->lastdaypower = BSWAP_16(pstPeakpower->lastdaypower);
+ pstPeakpower->lastweakpower = BSWAP_16(pstPeakpower->lastweakpower);
+ pstPeakpower->lastminutepowertime = BSWAP_32(pstPeakpower->lastminutepowertime);
+ pstPeakpower->lasthourpowertime = BSWAP_32(pstPeakpower->lasthourpowertime);
+ pstPeakpower->lastdaypowertime = BSWAP_32(pstPeakpower->lastdaypowertime);
+ pstPeakpower->lastweekpowertime = BSWAP_32(pstPeakpower->lastweekpowertime);
+#endif
+ return 0;
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_get_minpower_consmpt_history
+*
+* Description: This function updates the peak power consumption information
+* Input: intf - ipmi interface
+* Output: pavgpower- peak power consumption information
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_get_minpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstMinpower)
+{
+
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[4];
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+ data[0] = 0;
+ data[1] = 0xed;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting min power consumption history: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ if (verbose > 1)
+ {
+ printf("Peak power consmhistory Data : %x %x %x %x %x %x %x %x %x %x\n %x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
+ rsp[0], rsp[1], rsp[2], rsp[3],
+ rsp[4], rsp[5], rsp[6], rsp[7],
+ rsp[8], rsp[9], rsp[10], rsp[11],
+ rsp[12], rsp[13], rsp[14], rsp[15],
+ rsp[16], rsp[17], rsp[18], rsp[19],
+ rsp[20], rsp[21], rsp[22], rsp[23]
+ );
+
+ }
+ *pstMinpower =* ((IPMI_POWER_CONSUMP_HISTORY*)rsp);
+#if WORDS_BIGENDIAN
+ pstMinpower->lastminutepower = BSWAP_16(pstMinpower->lastminutepower);
+ pstMinpower->lasthourpower = BSWAP_16(pstMinpower->lasthourpower);
+ pstMinpower->lastdaypower = BSWAP_16(pstMinpower->lastdaypower);
+ pstMinpower->lastweakpower = BSWAP_16(pstMinpower->lastweakpower);
+ pstMinpower->lastminutepowertime = BSWAP_32(pstMinpower->lastminutepowertime);
+ pstMinpower->lasthourpowertime = BSWAP_32(pstMinpower->lasthourpowertime);
+ pstMinpower->lastdaypowertime = BSWAP_32(pstMinpower->lastdaypowertime);
+ pstMinpower->lastweekpowertime = BSWAP_32(pstMinpower->lastweekpowertime);
+#endif
+ return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_print_power_consmpt_history
+*
+* Description: This function print the average and peak power consumption information
+* Input: intf - ipmi interface
+* unit - watt / btuphr
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int ipmi_print_power_consmpt_history(void* intf,int unit )
+{
+
+ char timestr[30];
+
+ uint32_t lastminutepeakpower;
+ uint32_t lasthourpeakpower;
+ uint32_t lastdaypeakpower;
+ uint32_t lastweekpeakpower;
+
+ IPMI_AVGPOWER_CONSUMP_HISTORY avgpower;
+ IPMI_POWER_CONSUMP_HISTORY stMinpower;
+ IPMI_POWER_CONSUMP_HISTORY stPeakpower;
+ int rc=0;
+
+ uint64_t tempbtuphrconv;
+ //uint16_t temp;
+
+
+ rc= ipmi_get_avgpower_consmpt_history(intf,&avgpower);
+ if (-1 == rc)
+ return rc;
+
+ rc= ipmi_get_peakpower_consmpt_history(intf,&stPeakpower);
+ if (-1 == rc)
+ return rc;
+
+ rc= ipmi_get_minpower_consmpt_history(intf,&stMinpower);
+ if (-1 == rc)
+ return rc;
+
+
+ if(rc==0)
+ {
+ printf ("Power Consumption History\n\r\n\r");
+ /* The fields are alligned manually changing the spaces will alter the alignment*/
+ printf ("Statistic Last Minute Last Hour Last Day Last Week\n\r\n\r");
+
+ if (unit ==btuphr)
+ {
+ printf ("Average Power Consumption ");
+ tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastminutepower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lasthourpower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastdaypower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastweakpower);
+ printf ("%4d BTU/hr\n\r",tempbtuphrconv);
+
+ printf ("Max Power Consumption ");
+ tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastminutepower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lasthourpower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastdaypower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastweakpower);
+ printf ("%4d BTU/hr\n\r",tempbtuphrconv);
+
+ printf ("Min Power Consumption ");
+ tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastminutepower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lasthourpower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastdaypower);
+ printf ("%4d BTU/hr ",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastweakpower);
+ printf ("%4d BTU/hr\n\r\n\r",tempbtuphrconv);
+
+ }
+ else
+ {
+
+ printf ("Average Power Consumption ");
+ tempbtuphrconv=(avgpower.lastminutepower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(avgpower.lasthourpower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(avgpower.lastdaypower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(avgpower.lastweakpower);
+ printf ("%4ld W \n\r",tempbtuphrconv);
+
+ printf ("Max Power Consumption ");
+ tempbtuphrconv=(stPeakpower.lastminutepower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stPeakpower.lasthourpower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stPeakpower.lastdaypower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stPeakpower.lastweakpower);
+ printf ("%4ld W \n\r",tempbtuphrconv);
+
+ printf ("Min Power Consumption ");
+ tempbtuphrconv=(stMinpower.lastminutepower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stMinpower.lasthourpower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stMinpower.lastdaypower);
+ printf ("%4ld W ",tempbtuphrconv);
+ tempbtuphrconv=(stMinpower.lastweakpower);
+ printf ("%4ld W \n\r\n\r",tempbtuphrconv);
+ }
+
+ lastminutepeakpower=stPeakpower.lastminutepowertime;
+ lasthourpeakpower=stPeakpower.lasthourpowertime;
+ lastdaypeakpower=stPeakpower.lastdaypowertime;
+ lastweekpeakpower=stPeakpower.lastweekpowertime;
+
+ printf ("Max Power Time\n\r");
+ ipmi_time_to_str(lastminutepeakpower, timestr);
+ printf ("Last Minute : %s",timestr);
+ ipmi_time_to_str(lasthourpeakpower, timestr);
+ printf ("Last Hour : %s",timestr);
+ ipmi_time_to_str(lastdaypeakpower, timestr);
+ printf ("Last Day : %s",timestr);
+ ipmi_time_to_str(lastweekpeakpower, timestr);
+ printf ("Last Week : %s",timestr);
+
+
+ lastminutepeakpower=stMinpower.lastminutepowertime;
+ lasthourpeakpower=stMinpower.lasthourpowertime;
+ lastdaypeakpower=stMinpower.lastdaypowertime;
+ lastweekpeakpower=stMinpower.lastweekpowertime;
+
+ printf ("Min Power Time\n\r");
+ ipmi_time_to_str(lastminutepeakpower, timestr);
+ printf ("Last Minute : %s",timestr);
+ ipmi_time_to_str(lasthourpeakpower, timestr);
+ printf ("Last Hour : %s",timestr);
+ ipmi_time_to_str(lastdaypeakpower, timestr);
+ printf ("Last Day : %s",timestr);
+ ipmi_time_to_str(lastweekpeakpower, timestr);
+ printf ("Last Week : %s",timestr);
+
+ }
+ return rc;
+
+}
+
+
+
+/*****************************************************************
+* Function Name: ipmi_get_power_cap
+*
+* Description: This function updates the power cap information
+* Input: intf - ipmi interface
+* Output: ipmipowercap - power cap information
+*
+* Return:
+*
+******************************************************************/
+
+static int ipmi_get_power_cap(void* intf,IPMI_POWER_CAP* ipmipowercap )
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req={0};
+ //uint64_t tempbtuphrconv;
+ uint8_t data[4];
+
+ /* power supply rating command*/
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+
+ data[0] = 0;
+ data[1] = IPMI_DELL_POWER_CAP;
+ data[2] = 0;
+ data[3] = 0;
+
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting power cap: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ if (verbose > 1){
+ printf("power cap Data :%x %x %x %x %x %x %x %x %x %x %x",
+ rsp[1], rsp[2], rsp[3],
+ rsp[4], rsp[5], rsp[6], rsp[7],
+ rsp[8], rsp[9], rsp[10],rsp[11]);
+
+ }
+
+ * ipmipowercap = *((IPMI_POWER_CAP*)(rsp));
+#if WORDS_BIGENDIAN
+ ipmipowercap->PowerCap = BSWAP_16(ipmipowercap->PowerCap);
+ ipmipowercap->MaximumPowerConsmp = BSWAP_16(ipmipowercap->MaximumPowerConsmp);
+ ipmipowercap->MinimumPowerConsmp = BSWAP_16(ipmipowercap->MinimumPowerConsmp);
+ ipmipowercap->totalnumpowersupp = BSWAP_16(ipmipowercap->totalnumpowersupp);
+ ipmipowercap->AvailablePower = BSWAP_16(ipmipowercap->AvailablePower);
+ ipmipowercap->SystemThrottling = BSWAP_16(ipmipowercap->SystemThrottling);
+ ipmipowercap->Resv = BSWAP_16(ipmipowercap->Resv);
+#endif
+
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_print_power_cap
+*
+* Description: This function print the power cap information
+* Input: intf - ipmi interface
+* unit - watt / btuphr
+* Output:
+* Return:
+*
+******************************************************************/
+static int ipmi_print_power_cap(void* intf,uint8_t unit )
+{
+ uint64_t tempbtuphrconv;
+ int rc;
+ IPMI_POWER_CAP ipmipowercap;
+
+ memset(&ipmipowercap,0,sizeof(ipmipowercap));
+ rc=ipmi_get_power_cap(intf,&ipmipowercap);
+
+
+ if (rc==0)
+ {
+ if (unit ==btuphr){
+ tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+ printf ("Maximum power: %ld BTU/hr\n",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.MinimumPowerConsmp);
+ printf ("Minimum power: %ld BTU/hr\n",tempbtuphrconv);
+ tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.PowerCap);
+ printf ("Power cap : %ld BTU/hr\n",tempbtuphrconv);
+ }else{
+
+ printf ("Maximum power: %ld Watt\n",ipmipowercap.MaximumPowerConsmp);
+ printf ("Minimum power: %ld Watt\n",ipmipowercap.MinimumPowerConsmp);
+ printf ("Power cap : %ld Watt\n",ipmipowercap.PowerCap);
+ }
+ }
+ return rc;
+
+}
+
+/*****************************************************************
+* Function Name: ipmi_set_power_cap
+*
+* Description: This function updates the power cap information
+* Input: intf - ipmi interface
+* unit - watt / btuphr
+* val - new power cap value
+* Output:
+* Return:
+*
+******************************************************************/
+static int ipmi_set_power_cap(void* intf,int unit,int val )
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req={0};
+ uint8_t data[13];
+ uint16_t powercapval;
+ uint64_t maxpowerbtuphr;
+ uint64_t maxpowerbtuphr1;
+ uint64_t minpowerbtuphr;
+ IPMI_POWER_CAP ipmipowercap;
+
+ if(ipmi_get_power_capstatus_command(intf) < 0)
+ return -1; // Adding the failed condition check
+
+ if (PowercapSetable_flag!=1)
+ {
+ lprintf(LOG_ERR, " Can not set powercap on this system");
+ return -1;
+ }
+ else if(PowercapstatusFlag!=1)
+ {
+ lprintf(LOG_ERR, " Power cap set feature is not enabled");
+ return -1;
+ }
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data_len = 4;
+ memset(data, 0, 4);
+ req.msg.data = data;
+
+ data[0] = 0;
+ data[1] = IPMI_DELL_POWER_CAP;
+ data[2] = 0;
+ data[3] = 0;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting power cap: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ if (verbose > 1)
+ {
+ printf("power cap Data :%x %x %x %x %x %x %x %x %x %x ",
+ rsp[1], rsp[2], rsp[3],
+ rsp[4], rsp[5], rsp[6], rsp[7],
+ rsp[8], rsp[9], rsp[10],rsp[11]);
+
+ }
+
+ ipmipowercap.PowerCap=((rsp[1]<<8)+rsp[2]);
+ ipmipowercap.unit=rsp[3];
+ ipmipowercap.MaximumPowerConsmp=((rsp[4]<<8)+rsp[5]);
+ ipmipowercap.MinimumPowerConsmp=((rsp[6]<<8)+rsp[7]);
+ /* ARC: need Dell to verify these 3 values */
+ ipmipowercap.totalnumpowersupp = rsp[8];
+ ipmipowercap.AvailablePower = ((rsp[9]<<8)+rsp[10]);
+ ipmipowercap.SystemThrottling = rsp[11];
+
+ memset(data, 0, 13);
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_SET_SYS_INFO;
+ req.msg.data_len = 13;
+ req.msg.data = data;
+ data[0] = IPMI_DELL_POWER_CAP;
+ powercapval=val;
+
+
+ data[1] = (powercapval&0XFF);
+ data[2] = ((powercapval&0XFF00)>>8);
+ data[3] = unit;
+
+ data[4]=((ipmipowercap.MaximumPowerConsmp&0xFF));
+ data[5]=((ipmipowercap.MaximumPowerConsmp&0xFF00)>>8);
+ data[6]=((ipmipowercap.MinimumPowerConsmp&0xFF));
+ data[7]=((ipmipowercap.MinimumPowerConsmp&0xFF00)>>8);
+ data[8]=(uint8_t)(ipmipowercap.totalnumpowersupp);
+ data[9]=((ipmipowercap.AvailablePower&0xFF));
+ data[10]=((ipmipowercap.AvailablePower&0xFF00)>>8);
+ data[11]=(uint8_t)(ipmipowercap.SystemThrottling);
+ data[12]=0x00;
+
+ ipmipowercap.MaximumPowerConsmp = BSWAP_16(ipmipowercap.MaximumPowerConsmp);
+ ipmipowercap.MinimumPowerConsmp = BSWAP_16(ipmipowercap.MinimumPowerConsmp);
+ ipmipowercap.PowerCap = BSWAP_16(ipmipowercap.PowerCap);
+ if(unit==btuphr)
+ {
+ val = btuphr_to_watt_conversion(val);
+
+ }
+ else if(unit ==percent)
+ {
+ if((val <0)||(val>100))
+ {
+ lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between 0 - 100");
+ return -1;
+ }
+ val =( (val*(ipmipowercap.MaximumPowerConsmp -ipmipowercap.MinimumPowerConsmp))/100)+ipmipowercap.MinimumPowerConsmp;
+ lprintf(LOG_ERR, " Cap value in percentage is %d ",val);
+ data[1] = (val&0XFF);
+ data[2] = ((val&0XFF00)>>8);
+ data[3] = watt;
+ }
+ if(((val<ipmipowercap.MinimumPowerConsmp)||(val>ipmipowercap.MaximumPowerConsmp))&&(unit==watt))
+ {
+ lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between %d - %d",
+ ipmipowercap.MinimumPowerConsmp,ipmipowercap.MaximumPowerConsmp);
+ return -1;
+ }
+ else if(((val<ipmipowercap.MinimumPowerConsmp)||(val>ipmipowercap.MaximumPowerConsmp))&&(unit==btuphr))
+ {
+ minpowerbtuphr= watt_to_btuphr_conversion(ipmipowercap.MinimumPowerConsmp);
+ maxpowerbtuphr=watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+ maxpowerbtuphr1= watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+ lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between %d",
+ minpowerbtuphr);
+ lprintf(LOG_ERR, " -%d",
+ maxpowerbtuphr1);
+
+ return -1;
+ }
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error setting power cap: ");
+ if (rv < 0) printf("no response\n");
+ else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+ printf("FM001 : A required license is missing or expired\n");
+ return rv;
+ }
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+ if (verbose > 1)
+ {
+ printf("CC for setpowercap :%d ",rv);
+ }
+ return 0;
+}
+
+#ifdef NOT_USED
+static int getpowersupplyfruinfo(void *intf, uint8_t id,
+ struct fru_header header, struct fru_info fru);
+/*****************************************************************
+* Function Name: getpowersupplyfruinfo
+*
+* Description: This function retrieves the FRU header
+* Input: intf - ipmi interface
+* header - watt / btuphr
+* fru - FRU information
+* Output: header - FRU header
+* Return:
+*
+******************************************************************/
+static int getpowersupplyfruinfo(void *intf, uint8_t id,
+ struct fru_header header, struct fru_info fru)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[4];
+
+ memset(&fru, 0, sizeof(struct fru_info));
+ memset(&header, 0, sizeof(struct fru_header));
+
+ /*
+ * get info about this FRU
+ */
+ memset(msg_data, 0, 4);
+ msg_data[0] = id;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_FRU_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Device not present, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ fru.size = (rsp[1] << 8) | rsp[0];
+ fru.access = rsp[2] & 0x1;
+
+ lprintf(LOG_DEBUG, "fru.size = %d bytes (accessed by %s)",
+ fru.size, fru.access ? "words" : "bytes");
+
+ if (fru.size < 1) {
+ printf(" Invalid FRU size %d", fru.size);
+ return -1;
+ }
+
+ /*
+ * retrieve the FRU header
+ */
+ msg_data[0] = id;
+ msg_data[1] = 0;
+ msg_data[2] = 0;
+ msg_data[3] = 8;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_FRU_DATA;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Device not present, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ if (verbose > 1)
+ printbuf(rsp, rsp_len, "FRU DATA");
+
+ memcpy(&header, &rsp[1], 8);
+
+ return 0;
+
+
+}
+#endif
+
+/*****************************************************************
+* Function Name: ipmi_powermonitor_usage
+*
+* Description: This function prints help message for powermonitor command
+* Input:
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static void
+ipmi_powermonitor_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor");
+ lprintf(LOG_NOTICE, " Shows power tracking statistics ");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor clear cumulativepower");
+ lprintf(LOG_NOTICE, " Reset cumulative power reading");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor clear peakpower");
+ lprintf(LOG_NOTICE, " Reset peak power reading");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor powerconsumption");
+ lprintf(LOG_NOTICE, " Displays power consumption in <watt|btuphr>");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor powerconsumptionhistory <watt|btuphr>");
+ lprintf(LOG_NOTICE, " Displays power consumption history ");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor getpowerbudget");
+ lprintf(LOG_NOTICE, " Displays power cap in <watt|btuphr>");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor setpowerbudget <val><watt|btuphr|percent>");
+ lprintf(LOG_NOTICE, " Allows user to set the power cap in <watt|BTU/hr|percentage>");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor enablepowercap ");
+ lprintf(LOG_NOTICE, " To enable set power cap");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " powermonitor disablepowercap ");
+ lprintf(LOG_NOTICE, " To disable set power cap");
+ lprintf(LOG_NOTICE, "");
+
+}
+/*****************************************************************
+* Function Name: ipmi_delloem_vFlash_main
+*
+* Description: This function processes the delloem vFlash command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_vFlash_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ current_arg++;
+ rc = ipmi_delloem_vFlash_process(intf, current_arg, argv);
+ return(rc);
+}
+
+
+
+/*****************************************************************
+* Function Name: get_vFlash_compcode_str
+*
+* Description: This function maps the vFlash completion code
+* to a string
+* Input : vFlash completion code and static array of codes vs strings
+* Output: -
+* Return: returns the mapped string
+*
+******************************************************************/
+const char *
+get_vFlash_compcode_str(uint8_t vflashcompcode, const struct vFlashstr *vs)
+{
+ static char un_str[32];
+ int i;
+
+ for (i = 0; vs[i].str != NULL; i++) {
+ if (vs[i].val == vflashcompcode)
+ return vs[i].str;
+ }
+
+ memset(un_str, 0, 32);
+ snprintf(un_str, 32, "Unknown (0x%02X)", vflashcompcode);
+
+ return un_str;
+}
+
+/*****************************************************************
+* Function Name: ipmi_get_sd_card_info
+*
+* Description: This function prints the vFlash Extended SD card info
+* Input : ipmi interface
+* Output: prints the sd card extended info
+* Return: 0 - success -1 - failure
+*
+******************************************************************/
+static int
+ipmi_get_sd_card_info(void* intf) {
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req;
+
+ uint8_t msg_data[2];
+ uint8_t input_length=0;
+ uint8_t cardstatus=0x00;
+
+ IPMI_DELL_SDCARD_INFO * sdcardinfoblock;
+
+ input_length = 2;
+ msg_data[0] = msg_data[1] = 0x00;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_EXT_SD_CARD_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error getting SD Card Extended info, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+ return rv;
+ }
+
+ sdcardinfoblock = (IPMI_DELL_SDCARD_INFO *) (void *) rsp;
+
+ if( (iDRAC_FLAG == IDRAC_12G) && (sdcardinfoblock->vflashcompcode == VFL_NOT_LICENSED))
+ {
+ printf("FM001 : A required license is missing or expired\n");
+ return -1;
+ }
+ else if (sdcardinfoblock->vflashcompcode != 0x00)
+ {
+ lprintf(LOG_ERR, " Error in getting SD Card Extended Information (%s) \n", get_vFlash_compcode_str(sdcardinfoblock->vflashcompcode,
+ vFlash_completion_code_vals));
+ return -1;
+ }
+
+ if (!(sdcardinfoblock->sdcardstatus & 0x04))
+ {
+ lprintf(LOG_ERR, " vFlash SD card is unavailable, please insert the card\n of size 256MB or greater\n");
+ return 0;
+ }
+
+ printf("vFlash SD Card Properties\n");
+ printf("SD Card size : %8dMB\n",sdcardinfoblock->sdcardsize);
+ printf("Available size : %8dMB\n",sdcardinfoblock->sdcardavailsize);
+ printf("Initialized : %10s\n", (sdcardinfoblock->sdcardstatus & 0x80) ?
+ "Yes" : "No");
+ printf("Licensed : %10s\n", (sdcardinfoblock->sdcardstatus & 0x40) ?
+ "Yes" : "No");
+ printf("Attached : %10s\n", (sdcardinfoblock->sdcardstatus & 0x20) ?
+ "Yes" : "No");
+ printf("Enabled : %10s\n", (sdcardinfoblock->sdcardstatus & 0x10) ?
+ "Yes" : "No");
+ printf("Write Protected : %10s\n", (sdcardinfoblock->sdcardstatus & 0x08) ?
+ "Yes" : "No");
+ cardstatus = sdcardinfoblock->sdcardstatus & 0x03;
+ printf("Health : %10s\n", ((0x00 == cardstatus
+ ) ? "OK" : ((cardstatus == 0x03) ?
+ "Undefined" : ((cardstatus == 0x02) ?
+ "Critical" : "Warning"))));
+ printf("Bootable partition : %10d\n",sdcardinfoblock->bootpartion);
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_vFlash_process
+*
+* Description: This function processes the args for vFlash subcmd
+* Input : intf - ipmi interface, arg index, argv array
+* Output: prints help or error with help
+* Return: 0 - Success -1 - failure
+*
+******************************************************************/
+static int
+ipmi_delloem_vFlash_process(void* intf, int current_arg, char ** argv)
+{
+ int rc = 0;
+ int drv;
+
+ drv = get_driver_type();
+ if (drv != DRV_MV) /* MV open driver */
+ {
+ lprintf(LOG_ERR, " vFlash support is enabled only for wmi and open interface.\n Its not enabled for lan and lanplus interface.");
+ return -1;
+ }
+
+ if (argv[current_arg] == NULL || strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_vFlash_usage();
+ return 0;
+ }
+ ipmi_idracvalidator_command(intf);
+ if (!strncmp(argv[current_arg], "info\0", 5))
+ {
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_vFlash_usage();
+ return -1;
+ }
+ else if (strncmp(argv[current_arg], "Card\0", 5) == 0)
+ {
+ current_arg++;
+ if (argv[current_arg] != NULL)
+ {
+ ipmi_vFlash_usage();
+ return -1;
+ }
+ rc = ipmi_get_sd_card_info(intf);
+ return rc;
+ }
+ else /* TBD: many sub commands are present */
+ {
+ ipmi_vFlash_usage();
+ return -1;
+ }
+ }
+ /* TBD other vFlash subcommands */
+ else
+ {
+ ipmi_vFlash_usage();
+ return -1;
+ }
+ return(rc);
+}
+
+/*****************************************************************
+* Function Name: ipmi_vFlash_usage
+*
+* Description: This function displays the usage for using vFlash
+* Input : void
+* Output: prints help
+* Return: void
+*
+******************************************************************/
+static void
+ipmi_vFlash_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " vFlash info Card");
+ lprintf(LOG_NOTICE, " Shows Extended SD Card information");
+ lprintf(LOG_NOTICE, "");
+}
+/*****************************************************************
+* Function Name: ipmi_delloem_windbg_main
+*
+* Description: This function processes the delloem windbg command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_windbg_main (void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ current_arg++;
+ if (argv[current_arg] == NULL)
+ {
+ ipmi_windbg_usage();
+ return -1;
+ }
+ if (strncmp(argv[current_arg], "start\0", 6) == 0)
+ {
+ rc = ipmi_windbg_start(intf);
+ }
+ else if (strncmp(argv[current_arg], "end\0", 4) == 0)
+ {
+ rc = ipmi_windbg_end(intf);
+ }
+ else
+ {
+ ipmi_windbg_usage();
+ }
+ return(rc);
+}
+
+/*****************************************************************
+* Function Name: ipmi_windbg_start
+*
+* Description: This function Starts the windbg
+* Input : void
+* Output: Start the debug
+* Return: void
+*
+******************************************************************/
+static int
+ipmi_windbg_start (void * intf)
+{
+ int rc;
+ lprintf(LOG_NOTICE, "Issuing sol activate");
+ lprintf(LOG_NOTICE, "");
+
+ rc = ipmi_sol_activate(intf,0,0);
+ if (rc) lprintf(LOG_NOTICE, "Can not issue sol activate");
+ else windbgsession = 1;
+ return(rc);
+}
+
+/*****************************************************************
+* Function Name: ipmi_windbg_end
+*
+* Description: This function ends the windbg
+* Input : void
+* Output: End the debug
+* Return: void
+*
+******************************************************************/
+
+static int
+ipmi_windbg_end(void * intf)
+{
+ int rc;
+ lprintf(LOG_NOTICE, "Issuing sol deactivate");
+ lprintf(LOG_NOTICE, "");
+ rc = ipmi_sol_deactivate(intf);
+ if (rc) lprintf(LOG_NOTICE, "Can not issue sol deactivate");
+ else windbgsession = 0;
+ return(rc);
+}
+
+
+/*****************************************************************
+* Function Name: ipmi_windbg_usage
+*
+* Description: This function displays the usage for using windbg
+* Input : void
+* Output: prints help
+* Return: void
+*
+******************************************************************/
+
+static void
+ipmi_windbg_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " windbg start");
+ lprintf(LOG_NOTICE, " Starts the windbg session (Cold Reset & SOL Activation)");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " windbg end");
+ lprintf(LOG_NOTICE, " Ends the windbg session (SOL Deactivation");
+ lprintf(LOG_NOTICE, "");
+}
+
+
+
+/**********************************************************************
+* Function Name: ipmi_setled_usage
+*
+* Description: This function prints help message for setled command
+* Input:
+* Output:
+*
+* Return:
+*
+***********************************************************************/
+static void
+ipmi_setled_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " setled <b:d.f> <state..>");
+ lprintf(LOG_NOTICE, " Set backplane LED state");
+ lprintf(LOG_NOTICE, " b:d.f = PCI Bus:Device.Function of drive (lspci format)");
+ lprintf(LOG_NOTICE, " state = present|online|hotspare|identify|rebuilding|");
+ lprintf(LOG_NOTICE, " fault|predict|critical|failed");
+ lprintf(LOG_NOTICE, "");
+}
+
+static void
+ipmi_delloem_getled_usage(void)
+{
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " getled ");
+ lprintf(LOG_NOTICE, " Get Chassis ID LED state");
+ lprintf(LOG_NOTICE, "");
+}
+
+static int
+IsSetLEDSupported(void)
+{
+ return SetLEDSupported;
+}
+
+static int
+CheckSetLEDSupport(void * intf)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[10];
+
+ SetLEDSupported = 0;
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = 0xD5; /* Storage */
+ req.msg.data_len = sizeof(data); /*10*/
+ req.msg.data = data;
+
+ memset(data, 0, sizeof(data));
+ data[0] = 0x01; // get
+ data[1] = 0x00; // subcmd:get firmware version
+ data[2] = 0x08; // length lsb
+ data[3] = 0x00; // length msb
+ data[4] = 0x00; // offset lsb
+ data[5] = 0x00; // offset msb
+ data[6] = 0x00; // bay id
+ data[7] = 0x00;
+ data[8] = 0x00;
+ data[9] = 0x00;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv == 0) SetLEDSupported = 1;
+ return(rv);
+}
+
+/*****************************************************************
+* Function Name: ipmi_getdrivemap
+*
+* Description: This function returns mapping of BDF to Bay:Slot
+* Input: intf - ipmi interface
+* bdf - PCI Address of drive
+* *bay - Returns bay ID
+ *slot - Returns slot ID
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int
+ipmi_getdrivemap(void * intf, int b, int d, int f, int *bay, int *slot)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[8];
+
+ /* Get mapping of BDF to bay:slot */
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = 0xD5;
+ req.msg.data_len = 8;
+ req.msg.data = data;
+
+ memset(data, 0, sizeof(data));
+ data[0] = 0x01; // get
+ data[1] = 0x07; // storage map
+ data[2] = 0x06; // length lsb
+ data[3] = 0x00; // length msb
+ data[4] = 0x00; // offset lsb
+ data[5] = 0x00; // offset msb
+ data[6] = b; // bus
+ data[7] = (d << 3) + f; // devfn
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error issuing getdrivemap command, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+ return rv;
+ }
+
+ *bay = rsp[7];
+ *slot = rsp[8];
+ if (*bay == 0xFF || *slot == 0xFF)
+ {
+ lprintf(LOG_ERR, "Error could not get drive bay:slot mapping");
+ return -1;
+ }
+ return 0;
+}
+
+/*****************************************************************
+* Function Name: ipmi_setled_state
+*
+* Description: This function updates the LED on the backplane
+* Input: intf - ipmi interface
+* bdf - PCI Address of drive
+* state - SES Flags state of drive
+* Output:
+*
+* Return:
+*
+******************************************************************/
+static int
+ipmi_setled_state (void * intf, int bayId, int slotId, int state)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[20];
+
+ /* Issue Drive Status Update to bay:slot */
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = 0xD5;
+ req.msg.data_len = 20;
+ req.msg.data = data;
+
+ memset(data, 0, sizeof(data));
+ data[0] = 0x00; // set
+ data[1] = 0x04; // set drive status
+ data[2] = 0x0e; // length lsb
+ data[3] = 0x00; // length msb
+ data[4] = 0x00; // offset lsb
+ data[5] = 0x00; // offset msb
+ data[6] = 0x0e; // length lsb
+ data[7] = 0x00; // length msb
+ data[8] = bayId; // bayid
+ data[9] = slotId; // slotid
+ data[10] = state & 0xff; // state LSB
+ data[11] = state >> 8; // state MSB;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error issuing setled command, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+ return rv;
+ }
+
+ return 0;
+}
+
+int ipmi_delloem_getled_state (void * intf, uint8_t *state)
+{
+ uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+ struct ipmi_rq req = {0};
+ uint8_t data[2];
+ uint8_t led_state = 0;
+
+ req.msg.netfn = IPMI_DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_CHASSIS_LED_STATE;
+ req.msg.data_len = 0;
+ req.msg.data = data;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv) {
+ printf(" Error issuing getled command, ");
+ if (rv < 0) printf("no response\n");
+ else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+ } else {
+ led_state = rsp[0];
+ }
+ *state = led_state;
+ return rv;
+}
+
+/*****************************************************************
+* Function Name: ipmi_getsesmask
+*
+* Description: This function calculates bits in SES drive update
+* Return: Mask set with bits for SES backplane update
+*
+******************************************************************/
+static int ipmi_getsesmask(int argc, char **argv)
+{
+ int mask = 0;
+ //int idx;
+
+ while (current_arg < argc) {
+ if (!strcmp(argv[current_arg], "present"))
+ mask |= (1L << 0);
+ if (!strcmp(argv[current_arg], "online"))
+ mask |= (1L << 1);
+ if (!strcmp(argv[current_arg], "hotspare"))
+ mask |= (1L << 2);
+ if (!strcmp(argv[current_arg], "identify"))
+ mask |= (1L << 3);
+ if (!strcmp(argv[current_arg], "rebuilding"))
+ mask |= (1L << 4);
+ if (!strcmp(argv[current_arg], "fault"))
+ mask |= (1L << 5);
+ if (!strcmp(argv[current_arg], "predict"))
+ mask |= (1L << 6);
+ if (!strcmp(argv[current_arg], "critical"))
+ mask |= (1L << 9);
+ if (!strcmp(argv[current_arg], "failed"))
+ mask |= (1L << 10);
+ current_arg++;
+ }
+ return mask;
+}
+
+/*****************************************************************
+* Function Name: ipmi_delloem_setled_main
+*
+* Description: This function processes the delloem setled command
+* Input: intf - ipmi interface
+ argc - no of arguments
+ argv - argument string array
+* Output:
+*
+* Return: return code 0 - success
+* -1 - failure
+*
+******************************************************************/
+static int
+ipmi_delloem_setled_main(void * intf, int argc, char ** argv)
+{
+ int rc = -1;
+ int b,d,f, mask;
+ int bayId, slotId;
+
+ bayId = 0xFF;
+ slotId = 0xFF;
+
+ current_arg++;
+ if (argc < current_arg)
+ {
+ usage();
+ return rc;
+ }
+
+ /* ipmitool delloem setled info*/
+ if (argc == 1 || strcmp(argv[current_arg], "help") == 0)
+ {
+ ipmi_setled_usage();
+ return 0;
+ }
+ CheckSetLEDSupport (intf);
+ if (!IsSetLEDSupported())
+ {
+ printf("'setled' is not supported on this system.\n");
+ return rc;
+ }
+ else if (sscanf(argv[current_arg], "%*x:%x:%x.%x", &b,&d,&f) == 3) {
+ /* We have bus/dev/function of drive */
+ current_arg++;
+ ipmi_getdrivemap (intf, b, d, f, &bayId, &slotId);
+ }
+ else if (sscanf(argv[current_arg], "%x:%x.%x", &b,&d,&f) == 3) {
+ /* We have bus/dev/function of drive */
+ current_arg++;
+ }
+ else {
+ ipmi_setled_usage();
+ return -1;
+ }
+ /* Get mask of SES flags */
+ mask = ipmi_getsesmask(argc, argv);
+
+ /* Get drive mapping */
+ if (ipmi_getdrivemap (intf, b, d, f, &bayId, &slotId))
+ return -1;
+
+ /* Set drive LEDs */
+ return ipmi_setled_state (intf, bayId, slotId, mask);
+}
+
+static int
+ipmi_delloem_getled_main(void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+ uint8_t state;
+
+ if (argc == 1 || strncmp(argv[0], "help\0", 5) == 0)
+ {
+ ipmi_delloem_getled_usage();
+ return(0);
+ } else {
+ rc = ipmi_delloem_getled_state (intf, &state);
+ if (rc != 0) printf("getled_state error %d\n",rc);
+ else {
+ if (state == 0x01)
+ printf("Chassis ID LED Status = ON\n");
+ else printf("Chassis ID LED Status = off\n");
+ }
+ }
+ return (rc);
+}
+
+/*
+ * decode_sensor_dell
+ * inputs:
+ * sdr = the SDR buffer
+ * reading = the 3 or 4 bytes of data from GetSensorReading
+ * pstring = points to the output string buffer
+ * slen = size of the output buffer
+ * outputs:
+ * rv = 0 if this sensor was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_dell(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype, evtype;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ /* sdr[3] is SDR type: 1=full, 2=compact, 0xC0=oem */
+ if (sdr[3] != 0x02) return(rv); /*return if not compact SDR */
+ stype = sdr[12]; /*sensor type*/
+ evtype = sdr[13]; /*event type */
+ if (stype == 0x02) { /* Discrete Voltage */
+ /* Dell Discrete Voltage is opposite from normal */
+ if (evtype == 0x03) { /*oem interpretation */
+ if (reading[2] & 0x01) strncpy(pstring,"OK",slen);
+ else strncpy(pstring,"Exceeded",slen); /*LimitExceeded*/
+ rv = 0;
+ }
+ }
+ return(rv);
+}
+
+#define BIT(x) (1 << x)
+#define SIZE_OF_DESC 128
+
+char * get_dell_evt_desc(uchar *sel_rec)
+{
+ struct sel_event_record * rec = (struct sel_event_record *)sel_rec;
+ int data1, data2, data3;
+ int code;
+ char *desc = NULL;
+
+ unsigned char count;
+ unsigned char node;
+ //unsigned char num;
+ unsigned char dimmNum;
+ unsigned char dimmsPerNode;
+ char dimmStr[32];
+ //char cardStr[32];
+ //char numStr[32];
+ char tmpdesc[SIZE_OF_DESC];
+ static char rgdesc[SIZE_OF_DESC];
+ char* str;
+ unsigned char incr = 0;
+ unsigned char i = 0;
+ //unsigned char postCode;
+ // struct ipmi_rs *rsp;
+ // struct ipmi_rq req;
+ char tmpData;
+ int version;
+ // uint8_t devid[20]; /*usually 16 bytes*/
+ uint8_t iver;
+ // int rv;
+
+ data1 = rec->sel_type.standard_type.event_data[0];
+ data2 = rec->sel_type.standard_type.event_data[1];
+ data3 = rec->sel_type.standard_type.event_data[2];
+ if ( (rec->sel_type.standard_type.event_type == 0x0B) ||
+ (rec->sel_type.standard_type.event_type == 0x6F) ||
+ (rec->sel_type.standard_type.event_type == 0x07))
+ {
+ code = rec->sel_type.standard_type.sensor_type;
+ /* BDF or Slot */
+ desc = rgdesc;
+ memset(desc,0,SIZE_OF_DESC);
+ switch (code) {
+ case 0x07:
+ if( ((data1 & DATA_BYTE2_SPECIFIED_MASK) == 0x80))
+ {
+ if((data1 & 0x0f) == 0x00)
+ snprintf(desc,SIZE_OF_DESC,"CPU Internal Err | ");
+ if((data1 & 0x0f) == 0x06)
+ {
+ snprintf(desc,SIZE_OF_DESC,"CPU Protocol Err | ");
+ }
+ /* change bit location to a number */
+ for (count= 0; count < 8; count++)
+ {
+ if (BIT(count)& data2)
+ {
+ count++;
+ if( ((data1 & 0x0f) == 0x06) && (rec->sel_type.standard_type.sensor_num == 0x0A))
+ snprintf(desc,SIZE_OF_DESC,"FSB %d ",count);
+ else
+ snprintf(desc,SIZE_OF_DESC,"CPU %d | APIC ID %d ",count,data3);
+ break;
+ }
+ }
+ }
+ break;
+ case 0x0C:
+ if ( (rec->sel_type.standard_type.event_type == 0x0B) &&
+ !(data1 & 0x03) )
+ {
+ if(data2 & 0x04)
+ strcpy(desc,"Memory is in Spare Mode");
+ else if(data2 & 0x02)
+ strcpy(desc,"Memory is in Raid Mode ");
+ else if(data2 & 0x01)
+ strcpy(desc,"Memory is in Mirror Mode ");
+ break;
+ }
+ case 0x10:
+ get_devid_ver(NULL,NULL,&iver);
+ // rv = ipmi_getdeviceid(devid,sizeof(devid),fdbg);
+ // if (rv != 0) return NULL;
+ version = iver;
+ /* Memory DIMMS */
+ if( (data1 & 0x80) || (data1 & 0x20 ) )
+ {
+ if( (code == 0x0c) && (rec->sel_type.standard_type.event_type == 0x0B) )
+ {
+ if((data1 & 0x0f) == 0x00)
+ {
+ snprintf(desc,SIZE_OF_DESC," Redundancy Regained | ");
+ }
+ else if((data1 & 0x0f) == 0x01)
+ {
+ snprintf(desc,SIZE_OF_DESC,"Redundancy Lost | ");
+ }
+ }
+ else if(code == 0x0c)
+ {
+ if((data1 & 0x0f) == 0x00)
+ {
+ if(rec->sel_type.standard_type.sensor_num == 0x1C)
+ {
+ if((data1 & 0x80) && (data1 & 0x20 ))
+ {
+ count = 0;
+ snprintf(desc,SIZE_OF_DESC,"CRC Error on:");
+ for(i=0;i<4;i++)
+ {
+ if((BIT(i))&(data2))
+ {
+ if(count)
+ {
+ str = desc+strlen(desc);
+ *str++ = ',';
+ str = '\0';
+ count = 0;
+ }
+ switch(i)
+ {
+ case 0: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Memory");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 1: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Config");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 2: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 3: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory-corr");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ if(data3>=0x00 && data3<0xFF)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"|Failing_Channel:%d",data3);
+ strcat(desc,tmpdesc);
+ }
+ }
+ break;
+ }
+ snprintf(desc,SIZE_OF_DESC,"Correctable ECC | ");
+ }
+ else if((data1 & 0x0f) == 0x01)
+ {
+ snprintf(desc,SIZE_OF_DESC,"UnCorrectable ECC | ");
+ }
+ }
+ else if(code == 0x10)
+ {
+ if((data1 & 0x0f) == 0x00)
+ snprintf(desc,SIZE_OF_DESC,"Corr Memory Log Dissabled | ");
+ }
+ }
+ else
+ {
+ if(code == 0x12)
+ {
+ if((data1 & 0x0f) == 0x02)
+ snprintf(desc,SIZE_OF_DESC,"Unknown System Hardware Failure ");
+ }
+ if(code == 0x10)
+ {
+ if((data1 & 0x0f) == 0x03)
+ snprintf(desc,SIZE_OF_DESC,"All Even Logging Dissabled");
+ }
+ }
+ if(data1 & 0x80 )
+ {
+ if(((data2 >> 4) != 0x0f) && ((data2 >> 4) < 0x08))
+ {
+ tmpData = ('A'+ (data2 >> 4));
+ if( (code == 0x0c) && (rec->sel_type.standard_type.event_type == 0x0B) )
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Bad Card %c", tmpData);
+ }
+ else
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Card %c", tmpData);
+ }
+ strcat(desc, tmpdesc);
+ }
+ if (0x0F != (data2 & 0x0f))
+ {
+ if(0x51 == version)
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Bank %d", ((data2 & 0x0f)+1));
+ strcat(desc, tmpdesc);
+ }
+ else
+ {
+ incr = (data2 & 0x0f) << 3;
+ }
+ }
+
+ }
+ if(data1 & 0x20 )
+ {
+ if(0x51 == version)
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "DIMM %s", ('A'+ data3));
+ strcat(desc, tmpdesc);
+ }
+ else if( ((data2 >> 4) > 0x07) && ((data2 >> 4) != 0x0F))
+ {
+ strcpy(dimmStr, " DIMM_");
+ str = desc+strlen(desc);
+ dimmsPerNode = 4;
+ if( (data2 >> 4) == 0x09) dimmsPerNode = 6;
+ else if( (data2 >> 4) == 0x0A) dimmsPerNode = 8;
+ else if( (data2 >> 4) == 0x0B) dimmsPerNode = 9;
+ else if( (data2 >> 4) == 0x0C) dimmsPerNode = 12;
+ else if( (data2 >> 4) == 0x0D) dimmsPerNode = 24;
+ else if( (data2 >> 4) == 0x0E) dimmsPerNode = 3;
+ count = 0;
+ for (i = 0; i < 8; i++)
+ {
+ if (BIT(i) & data3)
+ {
+ if (count)
+ {
+ *str++ = ',';
+ count = 0;
+ }
+ node = (incr + i)/dimmsPerNode;
+ dimmNum = ((incr + i)%dimmsPerNode)+1;
+ dimmStr[5] = node + 'A';
+ sprintf(tmpdesc,"%d",dimmNum);
+ dimmStr[6] = tmpdesc[0];
+ dimmStr[7] = '\0';
+ strcat(str,dimmStr);
+ count++;
+ }
+ }
+ }
+ else
+ {
+ strcpy(dimmStr, " DIMM");
+ str = desc+strlen(desc);
+ count = 0;
+ for (i = 0; i < 8; i++)
+ {
+ if (BIT(i) & data3)
+ {
+ // check if more than one DIMM, if so add a comma to the string.
+ if (count)
+ {
+ *str++ = ',';
+ count = 0;
+ }
+ sprintf(tmpdesc,"%d",(i + incr + 1));
+ dimmStr[4] = tmpdesc[0];
+ dimmStr[5] = '\0';
+ strcat(str, dimmStr);
+ count++;
+ }
+ }
+ }
+ }
+ break;
+ case 0x20:
+ if(((data1 & 0x0f)== 0x00)&&((data1 & 0x80) && (data1 & 0x20)))
+ {
+ if((data2 > 0x00)&&(data2<0xFF))
+ {
+ //Add the code to display 194 entries.This sensor present only in ORCA
+
+ }
+ switch(data3)
+ {
+ case 0x01:
+ snprintf(desc,SIZE_OF_DESC,"BIOS TXT Error");
+ break;
+ case 0x02:
+ snprintf(desc,SIZE_OF_DESC,"Processor/FIT TXT");
+ break;
+ case 0x03:
+ snprintf(desc,SIZE_OF_DESC,"BIOS ACM TXT Error");
+ break;
+ case 0x04:
+ snprintf(desc,SIZE_OF_DESC,"SINIT ACM TXT Error");
+ break;
+ case 0xff:
+ snprintf(desc,SIZE_OF_DESC,"Unrecognized TT Error12");
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case 0x23:
+
+ if(data1 == 0xC1)
+ {
+ if(data2 == 0x04)
+ {
+ snprintf(desc,SIZE_OF_DESC,"Hard Reset|Interrupt type None,SMS/OS Timer used at expiration");
+ }
+ }
+
+ break;
+ case 0x2B:
+ if(((data1 & 0x0f)== 0x02)&&((data1 & 0x80) && (data1 & 0x20)))
+ {
+ if(data2 == 0x02)
+ {
+ if(data3 == 0x00)
+ {
+ snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and other hardware");
+ }
+ else if(data3 == 0x01)
+ {
+ snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and CPU");
+ }
+ }
+ }
+ break;
+
+ case 0xC1:
+ if(rec->sel_type.standard_type.sensor_num == 0x25)
+ {
+ if((data1 & 0x0f) == 0x01)
+ {
+ snprintf(desc, SIZE_OF_DESC, "Failed to program Virtual Mac Address");
+ if((data1 & 0x80)&&(data1 & 0x20))
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "PCI %.2x:%.2x.%x",
+ data3 &0x7f, (data2 >> 3) & 0x1F,
+ data2 & 0x7);
+ }
+ }
+ else if((data1 & 0x0f) == 0x02)
+ {
+ snprintf(desc, SIZE_OF_DESC, "Device option ROM failed to support link tuning or flex address");
+ if((data1 & 0x80)&&(data1 & 0x20))
+ {
+ //Add Mezzanine code here.DELLOEM SEL displayed unknown event
+ }
+ }
+ else if((data1 & 0x0f) == 0x03)
+ {
+ snprintf(desc, SIZE_OF_DESC, "Failed to get link tuning or flex address data from BMC/iDRAC");
+ }
+ strcat(desc,tmpdesc);
+ }
+ break;
+ case 0x13:
+ case 0xC2:
+ case 0xC3:
+ if(rec->sel_type.standard_type.sensor_num == 0x29)
+ {
+ if(((data1 & 0x0f)== 0x02)&&((data1 & 0x80) && (data1 & 0x20)))
+ {
+ #if 1 /*This sensor is not implemented in iDRAC code*/
+ snprintf(tmpdesc, SIZE_OF_DESC, "Partner-(LinkId:%d,AgentId:%d)|",(data2 & 0xC0),(data2 & 0x30));
+ strcat(desc,tmpdesc);
+ snprintf(tmpdesc, SIZE_OF_DESC, "ReportingAgent(LinkId:%d,AgentId:%d)|",(data2 & 0x0C),(data2 & 0x03));
+ strcat(desc,tmpdesc);
+ if((data3 & 0xFC) == 0x00)
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "LinkWidthDegraded|");
+ strcat(desc,tmpdesc);
+ }
+ if(BIT(1)& data3)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"PA_Type:IOH|");
+ }
+ else
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"PA-Type:CPU|");
+ }
+ strcat(desc,tmpdesc);
+ if(BIT(0)& data3)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:IOH");
+ }
+ else
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:CPU");
+ }
+ strcat(desc,tmpdesc);
+ #endif
+ }
+ }
+ else
+ {
+
+ if((data1 & 0x0f) == 0x02)
+ {
+ sprintf(desc,"%s","IO channel Check NMI");
+ }
+ else
+ {
+ if((data1 & 0x0f) == 0x00)
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCIe Error |");
+ }
+ else if((data1 & 0x0f) == 0x01)
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","I/O Error |");
+ }
+ else if((data1 & 0x0f) == 0x04)
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCI PERR |");
+ }
+ else if((data1 & 0x0f) == 0x05)
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCI SERR |");
+ }
+ else
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s"," ");
+ }
+ if (data3 & 0x80)
+ snprintf(tmpdesc, SIZE_OF_DESC, "Slot %d", data3 & 0x7f);
+ else
+ snprintf(tmpdesc, SIZE_OF_DESC, "PCI %.2x:%.2x.%x",
+ data3 &0x7f, (data2 >> 3) & 0x1F,
+ data2 & 0x7);
+ strcat(desc,tmpdesc);
+ }
+ }
+ break;
+ case 0x0F:
+ if(((data1 & 0x0f)== 0x0F)&&(data1 & 0x80))
+ {
+ switch(data2)
+ {
+ case 0x80:
+ snprintf(desc, SIZE_OF_DESC, "No memory is detected.");break;
+ case 0x81:
+ snprintf(desc,SIZE_OF_DESC, "Memory is detected but is not configurable.");break;
+ case 0x82:
+ snprintf(desc, SIZE_OF_DESC, "Memory is configured but not usable.");break;
+ case 0x83:
+ snprintf(desc, SIZE_OF_DESC, "System BIOS shadow failed.");break;
+ case 0x84:
+ snprintf(desc, SIZE_OF_DESC, "CMOS failed.");break;
+ case 0x85:
+ snprintf(desc, SIZE_OF_DESC, "DMA controller failed.");break;
+ case 0x86:
+ snprintf(desc, SIZE_OF_DESC, "Interrupt controller failed.");break;
+ case 0x87:
+ snprintf(desc, SIZE_OF_DESC, "Timer refresh failed.");break;
+ case 0x88:
+ snprintf(desc, SIZE_OF_DESC, "Programmable interval timer error.");break;
+ case 0x89:
+ snprintf(desc, SIZE_OF_DESC, "Parity error.");break;
+ case 0x8A:
+ snprintf(desc, SIZE_OF_DESC, "SIO failed.");break;
+ case 0x8B:
+ snprintf(desc, SIZE_OF_DESC, "Keyboard controller failed.");break;
+ case 0x8C:
+ snprintf(desc, SIZE_OF_DESC, "System management interrupt initialization failed.");break;
+ case 0x8D:
+ snprintf(desc, SIZE_OF_DESC, "TXT-SX Error.");break;
+ case 0xC0:
+ snprintf(desc, SIZE_OF_DESC, "Shutdown test failed.");break;
+ case 0xC1:
+ snprintf(desc, SIZE_OF_DESC, "BIOS POST memory test failed.");break;
+ case 0xC2:
+ snprintf(desc, SIZE_OF_DESC, "RAC configuration failed.");break;
+ case 0xC3:
+ snprintf(desc, SIZE_OF_DESC, "CPU configuration failed.");break;
+ case 0xC4:
+ snprintf(desc, SIZE_OF_DESC, "Incorrect memory configuration.");break;
+ case 0xFE:
+ snprintf(desc, SIZE_OF_DESC, "General failure after video.");
+ break;
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ code = rec->sel_type.standard_type.event_type;
+ }
+ return desc;
+}
+
+/*
+ * decode_sel_dell
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_dell(uint8_t *evt, char *outbuf, int outsz, char fdesc,
+ char fdbg)
+{
+ int rv = -1;
+ uint16_t id, genid;
+ uint8_t rectype;
+ uint32_t timestamp;
+ char *type_str = NULL;
+ char *gstr = NULL;
+ char *pstr = NULL;
+ int sevid;
+ uchar stype, snum;
+
+ fdebug = fdbg;
+ sevid = SEV_INFO;
+ id = evt[0] + (evt[1] << 8);
+ rectype = evt[2];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ stype = evt[10];
+ snum = evt[11];
+ gstr = "BMC ";
+ if (genid == 0x0033) gstr = "Bios";
+ type_str = "";
+ if (rectype == 0x02) type_str = get_sensor_type_desc(stype);
+
+#ifdef OTHER
+ /* evt[13] is data1/offset*/
+ if ( ((evt[13] & DATA_BYTE2_SPECIFIED_MASK) == 0x80) ||
+ ((evt[13] & DATA_BYTE3_SPECIFIED_MASK) == 0x20) ) {
+ // if (evt[13] & DATA_BYTE2_SPECIFIED_MASK)
+ // evt->data = rec->sel_type.standard_type.event_data[1];
+ pstr = get_dell_evt_desc(evt);
+ } else if (evt[13] == 0xC1) {
+ if (snum == 0x23) {
+ // evt->data = rec->sel_type.standard_type.event_data[1];
+ pstr = get_dell_evt_desc(evt);
+ }
+ }
+#endif
+ pstr = get_dell_evt_desc(evt);
+ if (pstr != NULL) rv = 0;
+
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,NULL,outbuf,outsz);
+ }
+ return rv;
+}
+
+#ifdef METACOMMAND
+int i_delloem(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rv = 0;
+ uchar devrec[16];
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+ set_loglevel(LOG_NOTICE);
+ argc_sav = argc;
+ argv_sav = argv;
+ parse_lan_options('V',"4",0); /*default to admin priv*/
+
+ while ( (c = getopt( argc, argv,"m:s:xzEF:J:N:P:R:T:U:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 's': sdrfile = optarg; break;
+ case 'x': fdebug = 2; /* normal (dbglog if isol) */
+ verbose = 1;
+ break;
+ case 'z': fdebug = 3; /*full debug (for isol)*/
+ verbose = 1;
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ usage();
+ rv = ERR_USAGE;
+ goto do_exit;
+ break;
+ }
+ rv = ipmi_getdeviceid(devrec,16,fdebug);
+ if (rv == 0) {
+ char ipmi_maj, ipmi_min;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ // vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ // prod_id = devrec[9] + (devrec[10] << 8);
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rv = ipmi_delloem_main(NULL, argc, argv);
+
+do_exit:
+ ipmi_close_();
+ return(rv);
+}
+/* end oem_dell.c */
diff --git a/util/oem_dell.h b/util/oem_dell.h
new file mode 100644
index 0000000..a17a517
--- /dev/null
+++ b/util/oem_dell.h
@@ -0,0 +1,629 @@
+/****************************************************************************
+Copyright (c) 2008, Dell Inc
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Dell Inc nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+*****************************************************************************/
+#ifndef IPMI_DELLOEM_H
+#define IPMI_DELLOEM_H
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef HAVE_ATTRIBUTE_PACKING
+/* this attribute is not very portable */
+#define ATTRIBUTE_PACKING __attribute__ ((packed))
+#else
+/* use #pragma pack(1) instead */
+#define ATTRIBUTE_PACKING
+#endif
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+
+
+#define IPMI_SET_SYS_INFO 0x58
+#define IPMI_GET_SYS_INFO 0x59
+
+/* Dell selector for LCD control - get and set unless specified */
+#define IPMI_DELL_LCD_STRING_SELECTOR 0xC1 /* RW get/set the user string */
+#define IPMI_DELL_LCD_CONFIG_SELECTOR 0xC2 /* RW set to user/default/none */
+#define IPMI_DELL_LCD_GET_CAPS_SELECTOR 0xCF /* RO use when available*/
+#define IPMI_DELL_LCD_STRINGEX_SELECTOR 0xD0 /* RW get/set the user string use first when available*/
+#define IPMI_DELL_LCD_STATUS_SELECTOR 0xE7 /* LCD string when config set to default.*/
+#define IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR 0xD1 /* LCD string when config set to default.*/
+
+/* Dell defines for picking which string to use */
+#define IPMI_DELL_LCD_CONFIG_USER_DEFINED 0x00 /* use string set by user*/
+#define IPMI_DELL_LCD_CONFIG_DEFAULT 0x01 /* use platform model name*/
+#define IPMI_DELL_LCD_CONFIG_NONE 0x02 /* blank*/
+#define IPMI_DELL_LCD_iDRAC_IPV4ADRESS 0x04 /* use string set by user*/
+#define IPMI_DELL_LCD_IDRAC_MAC_ADDRESS 0x08 /* use platform model name*/
+#define IPMI_DELL_LCD_OS_SYSTEM_NAME 0x10 /* blank*/
+
+#define IPMI_DELL_LCD_SERVICE_TAG 0x20 /* use string set by user*/
+#define IPMI_DELL_LCD_iDRAC_IPV6ADRESS 0x40 /* use string set by user*/
+#define IPMI_DELL_LCD_AMBEINT_TEMP 0x80 /* use platform model name*/
+#define IPMI_DELL_LCD_SYSTEM_WATTS 0x100 /* blank*/
+#define IPMI_DELL_LCD_ASSET_TAG 0x200
+
+#define IPMI_DELL_LCD_ERROR_DISP_SEL 0x01 /* use platform model name*/
+#define IPMI_DELL_LCD_ERROR_DISP_VERBOSE 0x02 /* blank*/
+
+#define IPMI_DELL_IDRAC_VALIDATOR 0xDD
+#define IPMI_DELL_POWER_CAP_STATUS 0xBA
+#define IPMI_DELL_AVG_POWER_CONSMP_HST 0xEB
+#define IPMI_DELL_PEAK_POWER_CONSMP_HST 0xEC
+#define SYSTEM_BOARD_SYSTEM_LEVEL_SENSOR_NUM 0x98
+
+#define IDRAC_11G 1
+#define IDRAC_12G 2
+// Return Error code for license
+#define LICENSE_NOT_SUPPORTED 0x6F
+#define VFL_NOT_LICENSED 0x33
+#define btuphr 0x01
+#define watt 0x00
+#define IPMI_DELL_POWER_CAP 0xEA
+#define percent 0x03
+
+/* Not on all Dell servers. If there, use it.*/
+#pragma pack(1)
+typedef struct _tag_ipmi_dell_lcd_caps
+{
+ uint8_t parm_rev; /* 0x11 for IPMI 2.0 */
+ uint8_t char_set; /* always 1 for printable ASCII 0x20-0x7E */
+ uint8_t number_lines; /* 0-4, 1 for 9G. 10G tbd */
+ uint8_t max_chars[4]; /* 62 for triathlon, 0 if not present (glacier) */
+ /* [0] is max chars for line 1 */
+}IPMI_DELL_LCD_CAPS;
+
+#define IPMI_DELL_LCD_STRING_LENGTH_MAX 62 /* Valid for 9G. Glacier ??. */
+#define IPMI_DELL_LCD_STRING1_SIZE 14
+#define IPMI_DELL_LCD_STRINGN_SIZE 16
+
+/* vFlash subcommands */
+#define IPMI_GET_EXT_SD_CARD_INFO 0xA4
+
+
+typedef struct _tag_ipmi_dell_lcd_string
+{
+ uint8_t parm_rev; /* 0x11 for IPMI 2.0 */
+ uint8_t data_block_selector; /* 16-byte data block number to access, 0 based.*/
+ union
+ {
+ struct
+ {
+ uint8_t encoding : 4; /* 0 is printable ASCII 7-bit */
+ uint8_t length; /* 0 to max chars from lcd caps */
+ uint8_t data[IPMI_DELL_LCD_STRING1_SIZE]; /* not zero terminated. */
+ }selector_0_string;
+ uint8_t selector_n_data[IPMI_DELL_LCD_STRINGN_SIZE];
+ }lcd_string;
+} ATTRIBUTE_PACKING IPMI_DELL_LCD_STRING;
+
+/* Only found on servers with more than 1 line. Use if available. */
+typedef struct _tag_ipmi_dell_lcd_stringex
+{
+ uint8_t parm_rev; /* 0x11 for IPMI 2.0 */
+ uint8_t line_number; /* LCD line number 1 to 4 */
+ uint8_t data_block_selector; /* 16-byte data block number to access, 0 based.*/
+ union
+ {
+ struct
+ {
+ uint8_t encoding : 4; /* 0 is printable ASCII 7-bit */
+ uint8_t length; /* 0 to max chars from lcd caps */
+ uint8_t data[IPMI_DELL_LCD_STRING1_SIZE]; /* not zero terminated. */
+ } selector_0_string;
+ uint8_t selector_n_data[IPMI_DELL_LCD_STRINGN_SIZE];
+ } lcd_string;
+} ATTRIBUTE_PACKING IPMI_DELL_LCD_STRINGEX;
+
+
+typedef struct _lcd_status
+{
+ char vKVM_status;
+ char lock_status;
+ char Resv1;
+ char Resv;
+} ATTRIBUTE_PACKING LCD_STATUS;
+
+typedef struct _lcd_mode
+{
+ uint8_t parametersel;
+ uint32_t lcdmode;
+ uint16_t lcdqualifier;
+ uint32_t capabilites;
+ uint8_t error_display;
+ uint8_t Resv;
+} ATTRIBUTE_PACKING LCD_MODE;
+#pragma pack()
+
+#define PARAM_REV_OFFSET (uint8_t)(0x1)
+
+#define LOM_MACTYPE_ETHERNET 0
+#define LOM_MACTYPE_ISCSI 1
+#define LOM_MACTYPE_RESERVED 3
+
+#define LOM_ETHERNET_ENABLED 0
+#define LOM_ETHERNET_DISABLED 1
+#define LOM_ETHERNET_PLAYINGDEAD 2
+#define LOM_ETHERNET_RESERVED 3
+
+#define LOM_ACTIVE 1
+#define LOM_INACTIVE 0
+
+#define MACADDRESSLENGH 6
+#define MAX_LOM 8
+
+#define IPMI_NETFN_SE (uint8_t)(0x04)
+#define IPMI_NETFN_APP (uint8_t)(0x06) //NETFN_APP
+#define IPMI_NETFN_STORAGE (uint8_t)(0x0a) //NETFN_STOR
+#define IPMI_CMD_GET_SEL_TIME 0x48
+#define GET_FRU_INFO 0x10
+#define GET_FRU_DATA 0x11
+#define BSWAP_16(x) ((((x) & 0xff00) >> 8) | (((x) & 0x00ff) << 8))
+
+#define APP_NETFN (uint8_t)(0x6)
+
+
+#define GET_SYSTEM_INFO_CMD (uint8_t)(0x59)
+#define EMB_NIC_MAC_ADDRESS_11G (uint8_t)(0xDA)
+#define EMB_NIC_MAC_ADDRESS_9G_10G (uint8_t)(0xCB)
+
+#define IMC_IDRAC_10G (uint8_t) (0x08)
+#define IMC_CMC (uint8_t) (0x09)
+#define IMC_IDRAC_11G_MONOLITHIC (uint8_t) (0x0A)
+#define IMC_IDRAC_11G_MODULAR (uint8_t) (0x0B)
+#define IMC_UNUSED (uint8_t) (0x0C)
+#define IMC_MASER_LITE_BMC (uint8_t) (0x0D)
+#define IMC_IDRAC_12G_MONOLITHIC (uint8_t) (0x10)
+#define IMC_IDRAC_12G_MODULAR (uint8_t) (0x11)
+
+
+#pragma pack(1)
+#ifdef LOM_OLD
+typedef struct
+{
+ unsigned int BladSlotNumber : 4;
+ unsigned int MacType : 2;
+ unsigned int EthernetStatus : 2;
+ unsigned int NICNumber : 5;
+ unsigned int Reserved : 3;
+ uint8_t MacAddressByte[MACADDRESSLENGH];
+} LOMMacAddressType;
+#else
+typedef struct
+{
+ uint8_t b0;
+ uint8_t b1;
+ uint8_t MacAddressByte[MACADDRESSLENGH];
+} LOMMacAddressType;
+#endif
+#pragma pack()
+
+#pragma pack(1)
+typedef struct
+{
+ LOMMacAddressType LOMMacAddress [MAX_LOM];
+} EmbeddedNICMacAddressType;
+
+typedef struct
+{
+ uint8_t MacAddressByte[MACADDRESSLENGH];
+} MacAddressType;
+
+typedef struct
+{
+ MacAddressType MacAddress [MAX_LOM];
+} EmbeddedNICMacAddressType_10G;
+
+struct fru_info {
+ uint16_t size;
+ uint8_t access:1;
+};
+struct fru_header {
+ uint8_t version;
+ struct {
+ uint8_t internal;
+ uint8_t chassis;
+ uint8_t board;
+ uint8_t product;
+ uint8_t multi;
+ } offset;
+ uint8_t pad;
+ uint8_t checksum;
+} ATTRIBUTE_PACKING;
+
+struct entity_id {
+ uint8_t id; /* physical entity id */
+#if WORDS_BIGENDIAN
+ uint8_t logical : 1; /* physical/logical */
+ uint8_t instance : 7; /* instance number */
+#else
+ uint8_t instance : 7; /* instance number */
+ uint8_t logical : 1; /* physical/logical */
+#endif
+} ATTRIBUTE_PACKING;
+struct sdr_record_mask {
+ union {
+ struct {
+ uint16_t assert_event; /* assertion event mask */
+ uint16_t deassert_event; /* de-assertion event ma
+sk */
+ uint16_t read; /* discrete reading mask */
+ } ATTRIBUTE_PACKING discrete;
+ /*...*/
+ } ATTRIBUTE_PACKING type;
+} ATTRIBUTE_PACKING ;
+
+struct sdr_record_full_sensor {
+ struct {
+ uint8_t owner_id;
+#if WORDS_BIGENDIAN
+ uint8_t channel:4; /* channel number */
+ uint8_t __reserved1:2;
+ uint8_t lun:2; /* sensor owner lun */
+#else
+ uint8_t lun:2; /* sensor owner lun */
+ uint8_t __reserved2:2;
+ uint8_t channel:4; /* channel number */
+#endif
+ uint8_t sensor_num; /* unique sensor number */
+ } ATTRIBUTE_PACKING keys;
+
+ struct entity_id entity;
+
+ struct {
+ struct {
+#if WORDS_BIGENDIAN
+ uint8_t __reserved3:1;
+ uint8_t scanning:1;
+ uint8_t events:1;
+ uint8_t thresholds:1;
+ uint8_t hysteresis:1;
+ uint8_t type:1;
+ uint8_t event_gen:1;
+ uint8_t sensor_scan:1;
+#else
+ uint8_t sensor_scan:1;
+ uint8_t event_gen:1;
+ uint8_t type:1;
+ uint8_t hysteresis:1;
+ uint8_t thresholds:1;
+ uint8_t events:1;
+ uint8_t scanning:1;
+ uint8_t __reserved4:1;
+#endif
+ } ATTRIBUTE_PACKING init;
+ struct {
+#if WORDS_BIGENDIAN
+ uint8_t ignore:1;
+ uint8_t rearm:1;
+ uint8_t hysteresis:2;
+ uint8_t threshold:2;
+ uint8_t event_msg:2;
+#else
+ uint8_t event_msg:2;
+ uint8_t threshold:2;
+ uint8_t hysteresis:2;
+ uint8_t rearm:1;
+ uint8_t ignore:1;
+#endif
+ } ATTRIBUTE_PACKING capabilities;
+ uint8_t type;
+ } ATTRIBUTE_PACKING sensor;
+
+ uint8_t event_type; /* event/reading type code */
+
+ struct sdr_record_mask mask;
+
+ struct {
+#if WORDS_BIGENDIAN
+ uint8_t analog:2;
+ uint8_t rate:3;
+ uint8_t modifier:2;
+ uint8_t pct:1;
+#else
+ uint8_t pct:1;
+ uint8_t modifier:2;
+ uint8_t rate:3;
+ uint8_t analog:2;
+#endif
+ struct {
+ uint8_t base;
+ uint8_t modifier;
+ } ATTRIBUTE_PACKING type;
+ } ATTRIBUTE_PACKING unit;
+
+#define SDR_SENSOR_L_LINEAR 0x00
+#define SDR_SENSOR_L_LN 0x01
+#define SDR_SENSOR_L_LOG10 0x02
+#define SDR_SENSOR_L_LOG2 0x03
+#define SDR_SENSOR_L_E 0x04
+#define SDR_SENSOR_L_EXP10 0x05
+#define SDR_SENSOR_L_EXP2 0x06
+#define SDR_SENSOR_L_1_X 0x07
+#define SDR_SENSOR_L_SQR 0x08
+#define SDR_SENSOR_L_CUBE 0x09
+#define SDR_SENSOR_L_SQRT 0x0a
+#define SDR_SENSOR_L_CUBERT 0x0b
+#define SDR_SENSOR_L_NONLINEAR 0x70
+ uint8_t linearization; /* 70h=non linear, 71h-7Fh=non linear, OEM */
+ uint16_t mtol; /* M, tolerance */
+ uint32_t bacc; /* accuracy, B, Bexp, Rexp */
+
+ struct {
+#if WORDS_BIGENDIAN
+ uint8_t __reserved5:5;
+ uint8_t normal_min:1; /* normal min field specified */
+ uint8_t normal_max:1; /* normal max field specified */
+ uint8_t nominal_read:1; /* nominal reading field specified */
+#else
+ uint8_t nominal_read:1; /* nominal reading field specified */
+ uint8_t normal_max:1; /* normal max field specified */
+ uint8_t normal_min:1; /* normal min field specified */
+ uint8_t __reserved5:5;
+#endif
+ } ATTRIBUTE_PACKING analog_flag;
+
+ uint8_t nominal_read; /* nominal reading, raw value */
+ uint8_t normal_max; /* normal maximum, raw value */
+ uint8_t normal_min; /* normal minimum, raw value */
+ uint8_t sensor_max; /* sensor maximum, raw value */
+ uint8_t sensor_min; /* sensor minimum, raw value */
+
+ struct {
+ struct {
+ uint8_t non_recover;
+ uint8_t critical;
+ uint8_t non_critical;
+ } ATTRIBUTE_PACKING upper;
+ struct {
+ uint8_t non_recover;
+ uint8_t critical;
+ uint8_t non_critical;
+ } ATTRIBUTE_PACKING lower;
+ struct {
+ uint8_t positive;
+ uint8_t negative;
+ } ATTRIBUTE_PACKING hysteresis;
+ } ATTRIBUTE_PACKING threshold;
+ uint8_t __reserved6[2];
+ uint8_t oem; /* reserved for OEM use */
+ uint8_t id_code; /* sensor ID string type/length code */
+ uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */
+} ATTRIBUTE_PACKING;
+struct sdr_record_list {
+ uint16_t id;
+ uint8_t version;
+ uint8_t type;
+ uint8_t length;
+ union {
+ struct sdr_record_full_sensor *full;
+ } ATTRIBUTE_PACKING record;
+ uint8_t *raw;
+ struct sdr_record_list *next;
+} ATTRIBUTE_PACKING;
+#pragma pack()
+
+#define TRANSPORT_NETFN (uint8_t)(0xc)
+#define GET_LAN_PARAM_CMD (uint8_t)(0x02)
+#define MAC_ADDR_PARAM (uint8_t)(0x05)
+#define LAN_CHANNEL_NUMBER (uint8_t)(0x01)
+
+#define IDRAC_NIC_NUMBER (uint8_t)(0x8)
+
+#define TOTAL_N0_NICS_INDEX (uint8_t)(0x1)
+
+
+// 12g supported
+#define SET_NIC_SELECTION_12G_CMD (uint8_t)(0x28)
+#define GET_NIC_SELECTION_12G_CMD (uint8_t)(0x29)
+
+// 11g supported
+#define SET_NIC_SELECTION_CMD (uint8_t)(0x24)
+#define GET_NIC_SELECTION_CMD (uint8_t)(0x25)
+#define GET_ACTIVE_NIC_CMD (uint8_t)(0xc1)
+#define POWER_EFFICENCY_CMD (uint8_t)(0xc0)
+#define SERVER_POWER_CONSUMPTION_CMD (uint8_t)(0x8F)
+
+#define POWER_SUPPLY_INFO (uint8_t)(0xb0)
+#define IPMI_ENTITY_ID_POWER_SUPPLY (uint8_t)(0x0a)
+#define SENSOR_STATE_STR_SIZE (uint8_t)(64)
+#define SENSOR_NAME_STR_SIZE (uint8_t)(64)
+
+#define GET_PWRMGMT_INFO_CMD (uint8_t)(0x9C)
+#define CLEAR_PWRMGMT_INFO_CMD (uint8_t)(0x9D)
+#define GET_PWR_HEADROOM_CMD (uint8_t)(0xBB)
+#define GET_PWR_CONSUMPTION_CMD (uint8_t)(0xB3)
+#define GET_FRONT_PANEL_INFO_CMD (uint8_t)0xb5
+
+
+#pragma pack(1)
+typedef struct _ipmi_power_monitor
+{
+ uint32_t cumStartTime;
+ uint32_t cumReading;
+ uint32_t maxPeakStartTime;
+ uint32_t ampPeakTime;
+ uint16_t ampReading;
+ uint32_t wattPeakTime;
+ uint16_t wattReading;
+} ATTRIBUTE_PACKING IPMI_POWER_MONITOR;
+
+
+#define MAX_POWER_FW_VERSION 8
+
+typedef struct _ipmi_power_supply_infoo
+{
+ /*No param_rev it is not a System Information Command */
+ uint16_t ratedWatts;
+ uint16_t ratedAmps;
+ uint16_t ratedVolts;
+ uint32_t vendorid;
+ uint8_t FrimwareVersion[MAX_POWER_FW_VERSION];
+ uint8_t Powersupplytype;
+ uint16_t ratedDCWatts;
+ uint16_t Resv;
+
+} ATTRIBUTE_PACKING IPMI_POWER_SUPPLY_INFO;
+
+
+typedef struct ipmi_power_consumption_data
+{
+ uint16_t actualpowerconsumption;
+ uint16_t powerthreshold;
+ uint16_t warningthreshold;
+ uint8_t throttlestate;
+ uint16_t maxpowerconsumption;
+ uint16_t throttlepowerconsumption;
+ uint16_t Resv;
+} ATTRIBUTE_PACKING IPMI_POWER_CONSUMPTION_DATA;
+
+
+typedef struct ipmi_inst_power_consumption_data
+{
+ uint16_t instanpowerconsumption;
+ uint16_t instanApms;
+ uint16_t resv1;
+ uint8_t resv;
+} ATTRIBUTE_PACKING IPMI_INST_POWER_CONSUMPTION_DATA;
+
+typedef struct _ipmi_avgpower_consump_histroy
+{
+ uint8_t parameterselector;
+ uint16_t lastminutepower;
+ uint16_t lasthourpower;
+ uint16_t lastdaypower;
+ uint16_t lastweakpower;
+
+} ATTRIBUTE_PACKING IPMI_AVGPOWER_CONSUMP_HISTORY;
+
+typedef struct _ipmi_power_consump_histroy
+{
+ uint8_t parameterselector;
+ uint16_t lastminutepower;
+ uint16_t lasthourpower;
+ uint16_t lastdaypower;
+ uint16_t lastweakpower;
+ uint32_t lastminutepowertime;
+ uint32_t lasthourpowertime;
+ uint32_t lastdaypowertime;
+ uint32_t lastweekpowertime;
+} ATTRIBUTE_PACKING IPMI_POWER_CONSUMP_HISTORY;
+
+
+typedef struct _ipmi_delloem_power_cap
+{
+ uint8_t parameterselector;
+ uint16_t PowerCap;
+ uint8_t unit;
+ uint16_t MaximumPowerConsmp;
+ uint16_t MinimumPowerConsmp;
+ uint16_t totalnumpowersupp;
+ uint16_t AvailablePower ;
+ uint16_t SystemThrottling;
+ uint16_t Resv;
+} ATTRIBUTE_PACKING IPMI_POWER_CAP;
+
+typedef struct _power_headroom
+{
+ uint16_t instheadroom;
+ uint16_t peakheadroom;
+} ATTRIBUTE_PACKING POWER_HEADROOM;
+
+struct vFlashstr {
+ uint8_t val;
+ const char * str;
+};
+typedef struct ipmi_vFlash_extended_info
+{
+ uint8_t vflashcompcode;
+ uint8_t sdcardstatus;
+ uint32_t sdcardsize;
+ uint32_t sdcardavailsize;
+ uint8_t bootpartion;
+ uint8_t Resv;
+} IPMI_DELL_SDCARD_INFO;
+#pragma pack()
+
+
+typedef struct _SensorReadingType
+{
+ uint8_t sensorReading;
+ uint8_t sensorFlags;
+ uint16_t sensorState;
+}SensorReadingType;
+
+struct standard_spec_sel_rec{
+ uint32_t timestamp;
+ uint16_t gen_id;
+ uint8_t evm_rev;
+ uint8_t sensor_type;
+ uint8_t sensor_num;
+#if WORDS_BIGENDIAN
+ uint8_t event_dir : 1;
+ uint8_t event_type : 7;
+#else
+ uint8_t event_type : 7;
+ uint8_t event_dir : 1;
+#endif
+#define DATA_BYTE2_SPECIFIED_MASK 0xc0 /* event_data[0] bit mask */
+#define DATA_BYTE3_SPECIFIED_MASK 0x30 /* event_data[0] bit mask */
+#define EVENT_OFFSET_MASK 0x0f /* event_data[0] bit mask */
+ uint8_t event_data[3];
+};
+
+#define SEL_OEM_TS_DATA_LEN 6
+#define SEL_OEM_NOTS_DATA_LEN 13
+struct oem_ts_spec_sel_rec{
+ uint32_t timestamp;
+ uint8_t manf_id[3];
+ uint8_t oem_defined[SEL_OEM_TS_DATA_LEN];
+};
+
+struct oem_nots_spec_sel_rec{
+ uint8_t oem_defined[SEL_OEM_NOTS_DATA_LEN];
+};
+
+#pragma pack(1)
+struct sel_event_record {
+ uint16_t record_id;
+ uint8_t record_type;
+ union{
+ struct standard_spec_sel_rec standard_type;
+ struct oem_ts_spec_sel_rec oem_ts_type;
+ struct oem_nots_spec_sel_rec oem_nots_type;
+ } sel_type;
+} ATTRIBUTE_PACKING; // __attribute__ ((packed));
+#pragma pack()
+
+uint16_t compareinputwattage(IPMI_POWER_SUPPLY_INFO* powersupplyinfo, uint16_t inputwattage);
+int ipmi_delloem_main(void * intf, int argc, char ** argv);
+int ipmi_delloem_getled_state (void * intf, uint8_t *state);
+#endif /*IPMI_DELLOEM_H*/
diff --git a/util/oem_fujitsu.c b/util/oem_fujitsu.c
new file mode 100644
index 0000000..362df96
--- /dev/null
+++ b/util/oem_fujitsu.c
@@ -0,0 +1,773 @@
+/*
+ * oem_fujitsu.c
+ *
+ * This module handles OEM-specific functions for Fujitsu-Siemens firmware.
+ *
+ * References:
+ * http://manuals.ts.fujitsu.com/file/4390/irmc_s2-ug-en.pdf
+ *
+ * Authors: Andy Cress arcress at users.sourceforge.net, and
+ * Dan Lukes dan at obluda.cz
+ *
+ * Copyright (c) 2010 Kontron America, Inc.
+ *
+ * 08/17/10 Andy Cress v1.0 new, with source input from Dan Lukes
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+#include "oem_fujitsu.h"
+
+/* extern void get_mfgid(int *vend, int *prod); * from ipmicmd.h*/
+/* extern int get_lan_options(); * from ipmicmd.h */
+static char fdebug = 0;
+static char freadok = 1;
+#define ERRLED 0 /*GEL - red Global Error LED*/
+#define WARNLED 1 /*CSS - yellow warning LED*/
+#define IDLED 2 /*ID - blue Identify LED*/
+
+#define NETFN_FUJITSU_IRMCS2 0xB8
+#define CMD_FUJITSU_IRMCS2 0xF5
+#define CMD_SPEC_FUJITSU_SET_ID_LED 0xB0
+#define CMD_SPEC_FUJITSU_GET_ID_LED 0xB1
+#define CMD_SPEC_FUJITSU_GET_ERR_LED 0xB3
+#define LED_OFF 0
+#define LED_ON 1
+#define LED_BLINK 2
+
+/*
+ * get_alarmss_fujitsu
+ * returns an array of 3 bytes:
+ * offset 0 = ID blue LED state (0=off, 1=on, 2=blink)
+ * offset 1 = CSS yellow LED state (0=off, 1=on, 2=blink)
+ * offset 2 = GEL red LED state (0=off, 1=on, 2=blink)
+ */
+int get_alarms_fujitsu(uchar *rgalarms )
+{
+ int rv = -1;
+ uchar idata[16];
+ uchar rdata[16];
+ int rlen;
+ ushort icmd;
+ uchar cc;
+ int vend_id, prod_id;
+
+ if (rgalarms == NULL) return(ERR_BAD_PARAM);
+ memset(rgalarms,0,3);
+ /* check if iRMC s2 */
+ get_mfgid(&vend_id,&prod_id);
+ if (vend_id != VENDOR_FUJITSU) return(LAN_ERR_NOTSUPPORT);
+ if (FUJITSU_PRODUCT_IS_iRMC_S1(prod_id)) return(LAN_ERR_NOTSUPPORT);
+
+ /* get error, warning, id led statuses */
+ icmd = CMD_FUJITSU_IRMCS2 | (IPMI_NET_FN_OEM_GROUP_RQ << 8);
+ idata[0] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
+ idata[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
+ idata[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
+ idata[3] = CMD_SPEC_FUJITSU_GET_ID_LED;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd_mc(icmd, idata, 4, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv != 0) return(rv);
+ rgalarms[0] = (rdata[3] & 0x03); /*id led, after the IANA response */
+ icmd = CMD_FUJITSU_IRMCS2 | (IPMI_NET_FN_OEM_GROUP_RQ << 8);
+ idata[0] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
+ idata[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
+ idata[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
+ idata[3] = CMD_SPEC_FUJITSU_GET_ERR_LED;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd_mc(icmd, idata, 4, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ switch(rdata[3]) {
+ case 1: rgalarms[1] = LED_OFF; rgalarms[2] = LED_ON; break;
+ case 2: rgalarms[1] = LED_OFF; rgalarms[2] = LED_BLINK; break;
+ case 3: rgalarms[1] = LED_ON; rgalarms[2] = LED_OFF; break;
+ case 4: rgalarms[1] = LED_ON; rgalarms[2] = LED_ON; break;
+ case 5: rgalarms[1] = LED_ON; rgalarms[2] = LED_BLINK; break;
+ case 6: rgalarms[1] = LED_BLINK; rgalarms[2] = LED_OFF; break;
+ case 7: rgalarms[1] = LED_BLINK; rgalarms[2] = LED_ON; break;
+ case 8: rgalarms[1] = LED_BLINK; rgalarms[2] = LED_BLINK; break;
+ case 0:
+ default: rgalarms[1] = LED_OFF; rgalarms[2] = LED_OFF; break;
+ }
+
+ return(rv);
+}
+
+static char *led_str(uchar b)
+{
+ char *pstr;
+ switch(b) {
+ case LED_ON: pstr = "ON"; break;
+ case LED_BLINK: pstr = "Blink"; break;
+ case LED_OFF:
+ default: pstr = "off"; break;
+ }
+ return(pstr);
+}
+
+/*
+ * show_alarms_fujitsu
+ * offset 0 = ID blue LED state (0=off, 1=on, 2=blink)
+ * offset 1 = CSS yellow LED state (0=off, 1=on, 2=blink)
+ * offset 2 = GEL red LED state (0=off, 1=on, 2=blink)
+ */
+int show_alarms_fujitsu(uchar *rgalarms)
+{
+ if (rgalarms == NULL) return(ERR_BAD_PARAM);
+ /* show error, warning, id led statuses */
+ printf("iRMC S2 ID LED (blue) = %s\n",led_str(rgalarms[0]));
+ printf("iRMC S2 CSS LED (yellow) = %s\n",led_str(rgalarms[1]));
+ printf("iRMC S2 GEL LED (red) = %s\n",led_str(rgalarms[2]));
+ return(0);
+}
+
+/*
+ * set_alarms_fujitsu
+ * num: only the ID LED can be set, so num==0
+ * val: 0=LED_OFF, 1=LED_ON
+ */
+int set_alarms_fujitsu(uchar num, uchar val)
+{
+ int rv = -1;
+ uchar idata[16];
+ uchar rdata[16];
+ int rlen;
+ ushort icmd;
+ uchar cc;
+ int vend_id, prod_id;
+
+ get_mfgid(&vend_id,&prod_id);
+ if (vend_id != VENDOR_FUJITSU) return(LAN_ERR_NOTSUPPORT);
+ if (FUJITSU_PRODUCT_IS_iRMC_S1(prod_id)) return(LAN_ERR_NOTSUPPORT);
+
+ /* set the specified LED number to val */
+ icmd = CMD_FUJITSU_IRMCS2 | (IPMI_NET_FN_OEM_GROUP_RQ << 8);
+ idata[0] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
+ idata[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
+ idata[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
+ idata[3] = CMD_SPEC_FUJITSU_SET_ID_LED;
+ if (val == 0xFF) idata[4] = LED_ON;
+ else if (val == 0) idata[4] = LED_OFF;
+ else idata[4] = LED_BLINK;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd_mc(icmd, idata, 5, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+
+ return(rv);
+}
+
+/*
+ * read_sel_fujitsu
+ *
+ * Fujitsu OEM
+ * http://manuals.ts.fujitsu.com/file/4390/irmc_s2-ug-en.pdf
+ *
+ * Request
+ * 0x2E - OEM network function
+ * 0xF5 - OEM cmd
+ * 0x?? - Fujitsu IANA (LSB first)
+ * 0x?? - Fujitsu IANA
+ * 0x?? - Fujitsu IANA
+ * 0x43 - Command Specifier
+ * 0x?? - Record ID (LSB first)
+ * 0x?? - Record ID ; 0x0000 = "first record", 0xFFFF = "last record"
+ * 0x?? - Offset (in response SEL text)
+ * 0x?? - MaxResponseDataSize (size of converted SEL data 16:n in response,
+ * maximum is 100, some only handle 64)
+ *
+ * Response
+ * 0xF5 - OEM cmd
+ * 0x?? - Completion code
+ * 0 0x?? - Fujitsu IANA (LSB first)
+ * 1 0x?? - Fujitsu IANA
+ * 2 0x?? - Fujitsu IANA
+ * 3 0x?? - Next Record ID (LSB)
+ * 4 0x?? - Next Record ID (MSB)
+ * 5 0x?? - Actual Record ID (LSB)
+ * 6 0x?? - Actual Record ID (MSB)
+ * 7 0x?? - Record type
+ * 8 0x?? - timestamp (LSB first)
+ * 9 0x?? - timestamp
+ * 10 0x?? - timestamp
+ * 11 0x?? - timestamp
+ * 12 0x?? - severity
+ * bit 7 - CSS component
+ * bit 6-4 - 000 = INFORMATIONAL
+ * 001 = MINOR
+ * 010 = MAJOR
+ * 011 = CRITICAL
+ * 1xx = unknown
+ * bit 3-0 - reserved
+ * 13 0x?? - data length (of the whole text)
+ * 14 0x?? - converted SEL data
+ * requested number of bytes starting at requested offset
+ * (MaxResponseDataSize-1 bytes of data) .....
+ * 0x00 - trailing '\0' character
+ */
+int read_sel_fujitsu(uint16_t id, char *buf, int sz, char fdbg)
+{
+ int rv = -1;
+ uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
+ uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
+ char textbuf[IPMI_OEM_MAX_BYTES];
+ int rs_len, text_len, data_len, chunk_len;
+ int max_read_length;
+ uint16_t actual_record_id = id;
+ uint32_t timestamp = 0;
+ // uint16_t next_record_id;
+ // uint8_t record_type;
+ uint8_t severity = 0;
+ uint8_t ccode;
+ char timestr[40];
+ char *severity_text = NULL;
+ uint8_t offset = 0;
+ int vend_id, prod_id;
+
+ fdebug = fdbg;
+ if (buf == NULL) return(rv);
+ max_read_length = IPMI_OEM_MAX_BYTES;
+ data_len = IPMI_OEM_MAX_BYTES;
+ /* This command requires admin privilege, so check and
+ print a warning if Fujitsu and not admin. */
+ get_mfgid(&vend_id,&prod_id);
+ if (vend_id == VENDOR_FUJITSU) { /* connected to Fujitsu MC */
+ int auth, priv;
+ if (FUJITSU_PRODUCT_IS_iRMC_S1(prod_id)) {
+ max_read_length = 32;
+ data_len = 80;
+ }
+ rv = get_lan_options(NULL,NULL,NULL,&auth,&priv,NULL,NULL,NULL);
+ if ((rv == 0) && (priv < 4)) { /*remote and not admin priv*/
+ printf("*** Admin privilege (-V 4) required for full OEM decoding.\n");
+ }
+ }
+
+ memset(textbuf,0,sizeof(textbuf));
+ bytes_rq[0] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
+ bytes_rq[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
+ bytes_rq[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
+ bytes_rq[3] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_SEL_ENTRY_LONG_TEXT;
+ bytes_rq[4] = (id & 0x00FF);
+ bytes_rq[5] = (id & 0xFF00) >> 8;
+ bytes_rq[7] = (uchar)max_read_length;
+
+ while (offset < data_len)
+ {
+ bytes_rq[6] = offset;
+ /* Do not ask BMC for data beyond data_len, request partial if so. */
+ if (offset + max_read_length > data_len)
+ bytes_rq[7] = data_len - offset;
+ rs_len = sizeof(bytes_rs);
+ rv = ipmi_cmdraw(IPMI_CMD_OEM_FUJITSU_SYSTEM, IPMI_NET_FN_OEM_GROUP_RQ,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ bytes_rq, 9, bytes_rs, &rs_len, &ccode, fdebug);
+ if (fdebug) printf("read_sel_fujitsu rv = %d, cc = %x\n", rv, ccode);
+ if (rv == 0 && ccode != 0) rv = ccode;
+ if (rv != 0) return(rv);
+ if (fdebug) dump_buf("read_sel_fujitsu data",bytes_rs,rs_len,1);
+
+ if (offset == 0) { /* only need to set these on the first pass */
+ actual_record_id = bytes_rs[5] + (bytes_rs[6] << 8);
+ timestamp = bytes_rs[8] + (bytes_rs[9] << 8) +
+ (bytes_rs[10] << 16) + (bytes_rs[11] << 24);
+ severity = (bytes_rs[12] >> 3);
+ data_len = bytes_rs[13];
+ if (data_len > IPMI_OEM_MAX_BYTES) data_len = IPMI_OEM_MAX_BYTES;
+ }
+ chunk_len = rs_len - 14;
+ if ((offset + chunk_len) > IPMI_OEM_MAX_BYTES)
+ chunk_len = IPMI_OEM_MAX_BYTES - offset;
+ memcpy(&textbuf[offset],&bytes_rs[14],chunk_len);
+ offset += (uint8_t)chunk_len;
+ }
+ textbuf[IPMI_OEM_MAX_BYTES-1]='\0'; /*stringify*/
+ text_len = strlen_(textbuf);
+
+ switch (severity) {
+ case 0: severity_text = "INFORMATIONAL:"; break;
+ case 1: severity_text = "MINOR:"; break;
+ case 2: severity_text = "MAJOR:"; break;
+ case 3: severity_text = "CRITICAL:"; break;
+ case 4:
+ case 5:
+ case 6:
+ case 7: severity_text = ""; break;
+ case 8: severity_text = "INFORMATIONAL/CSS:"; break;
+ case 9: severity_text = "MINOR/CSS:"; break;
+ case 10: severity_text = "MAJOR/CSS:"; break;
+ case 11: severity_text = "CRITICAL/CSS:"; break;
+ case 12:
+ case 13:
+ case 14:
+ case 15: severity_text = "unknown/CSS:"; break;
+ }
+
+ fmt_time(timestamp, timestr, sizeof(timestr));
+ snprintf(buf, sz, "%u | %s | %s %s\n", (int)actual_record_id,
+ timestr, severity_text, textbuf);
+ return rv;
+}
+
+/*
+ * decode_sel_fujitsu
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_fujitsu(uint8_t *evt, char *outbuf, int outsz, char fdesc,
+ char fdbg)
+{
+ int rv = -1;
+ uint16_t id;
+ uint8_t rectype;
+ int oemid;
+ uint32_t timestamp;
+ char mybuf[64];
+ char *type_str = NULL;
+ char *gstr = NULL;
+ char *pstr = NULL;
+ ushort genid;
+ int sevid;
+
+ fdebug = fdbg;
+ id = evt[0] + (evt[1] << 8);
+ if (freadok) {
+ rv = read_sel_fujitsu(id, outbuf, outsz, fdbg);
+ if (rv == 0) return(rv); /*success, done*/
+ }
+ freadok = 0; /*not fujitsu or not local, so do not retry */
+
+ sevid = SEV_INFO;
+ /* instead try to decode some events manually */
+ rectype = evt[2];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ if (rectype == 0xc1) { /* OEM type C1 */
+ oemid = evt[7] + (evt[8] << 8) + (evt[9] << 16);
+ if (oemid == VENDOR_FUJITSU) {
+ type_str = "Fujitsu";
+ gstr = "BMC ";
+ switch(evt[10]) {
+ case 0x09:
+ sprintf(mybuf,"iRMC S2 CLI/Telnet user %d login from %d.%d.%d.%d",
+ evt[11], evt[12], evt[13], evt[14], evt[15]);
+ break;
+ case 0x0a:
+ sprintf(mybuf,"iRMC S2 CLI/Telnet user %d logout from %d.%d.%d.%d",
+ evt[11], evt[12], evt[13], evt[14], evt[15]);
+ break;
+ default:
+ sprintf(mybuf,"iRMC S2 Event %02x %02x %02x %02x %02x %02x",
+ evt[10], evt[11], evt[12], evt[13], evt[14], evt[15]);
+ break;
+ }
+ format_event(id,timestamp, sevid, genid, type_str,
+ evt[10],NULL,mybuf,NULL,outbuf,outsz);
+ rv = 0;
+ } /*endif fujitsu oem */
+ } else if (rectype == 0x02) {
+ type_str = "iRMC S2";
+ gstr = "BMC ";
+ sprintf(mybuf,"%02x [%02x %02x %02x]", evt[12],evt[13],evt[14],evt[15]);
+ switch(evt[10]) { /*sensor type*/
+ case 0xc8:
+ switch(evt[13]) {
+ case 0x29:
+ sprintf(mybuf,"CLI/Telnet user %d login", evt[15]);
+ break;
+ case 0x2a:
+ sprintf(mybuf,"CLI/Telnet user %d logout", evt[15]);
+ break;
+ case 0x21:
+ sprintf(mybuf,"Browser user %d login", evt[15]);
+ break;
+ case 0x22:
+ sprintf(mybuf,"Browser user %d logout", evt[15]);
+ break;
+ case 0x23:
+ sprintf(mybuf,"Browser user %d auto-logout", evt[15]);
+ break;
+ default: /*mybuf has the raw bytes*/
+ break;
+ }
+ pstr = mybuf;
+ rv = 0;
+ break;
+ case 0xca:
+ if (evt[13] == 0x26) pstr = "Paging: Email - notification failed";
+ else if (evt[13] == 0xa6) pstr = "Paging: Email - DNS failed";
+ else pstr = mybuf;
+ rv = 0;
+ break;
+ case 0xe1:
+ sevid = SEV_MAJ;
+ if (evt[13] == 0x0f) pstr = "MC access degraded";
+ else pstr = mybuf;
+ rv = 0;
+ break;
+ case 0xec:
+ if (evt[13] == 0xa0) {
+ sprintf(mybuf,"Firmware flash version %d.%d",
+ (evt[14] & 0x0f),evt[15]);
+ }
+ pstr = mybuf;
+ rv = 0;
+ break;
+ case 0xee:
+ type_str = "iRMC S2";
+ if (evt[12] == 0x0a && evt[13] == 0x80)
+ pstr = "Automatic restart after power fail";
+ else pstr = mybuf;
+ rv = 0;
+ break;
+ default: break;
+ }
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ evt[11],NULL,pstr,NULL,outbuf,outsz);
+ /*evt[11] = sensor number */
+ }
+ }
+ return rv;
+}
+
+
+/*
+ * Fujitsu iRMC S1 / iRMC S2 OEM Sensor logic
+ */
+
+/* 0xDD */
+const char * const ipmi_sensor_type_oem_fujitsu_system_power_consumption[] =
+ {
+ /* EN 0x00 */ "System Power Consumption within Limit",
+ /* EN 0x01 */ "System Power Consumption above Warning Level",
+ /* EN 0x02 */ "System Power Consumption above Critical Level",
+ /* EN 0x03 */ "System Power Consumption limiting disabled",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_system_power_consumption_max_index = 0x03;
+
+
+/* 0xDE */
+const char * const ipmi_sensor_type_oem_fujitsu_memory_status[] =
+ {
+ /* EN 0x00 */ "Empty slot",
+ /* EN 0x01 */ "OK",
+ /* EN 0x02 */ "Reserved",
+ /* EN 0x03 */ "Error",
+ /* EN 0x04 */ "Fail",
+ /* EN 0x05 */ "Prefailure",
+ /* EN 0x06 */ "Reserved",
+ /* EN 0x07 */ "Unknown",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_memory_status_max_index = 0x07;
+
+/* 0xDF */
+const char * const ipmi_sensor_type_oem_fujitsu_memory_config[] =
+ {
+ /* EN 0x00 */ "Normal",
+ /* EN 0x01 */ "Disabled",
+ /* EN 0x02 */ "Spare module",
+ /* EN 0x03 */ "Mirrored module",
+ /* EN 0x04 */ "RAID module",
+ /* EN 0x05 */ "Not Usable",
+ /* EN 0x06 */ "Unspecified state(6)",
+ /* EN 0x07 */ "Unspecified state(7)",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_memory_config_max_index = 0x07;
+
+/* 0xE1 */
+const char * const ipmi_sensor_type_oem_fujitsu_memory[] =
+ {
+ /* EN 0x00 */ "Non Fujitsu memory module detected",
+ /* EN 0x01 */ "Memory module replaced",
+ /* EN 0x02 */ "Fatal general memory error",
+ /* EN 0x03 */ "Recoverable general memory error",
+ /* EN 0x04 */ "Recoverable ECC memory error",
+ /* EN 0x05 */ "Recoverable CRC memory error",
+ /* EN 0x06 */ "Fatal CRC memory error",
+ /* EN 0x07 */ "Recoverable thermal memory event",
+ /* EN 0x08 */ "Fatal thermal memory error",
+ /* EN 0x09 */ "Too many correctable memory errors",
+ /* EN 0x0A */ "Uncorrectable Parity memory error",
+ /* EN 0x0B */ "Memory Modules swapped",
+ /* EN 0x0C */ "Memory Module moved",
+ /* EN 0x0D */ "Memory removed",
+ /* EN 0x0E */ "Memory Re-inserted",
+ /* EN 0x0F */ "Memory module(s) changed",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_memory_max_index = 0x0F;
+
+/* 0xE3 */
+const char * const ipmi_sensor_type_oem_fujitsu_hw_error[] =
+ {
+ /* EN 0x00 */ "TPM Error",
+ /* EN 0x01 */ "Reserved",
+ /* EN 0x02 */ "No usable CPU",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_hw_error_max_index = 0x02;
+
+/* 0xE4 */
+const char * const ipmi_sensor_type_oem_fujitsu_sys_error[] =
+ {
+ /* EN 0x00 */ "System configuration Data error",
+ /* EN 0x01 */ "Resource Conflict", /* Slot in EventData3 */
+ /* EN 0x02 */ "IRQ not configured", /* Slot in EventData3 */
+ /* EN 0x03 */ "Device node allocation error", /* Device in EventData3 */
+ /* EN 0x04 */ "Expansion ROM Slot not initialized", /* Slot in EventData3 */
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_sys_error_max_index = 0x04;
+
+/* 0xE6 */
+const char * const ipmi_sensor_type_oem_fujitsu_fan_status[] =
+ {
+ /* EN 0x00 */ "FAN on, running",
+ /* EN 0x01 */ "FAN failed",
+ /* EN 0x02 */ "FAN prefailure",
+ /* EN 0x03 */ "Redundant FAN failed",
+ /* EN 0x04 */ "FAN not manageable",
+ /* EN 0x05 */ "FAN not installed",
+ /* EN 0x06 */ "FAN unspecified state(6)",
+ /* EN 0x07 */ "FAN in init phase",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_fan_status_max_index = 0x07;
+
+/* 0xE8 */
+const char * const ipmi_sensor_type_oem_fujitsu_psu_status[] =
+ {
+ /* EN 0x00 */ "Power supply - Not present",
+ /* EN 0x01 */ "Power supply - OK",
+ /* EN 0x02 */ "Power supply - Failed",
+ /* EN 0x03 */ "Redundant power supply - AC failed",
+ /* EN 0x04 */ "Redundant power supply - DC failed",
+ /* EN 0x05 */ "Power supply - Critical Temperature",
+ /* EN 0x06 */ "Power supply - Not manageable",
+ /* EN 0x07 */ "Power supply - Fan failure predicted",
+ /* EN 0x08 */ "Power supply - Fan failed",
+ /* EN 0x09 */ "Power supply - Power Save Mode",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_psu_status_max_index = 0x09;
+
+/* 0xE9 */
+const char * const ipmi_sensor_type_oem_fujitsu_psu_redundancy[] =
+ {
+ /* EN 0x00 */ "Power Supply - redundancy present",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_psu_redundancy_max_index = 0x00;
+
+/* 0xEC */
+const char * const ipmi_sensor_type_oem_fujitsu_flash[] =
+ {
+ /* EN 0x00 */ "Online firmware flash",
+ /* EN 0x01 */ "Online firmware flash: reboot",
+ /* EN 0x02 */ "BIOS TFTP Flash: OK",
+ /* EN 0x03 */ "BIOS TFTP Flash: failed",
+ /* EN 0x04 */ "iRMC TFTP Flash: OK",
+ /* EN 0x05 */ "iRMC TFTP Flash: failed",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_flash_max_index = 0x05;
+
+/* 0xEF */
+const char * const ipmi_sensor_type_oem_fujitsu_config_backup[] =
+ {
+ /* EN 0x00 */ "Chassis IDPROM: Motherboard Exchange detected",
+ /* EN 0x01 */ "Chassis IDPROM: Read or Write error",
+ /* EN 0x02 */ "Chassis IDPROM: Restore successful",
+ /* EN 0x03 */ "Chassis IDPROM: Restore failed",
+ /* EN 0x04 */ "Chassis IDPROM: Backup successful",
+ /* EN 0x05 */ "Chassis IDPROM: Backup failed",
+ /* EN 0x06 */ "Chassis IDPROM: Feature disabled",
+ /* EN 0x07 */ "Chassis IDPROM: Function Not Available",
+ /* EN 0x08 */ "Reserved",
+ /* EN 0x09 */ "Reserved",
+ /* EN 0x0A */ "Reserved",
+ /* EN 0x0B */ "Reserved",
+ /* EN 0x0C */ "Reserved",
+ /* EN 0x0D */ "Reserved",
+ /* EN 0x0E */ "Reserved",
+ /* EN 0x0F */ "NVRAM defaults loaded",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_config_backup_max_index = 0x0F;
+
+/* 0xEF */
+const char * const ipmi_sensor_type_oem_fujitsu_i2c_bus[] =
+ {
+ /* EN 0x00 */ "I2C Bus Error",
+ /* EN 0x01 */ "I2C Bus OK",
+ /* EN 0x02 */ "I2C Bus Disabled",
+ /* EN 0x03 */ "I2C Bus Failed",
+ NULL
+ };
+unsigned int ipmi_sensor_type_oem_fujitsu_i2c_bus_max_index = 0x03;
+
+static char * get_array_message (unsigned int offset,
+ unsigned int offset_max,
+ const char * const string_array[])
+{
+ if (offset > offset_max) return("unknown");
+ return((char *)string_array[offset]);
+}
+
+
+static char *get_oem_reading_string(uchar sensor_type, uchar offset)
+{
+ char * pstr = "";
+ /*
+ * OEM Interpretation
+ * Fujitsu iRMC S1 / iRMC S2
+ */
+ switch (sensor_type)
+ {
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_I2C_BUS:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_i2c_bus_max_index,
+ ipmi_sensor_type_oem_fujitsu_i2c_bus));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_SYSTEM_POWER_CONSUMPTION:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_system_power_consumption_max_index,
+ ipmi_sensor_type_oem_fujitsu_system_power_consumption));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_STATUS:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_memory_status_max_index,
+ ipmi_sensor_type_oem_fujitsu_memory_status));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_CONFIG:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_memory_config_max_index,
+ ipmi_sensor_type_oem_fujitsu_memory_config));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_memory_max_index,
+ ipmi_sensor_type_oem_fujitsu_memory));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_HW_ERROR:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_hw_error_max_index,
+ ipmi_sensor_type_oem_fujitsu_hw_error));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_SYS_ERROR:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_sys_error_max_index,
+ ipmi_sensor_type_oem_fujitsu_sys_error));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_FAN_STATUS:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_fan_status_max_index,
+ ipmi_sensor_type_oem_fujitsu_fan_status));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_STATUS:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_psu_status_max_index,
+ ipmi_sensor_type_oem_fujitsu_psu_status));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_REDUNDANCY:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_psu_redundancy_max_index,
+ ipmi_sensor_type_oem_fujitsu_psu_redundancy));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_FLASH:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_flash_max_index,
+ ipmi_sensor_type_oem_fujitsu_flash));
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_CONFIG_BACKUP:
+ return (get_array_message (offset,
+ ipmi_sensor_type_oem_fujitsu_config_backup_max_index,
+ ipmi_sensor_type_oem_fujitsu_config_backup));
+ /* These are reserved */
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_COMMUNICATION:
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_EVENT:
+ default:
+ break;
+ }
+ return(pstr);
+}
+
+
+static char *get_oem_sensor_type_string (uint8_t sensor_type)
+{
+ switch (sensor_type) {
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_I2C_BUS : return ("OEM I2C Bus");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_SYSTEM_POWER_CONSUMPTION: return ("OEM Power Consumption");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_STATUS : return ("OEM Memory Status");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_CONFIG : return ("OEM Memory Config");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY : return ("OEM Memory");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_FAN_STATUS : return ("OEM Fan Status");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_STATUS : return ("OEM PSU Status");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_REDUNDANCY: return ("OEM PSU Redundancy");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_COMMUNICATION : return ("OEM Communication");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_FLASH : return ("OEM Flash");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_EVENT : return ("OEM Event");
+ case IPMI_SENSOR_TYPE_OEM_FUJITSU_CONFIG_BACKUP : return ("OEM Config Backup");
+ default : break; /* fall into generic case below */
+ }
+ return ("");
+}
+
+
+int decode_sensor_fujitsu(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ char *typestr = NULL;
+ char *readstr = NULL;
+ uchar stype;
+ int vend_id, prod_id;
+
+ /* Only get here if vend_id == VENDOR_FUJITSU */
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ stype = sdr[12];
+ typestr = get_oem_sensor_type_string(stype);
+
+ get_mfgid(&vend_id,&prod_id);
+ if (vend_id == IPMI_IANA_ENTERPRISE_ID_FUJITSU
+ && (prod_id >= IPMI_FUJITSU_PRODUCT_ID_MIN
+ && prod_id <= IPMI_FUJITSU_PRODUCT_ID_MAX)) {
+ readstr = get_oem_reading_string(stype,reading[2]);
+ if (readstr != NULL && (readstr[0] != 0)) rv = 0;
+ } else readstr = "";
+ snprintf (pstring, slen, "%s = %s",typestr,readstr);
+ return(rv);
+}
+
+/* end oem_fujitsu.c */
diff --git a/util/oem_fujitsu.h b/util/oem_fujitsu.h
new file mode 100644
index 0000000..defc6ac
--- /dev/null
+++ b/util/oem_fujitsu.h
@@ -0,0 +1,130 @@
+/*
+ * oem_fujitsu.h
+ *
+ * Authors: Andy Cress arcress at users.sourceforge.net, and
+ * Dan Lukes dan at obluda.cz
+ *
+ * 08/27/10 Andy Cress - added with source input from Dan Lukes
+ */
+/*M*
+The BSD 2.0 License
+
+Copyright (c) 2009 Kontron America, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron, nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+
+#define IPMI_OEM_MAX_BYTES 100
+#define IPMI_IANA_ENTERPRISE_ID_FUJITSU 10368
+#define IPMI_NET_FN_OEM_GROUP_RQ 0x2E
+#define IPMI_CMD_OEM_FUJITSU_SYSTEM 0xF5
+#define IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_SEL_ENTRY_LONG_TEXT 0x43
+
+#define IPMI_FUJITSU_PRODUCT_ID_MIN 0x0200
+#define IPMI_FUJITSU_PRODUCT_ID_MAX 0x03FF
+// iRMC-S1 based systems
+#define IPMI_FUJITSU_PRODUCT_ID_TX200S3 0x0200
+#define IPMI_FUJITSU_PRODUCT_ID_TX300S3 0x0201
+#define IPMI_FUJITSU_PRODUCT_ID_RX200S3 0x0202
+#define IPMI_FUJITSU_PRODUCT_ID_RX300S3 0x0203
+#define IPMI_FUJITSU_PRODUCT_ID_UNUSEDS3 0x0204
+#define IPMI_FUJITSU_PRODUCT_ID_RX100S4 0x0205
+#define IPMI_FUJITSU_PRODUCT_ID_TX150S5 0x0206
+#define IPMI_FUJITSU_PRODUCT_ID_TX120S1 0x0207
+#define IPMI_FUJITSU_PRODUCT_ID_BX630S2 0x0208
+#define IPMI_FUJITSU_PRODUCT_ID_RX330S1 0x0209
+#define IPMI_FUJITSU_PRODUCT_ID_E230RN1 0x0210
+#define IPMI_FUJITSU_PRODUCT_ID_E230RSL 0x0211
+#define IPMI_FUJITSU_PRODUCT_ID_RX330S1_SHA 0x0212
+#define IPMI_FUJITSU_PRODUCT_ID_BX630S2_SHA 0x0213
+
+#define FUJITSU_PRODUCT_IS_iRMC_S1(_product_id_) \
+ ((_product_id_) == IPMI_FUJITSU_PRODUCT_ID_TX200S3 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_TX300S3 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_RX200S3 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_RX300S3 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_UNUSEDS3 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_RX100S4 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_TX150S5 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_TX120S1 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_BX630S2 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_RX330S1 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_E230RN1 \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_E230RSL \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_RX330S1_SHA \
+ || (_product_id_) == IPMI_FUJITSU_PRODUCT_ID_BX630S2_SHA)
+
+// iRMC-S2 based systems
+#define IPMI_FUJITSU_PRODUCT_ID_RX600S4 0x0218
+#define IPMI_FUJITSU_PRODUCT_ID_TX200S4 0x0220
+#define IPMI_FUJITSU_PRODUCT_ID_TX300S4 0x0221
+#define IPMI_FUJITSU_PRODUCT_ID_RX200S4 0x0222
+#define IPMI_FUJITSU_PRODUCT_ID_RX300S4 0x0223
+#define IPMI_FUJITSU_PRODUCT_ID_UNUSEDS4 0x0224
+#define IPMI_FUJITSU_PRODUCT_ID_RX100S5 0x0225
+#define IPMI_FUJITSU_PRODUCT_ID_TX150S6 0x0226
+#define IPMI_FUJITSU_PRODUCT_ID_TX120S2 0x0227
+#define IPMI_FUJITSU_PRODUCT_ID_TX150S6_64K 0x0233
+#define IPMI_FUJITSU_PRODUCT_ID_TX200S4_64K 0x0234
+#define IPMI_FUJITSU_PRODUCT_ID_TX300S4_64K 0x0235
+#define IPMI_FUJITSU_PRODUCT_ID_TX200S5 0x0240
+#define IPMI_FUJITSU_PRODUCT_ID_TX300S5 0x0241
+#define IPMI_FUJITSU_PRODUCT_ID_RX200S5 0x0242
+#define IPMI_FUJITSU_PRODUCT_ID_RX300S5 0x0243
+#define IPMI_FUJITSU_PRODUCT_ID_BX620S5 0x0244
+#define IPMI_FUJITSU_PRODUCT_ID_RX100S6 0x0245
+#define IPMI_FUJITSU_PRODUCT_ID_TX150S7 0x0246
+#define IPMI_FUJITSU_PRODUCT_ID_BX960S1 0x0254
+#define IPMI_FUJITSU_PRODUCT_ID_BX924S1 0x0255
+#define IPMI_FUJITSU_PRODUCT_ID_BX920S1 0x0256
+#define IPMI_FUJITSU_PRODUCT_ID_BX922S1 0x0257
+#define IPMI_FUJITSU_PRODUCT_ID_RX600S5 0x0258
+#define IPMI_FUJITSU_PRODUCT_ID_TX200S6 0x0260
+#define IPMI_FUJITSU_PRODUCT_ID_TX300S6 0x0261
+#define IPMI_FUJITSU_PRODUCT_ID_RX200S6 0x0262
+#define IPMI_FUJITSU_PRODUCT_ID_RX300S6 0x0263
+
+/*******************************************
++ * Fujitsu Siemens Computers *
++ * Fujitsu Technology Solutions *
++ * iRMC S1 / iRMC S2 *
++ *******************************************/
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_I2C_BUS 0xC0
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_SYSTEM_POWER_CONSUMPTION 0xDD //Events only
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_STATUS 0xDE
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY_CONFIG 0xDF
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_MEMORY 0xE1 // Events only
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_HW_ERROR 0xE3 // Events only
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_SYS_ERROR 0xE4 // Events only
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_FAN_STATUS 0xE6
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_STATUS 0xE8
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_PSU_REDUNDANCY 0xE9
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_COMMUNICATION 0xEA // Reserved
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_FLASH 0xEC // Events only
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_EVENT 0xEE // Reserved
+#define IPMI_SENSOR_TYPE_OEM_FUJITSU_CONFIG_BACKUP 0xEF
diff --git a/util/oem_hp.c b/util/oem_hp.c
new file mode 100644
index 0000000..29a813f
--- /dev/null
+++ b/util/oem_hp.c
@@ -0,0 +1,149 @@
+/*
+ * oem_hp.c
+ * Handle HP OEM command functions
+ *
+ * Change history:
+ * 02/23/2012 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2012 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+#include "isensor.h"
+
+static char *redund_str(uchar b)
+{
+ char *pstr;
+ if (b == 0x00) pstr = "Disabled";
+ else if (b == 0x01) pstr = "Fully Redundant";
+ else if (b == 0x02) pstr = "Redundancy Lost";
+ else if (b == 0x0b) pstr = "AC Lost";
+ else pstr = "Redundancy Degraded";
+ return(pstr);
+}
+
+/*
+ * decode_sensor_hp
+ * inputs:
+ * sdr = the SDR buffer
+ * reading = the 3 or 4 bytes of data from GetSensorReading
+ * pstring = points to the output string buffer
+ * slen = size of the output buffer
+ * outputs:
+ * rv = 0 if this sensor was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_hp(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ char *pstr = NULL;
+ uchar stype, evtype, b;
+ ushort v;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ /* sdr[3] is SDR type 1=full, 2=compact */
+ stype = sdr[12]; /*sensor type*/
+ evtype = sdr[13]; /*event type */
+ if (stype == 0xC0) { /* HP OEM Sensor, no sensor reading */
+ strncpy(pstring,"na",slen); /*oem*/
+ rv = 0;
+ } else {
+ if ((reading[2] & 0x40) == 0x40) { /*Init/Unavail state*/
+ strncpy(pstring,"Init",slen);
+ rv = 0;
+ } else if ((sdr[20] & 0xC0) == 0xC0) { /*unit1==discrete*/
+ b = reading[2] & 0x3f;
+ pstr = "DiscreteUnit";
+ if (evtype == 0x0b) pstr = redund_str(b);
+ snprintf(pstring,slen,"%02x%02x %s",reading[3],reading[2],pstr);
+ rv = 0;
+ } else if (evtype == 0x6f) { /*evtype==0x6f special*/
+ pstr = "DiscreteEvt";
+ if (stype == 0x08) { /*Power Supply presence*/
+ if (reading[2] & 0x01) pstr = "Present";
+ else pstr = "Absent";
+ }
+ snprintf(pstring,slen,"%02x%02x %s",reading[3],reading[2],pstr);
+ rv = 0;
+ } else if (evtype == 0x0B) { /*Redundancy*/
+ b = reading[2] & 0x3f;
+ pstr = "DiscretePS"; /*Power Supplies*/
+ if (evtype == 0x0b) pstr = redund_str(b);
+ snprintf(pstring,slen,"%02x%02x %s",reading[3],reading[2],pstr);
+ rv = 0;
+ } else if (evtype == 0x0A) { /*Discrete Fan*/
+ v = reading[2] + (reading[3] & 0x3f);
+ if (v & 0x001) pstr = "Transition to Running";
+ else if (v & 0x002) pstr = "Transition to In Test";
+ else if (v & 0x004) pstr = "Transition to Power Off";
+ else if (v & 0x008) pstr = "Transition to On Line";
+ else if (v & 0x010) pstr = "Transition to Off Line";
+ else if (v & 0x020) pstr = "Transition to Off Duty";
+ else if (v & 0x040) pstr = "Transition to Degraded";
+ else if (v & 0x080) pstr = "Transition to Power";
+ else if (v & 0x100) pstr = "Install Error";
+ else pstr = "Unknown";
+ snprintf(pstring,slen,"%02x%02x %s",reading[3],reading[2],pstr);
+ rv = 0;
+ } else if (evtype == 0x09) { /* stype==0x03 Power Meter */
+ b = reading[2] & 0x3f;
+ if (b & 0x01) pstr = "Disabled";
+ else if (b & 0x02) pstr = "Enabled";
+ else pstr = "Unknown";
+ snprintf(pstring,slen,"%02x%02x %s",reading[3],reading[2],pstr);
+ rv = 0;
+ }
+ }
+ return(rv);
+}
+
+void show_oemsdr_hp(uchar *sdr)
+{
+ int len, i;
+
+ len = sdr[4] + 5;
+ if (sdr[8] == 0x02) len = 18;
+ printf("HP: ");
+ for (i = 8; i < len; i++)
+ printf("%02x ",sdr[i]);
+ if (sdr[8] == 0x02) printf("%s",&sdr[18]);
+ printf("\n");
+ return;
+}
+
+/* end oem_hp.c */
diff --git a/util/oem_intel.c b/util/oem_intel.c
new file mode 100644
index 0000000..f568300
--- /dev/null
+++ b/util/oem_intel.c
@@ -0,0 +1,1842 @@
+/*
+ * oem_intel.c
+ *
+ * This module handles code specific to Intel platforms,
+ * including the Intel/Kontron Telco Alarms panel.
+ *
+ * Note that the Intel BMC TAM will set these alarms
+ * based on firmware-detected thresholds and events.
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2005 Intel Corporation
+ * Copyright (c) 2010 Kontron America, Inc.
+ *
+ * Compile flags for oem_intel.c:
+ * NO_CMD would be defined if linking with ievents.c only (no ipmicmd code)
+ * NO_EVENTS would be defined if linking with ialarms.c (no ievents code)
+ *
+ * 09/02/10 Andy Cress - separated from ialarms.c
+ */
+/*M*
+Copyright (c) 2005 Intel Corporation
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#if defined(DOS)
+#include <dos.h>
+#endif
+#include "ipmicmd.h"
+#include "oem_intel.h"
+
+#ifdef METACOMMAND
+#include "ievents.h"
+extern char fsm_debug; /*mem_if.c*/
+extern int sens_verbose; /*isensor.c*/
+extern int get_sensdesc(uchar sa, int snum, char *sdesc, int *pstyp, int *pidx);
+extern int get_MemDesc(int array, int dimm, char *desc, int *psz); /*mem_if.c*/
+#else
+static char fsm_debug = 0;
+static int sens_verbose = 0;
+static int get_MemDesc(int array, int dimm, char *desc, int *psz) { return -1;}
+#if !defined(NO_CMD)
+int get_sensdesc(uchar sa, int snum, char *sensdesc, int *pstyp, int *pidx)
+{ return(-1); }
+#endif
+static char *get_sensor_type_desc(uchar stype)
+{
+ static char tstr[12];
+ sprintf(tstr,"%02x",stype);
+ return(tstr);
+}
+#endif
+extern char fdebug; /*ipmicmd.c*/
+
+/*
+ * Global variables
+ */
+static char fRelayBits = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+#ifdef OLD
+#ifdef WIN32
+/* Windows tamutil is installed by the ipmirastools package from Kontron. */
+static char *tam1cmd = "\"\"%ProgramFiles%\"\\Intel\\ipmirastools\\tamutil\" >NUL: 2>NUL:";
+static char *tam2cmd = "\"\"%ProgramFiles%\"\\Intel\\ipmirastools\\tamutil\" |findstr TAM.Status >NUL:";
+//static char * tam3cmd = "ipmiutil sensor |findstr BMC_TAM >NUL:";
+//static char * tambcmd = "bmcTamActive"; /*old*/
+#define RET_NOT_FOUND 1 /*command not found (%ERRORLEVE%=9009)*/
+#else
+/* Linux tamutil is installed by the ipmimisc package from Kontron. */
+static char *tam1cmd = "/usr/share/ipmimisc/tamutil >/dev/null 2>&1";
+static char *tam2cmd = "/usr/share/ipmimisc/tamutil 2>/dev/null |grep TAM.Status >/dev/null";
+//static char * tam3cmd = "ipmiutil sensor |grep BMC_TAM >/dev/null";
+//static char * tambcmd = "/usr/local/tam/bin/bmcTamActive 2>/dev/null"; /*old*/
+//#define RET_TAMB_ACTIVE 256 /*from bmcTamActive, if BMC TAM is enabled*/
+#define RET_NOT_FOUND 32512 /*command not found ($?=127 if shell)*/
+#endif
+#endif
+
+#ifdef NOT
+#define PRIVATE_BUS_ID 0x03 // w Sahalee, the 8574 is on Private Bus 1
+#define PRIVATE_BUS_ID5 0x05 // for Intel TIGI2U
+#define PRIVATE_BUS_ID7 0x07 // for Intel S5000
+#define PERIPHERAL_BUS_ID 0x24 // w mBMC, the 8574 is on the Peripheral Bus
+#define ALARMS_PANEL_WRITE 0x40
+#define ALARMS_PANEL_READ 0x41
+#define DISK_LED_WRITE 0x44 // only used for Chesnee mBMC
+#define DISK_LED_READ 0x45 // only used for Chesnee mBMC
+#endif
+
+#if defined(NO_CMD)
+const char * val2str(ushort val, const struct valstr *vs)
+{
+ static char un_str[32];
+ int i;
+ for (i = 0; vs[i].str != NULL; i++)
+ if (vs[i].val == val) return vs[i].str;
+ memset(un_str, 0, 32);
+ snprintf(un_str, 32, "Unknown (0x%x)", val);
+ return un_str;
+}
+#else
+uchar get_nsc_diskleds(uchar busid)
+{
+ uchar inputData[4];
+ uchar rdata[16];
+ int responseLength = 4;
+ uchar completionCode;
+ int ret;
+
+ inputData[0] = busid;
+ inputData[1] = DISK_LED_READ;
+ inputData[2] = 0x1; // return one byte of LED data
+ inputData[3] = 0x00; // init data to zero
+ ret = ipmi_cmd(MASTER_WRITE_READ, inputData, 3, rdata,
+ &responseLength, &completionCode, fdebug);
+ if (ret != 0) {
+ printf("get_nsc_diskleds: ret = %d, ccode %02x, leds = %02x\n",
+ ret, completionCode, rdata[0]);
+ return(0);
+ }
+ return(rdata[0]);
+} /*end get_nsc_diskleds()*/
+
+int set_nsc_diskleds(uchar val, uchar busid)
+{
+ uchar inputData[4];
+ uchar rdata[16];
+ int responseLength = 4;
+ uchar completionCode;
+ int ret;
+
+ inputData[0] = busid;
+ inputData[1] = DISK_LED_WRITE;
+ inputData[2] = 0x01; // len = one byte of LED data
+ inputData[3] = val;
+ ret = ipmi_cmd(MASTER_WRITE_READ, inputData, 4, rdata,
+ &responseLength, &completionCode, fdebug);
+ if (ret != 0) {
+ printf("set_nsc_diskleds: ret = %d, ccode %02x, leds = %02x\n",
+ ret, completionCode, val);
+ return(0);
+ }
+ return(ret);
+} /*end set_nsc_diskleds()*/
+
+void show_nsc_diskleds(uchar val)
+{
+ if (fdebug) printf("diskled = %02x\n",val);
+ printf("disk A: ");
+ if ((val & 0x20) == 0) printf("present");
+ else printf("not present");
+ if ((val & 0x02) == 0) printf("/faulted ");
+ printf("\ndisk B: ");
+ if ((val & 0x10) == 0) printf("present");
+ else printf("not present");
+ if ((val & 0x01) == 0) printf("/faulted ");
+ printf("\n");
+}
+
+uchar get_alarms_intel(uchar busid)
+{
+ uchar inputData[4];
+ uchar rdata[16];
+ int responseLength = 4;
+ uchar completionCode;
+ int ret;
+
+ inputData[0] = busid;
+ inputData[1] = ALARMS_PANEL_READ;
+ inputData[2] = 0x1; // return one byte of alarms data
+ inputData[3] = 0x00; // init data to zero
+ ret = ipmi_cmd(MASTER_WRITE_READ, inputData, 3, rdata,
+ &responseLength, &completionCode, fdebug);
+ if (ret != 0 || completionCode != 0) {
+ printf("get_alarms: ret = %d, ccode %02x, alarms = %02x\n",
+ ret, completionCode, rdata[0]);
+ return(0);
+ }
+ return(rdata[0]);
+} /*end get_alarms()*/
+
+int set_alarms_intel(uchar val, uchar busid)
+{
+ uchar inputData[4];
+ uchar rdata[16];
+ int responseLength = 4;
+ uchar completionCode;
+ int ret;
+
+ inputData[0] = busid;
+ inputData[1] = ALARMS_PANEL_WRITE;
+ inputData[2] = 0x1; // one byte of alarms data
+ inputData[3] = val;
+ ret = ipmi_cmd(MASTER_WRITE_READ, inputData, 4, rdata,
+ &responseLength, &completionCode, fdebug);
+ if (ret != 0) {
+ printf("set_alarms: ret = %d, ccode %02x, value = %02x\n",
+ ret, completionCode, val);
+ return(ret);
+ }
+ if (completionCode != 0) ret = completionCode;
+ return(ret);
+} /*end set_alarms()*/
+
+/*
+ * show_alarms
+ *
+ * The alarm control/status byte is decoded as follows:
+ * bit
+ * 7 = reserved, always write 1
+ * 6 = LED colors, 1 = amber (default), 0 = red
+ * Colors were added in some later firmware versions, but
+ * not for all platforms.
+ * 5 = Minor Relay bit, 0 = on, 1 = off, always write 1
+ * 4 = Major Relay bit, 0 = on, 1 = off, always write 1
+ * 3 = Minor LED bit, 0 = on, 1 = off
+ * 2 = Major LED bit, 0 = on, 1 = off
+ * 1 = Critical LED bit, 0 = on, 1 = off
+ * 0 = Power LED bit, 0 = on, 1 = off
+ *
+ * Note that the Power LED is also wired to the System Fault LED
+ * in the back of the system, so this state may be off for Power,
+ * but the LED could be lit for a System Fault reason instead.
+ */
+void show_alarms_intel(uchar val)
+{
+ char *scrit = "ON ";
+ char *smaj = "ON ";
+ char *smin = "ON ";
+ char *spow = "ON ";
+ char *rmaj = "ON";
+ char *rmin = "ON";
+ if (fdebug) printf("alarms = %02x\n",val);
+
+ if (val & 0x01) spow = "off";
+ if (val & 0x02) scrit = "off";
+ if (val & 0x04) smaj = "off";
+ if (val & 0x08) smin = "off";
+ printf("Alarm LEDs: critical = %s major = %s minor = %s power = %s\n",
+ scrit,smaj,smin,spow);
+ if (fRelayBits == 1) { /*CG2100 platforms have Relay bits reversed*/
+ if (val & 0x10) rmin = "off ";
+ if (val & 0x20) rmaj = "off ";
+ } else {
+ if (val & 0x10) rmaj = "off ";
+ if (val & 0x20) rmin = "off ";
+ }
+ printf("Alarm Relays: major = %s minor = %s\n", rmaj, rmin);
+}
+
+/*
+ * get_led_status_intel
+ * uses Intel OEM command to get the status of the ID LED.
+ * if success, rv=0, pstate: 0=off, 1=on, 2=blinking
+ */
+int get_led_status_intel(uchar *pstate)
+{
+ uchar rdata[64];
+ int rv, rlen;
+ uchar cc, b_leds, bstate;
+
+ /* This command is only supported on Intel S5000 motherboards */
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x40,0x32, g_sa,g_bus,g_lun,
+ NULL, 0, rdata, &rlen, &cc, fdebug);
+ if (fdebug) printf("get_led_status_intel: rv = %d, cc=%02x\n", rv,cc);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ b_leds = rdata[0];
+ bstate = 0; /*off*/
+ if (b_leds & 0x80) { bstate = 1; /*on*/ }
+ else if (b_leds & 0x40) { bstate = 2; /*blink*/ }
+ if (pstate != NULL) *pstate = bstate;
+ }
+ return(rv);
+}
+
+
+int detect_capab_intel(int vend_id,int prod_id, int *cap, int *ndisk,char fdbg)
+{
+ int busid = PRIVATE_BUS_ID;
+ int f = 0;
+ char fbmctam = 0;
+ char fHasAlarms = 0;
+ char fHasEnc = 0;
+ char fpicmg = 0;
+ char fChesnee = 0;
+ int styp, idx, rv;
+ char desc[20];
+
+ fdebug = fdbg;
+ if (vend_id == VENDOR_NSC) { /*NSC mBMC, Chesnee*/
+ busid = PERIPHERAL_BUS_ID;
+ fHasAlarms = 1;
+ fChesnee = 1;
+ } else if (vend_id == VENDOR_INTEL) { /*Intel BMC*/
+ switch (prod_id) {
+ case 0x0022:
+ busid = PRIVATE_BUS_ID5; /* Intel TIGI2U */
+ fbmctam = 1; /* Intel TIGI2U may have bmc tam */
+ fHasAlarms = 1;
+ fHasEnc = 2;
+ break;
+ case 0x000C: /* TSRLT2 or TSRMT2 */
+ busid = PRIVATE_BUS_ID;
+ fbmctam = 0; /* no BMC TAM */
+ fHasAlarms = 1;
+ fHasEnc = 0;
+ break;
+ case 0x001B:
+ busid = PRIVATE_BUS_ID;
+ fbmctam = 1; /* Intel TIGPR2U may have bmc tam */
+ fHasAlarms = 1;
+ break;
+ case 0x0808:
+ case 0x0841:
+ fpicmg = 1; /* Intel ATCA platform, supports PICMG */
+ fHasAlarms = 1;
+ break;
+ case 0x4311:
+ busid = PERIPHERAL_BUS_ID; /* SJR2 (NSI2U) mBMC */
+ break;
+ case 0x0026: /*BridgePort*/
+ case 0x0028: /*S5000PAL*/
+ case 0x0029: /*S5000PSL*/
+ case 0x0811: /*S5000PHB*/
+ busid = PRIVATE_BUS_ID7; /* Intel Harbision (TIGW1U/NSW1U) */
+ /* Check for SAS Drv Pres sensor on HSC, if TIGW1U */
+ rv = get_sensdesc(0xC0,0x09,desc,&styp, &idx);
+ if (fdebug) printf("get_sensdesc rv = %d\n",rv);
+ if (rv == ERR_NOT_FOUND) { /* NSW1U does not have alarm panel*/
+ fHasAlarms = 0;
+ fHasEnc = 0;
+ } else { /* has HSC, like TIGW1U */
+ fbmctam = 1; /* TIGW1U may have bmc tam */
+ fHasAlarms = 1;
+ if (prod_id == 0x0811) fHasEnc = 3;
+ else fHasEnc = 6;
+ }
+ break;
+ case 0x003E: /*S5520UR*/
+ busid = PRIVATE_BUS_ID;
+ fbmctam = 1; /* CG2100 has bmc tam */
+ fHasAlarms = 1;
+ fHasEnc = 8; /* CG2100 has 8 disks */
+ fRelayBits = 1;
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ break;
+ case 0x005D: /* Copper Pass, CG2200*/
+ busid = PRIVATE_BUS_ID;
+ fbmctam = 1; /* CG2200 has bmc tam */
+ fHasAlarms = 1;
+ fRelayBits = 1;
+ fHasEnc = 6; /* 6 disks */
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ break;
+ case 0x0051: /* Eagle Pass */
+ busid = PRIVATE_BUS_ID;
+ fbmctam = 1; /* CG1200 has bmc tam */
+ fHasAlarms = 1;
+ fRelayBits = 1;
+ fHasEnc = 4; /* 4 disks */
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ break;
+ case 0x0048: /* "(S1200BT)" *BearTooth Pass*/
+ case 0x004A: /* "(S2600CP)" *Canoe Pass*/
+ case 0x0055: /* Iron Pass */
+ case 0x005C: /* Lizard Head Pass */
+ fHasEnc = 8;
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ break;
+ default:
+ busid = PRIVATE_BUS_ID;
+ fHasEnc = 8;
+ break;
+ }
+ }
+ if (fHasAlarms) f |= HAS_ALARMS_MASK;
+ if (fbmctam) f |= HAS_BMCTAM_MASK;
+ if (fHasEnc > 0) {
+ f |= HAS_ENCL_MASK;
+ if (ndisk != NULL) *ndisk = fHasEnc;
+ }
+ if (fpicmg) f |= HAS_PICMG_MASK;
+ if (fChesnee) f |= HAS_NSC_MASK;
+ if (is_romley(vend_id,prod_id)) {
+ if (prod_id == 0x005D) fHasEnc = 6; /*CG2200*/
+ fHasEnc = 8;
+ set_max_kcs_loops(URNLOOPS); /*longer for cmds (default 300)*/
+ f |= HAS_ROMLEY_MASK;
+ }
+ *cap = f;
+ return(busid);
+}
+
+int check_bmctam_intel(void)
+{
+ int ret, rlen;
+ uchar rdata[16];
+ uchar cc;
+
+ /* Check if BMC TAM is enabled */
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw(0x00, 0x36, g_sa,g_bus,g_lun,
+ NULL, 0, rdata, &rlen, &cc, fdebug);
+ if ((ret == 0) && (cc == 0)) {
+ printf("Warning: BMC TAM is active and managing the LEDs.\n"
+ "Use tamutil (from ipmimisc rpm) to set alarms instead.\n");
+ return(LAN_ERR_ABORT);
+ } else return(0);
+#ifdef OLD
+ ret = system(tam1cmd);
+ if (fdebug) printf("%s ret = %d\n",tam1cmd,ret);
+ if (ret == RET_NOT_FOUND) { /*command not found, no such file*/
+ /* Could also do "ipmiutil sensor |grep BMC_TAM" (tam3cmd),
+ * but this would take a while to complete. */
+ printf("Warning: BMC TAM may be active and managing the LEDs.\n"
+ "If so, use tamutil to set the alarm LEDs instead.\n");
+ } else if (ret == 0) {
+ /*the command was found, check if BMC TAM enabled*/
+ ret = system(tam2cmd);
+ if (fdebug) printf("%s ret = %d\n",tam2cmd,ret);
+ if (ret == 0) {
+ /*If so, print warning, use Intel tamutil instead.*/
+ printf("Warning: BMC TAM is active and managing the LEDs.\n"
+ "Use tamutil or the Intel TAM API to set alarms instead.\n"
+ "Aborting.\n");
+ return(LAN_ERR_ABORT);
+ }
+ }
+ /* else tamutil was there but did not show BMC TAM active, so
+ * assume BMC TAM is not active and do nothing. */
+ return(ret);
+#endif
+}
+
+int soft_reset_intel(uchar func)
+{
+ int ret, rlen;
+ uchar idata[16];
+ uchar rdata[16];
+ uchar cc;
+
+ /* Do an Intel S5000 soft reset, via an OS bridge agent (ipmiutil_asy) */
+ rlen = sizeof(rdata);
+ idata[0] = func; /* 0=read, 1=shutdown, 2=reset */
+ ret = ipmi_cmdraw(0x70, 0x30, g_sa,g_bus,g_lun,
+ idata, 1, rdata, &rlen, &cc, fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc;
+ return(ret);
+}
+
+int lan_failover_intel(uchar func, uchar *mode)
+{
+ int ret, rlen;
+ uchar idata[16];
+ uchar rdata[16];
+ uchar cc;
+
+ /* Do an Intel S2600 LAN Failover command, where func is:
+ * 0x00=disable,
+ * 0x01=enable with leash monitor,
+ * 0x02=enable with ARP monitor if blade,
+ * 0xFF=no set, just get current mode
+ */
+ rlen = sizeof(rdata);
+ idata[0] = func; /* 0=read, 1=shutdown, 2=reset */
+ ret = ipmi_cmdraw(0x40, 0x3E, g_sa,g_bus,g_lun,
+ idata, 1, rdata, &rlen, &cc, fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc;
+ if (ret == 0 && mode != NULL) *mode = rdata[0];
+ return(ret);
+}
+
+int get_power_restore_delay_intel(int *delay)
+{
+ int ret, rlen;
+ uchar idata[16];
+ uchar rdata[16];
+ uchar cc;
+
+ rlen = sizeof(rdata);
+ ret = ipmi_cmdraw(0x55, 0x30, g_sa,g_bus,g_lun,
+ idata, 0, rdata, &rlen, &cc, fdebug);
+ if ((ret == 0) && (cc != 0)) ret = cc;
+ if (ret == 0 && delay != NULL)
+ *delay = ( rdata[1] + ((rdata[0] & 0x07) << 8) );
+ return(ret);
+}
+
+/* end-else NO_CMD not defined */
+#endif
+
+#define NTAMSEV 8
+static char *tam_sev[] = {
+/*0*/ "OFF",
+/*1*/ "MNR",
+/*2*/ "MNR+P",
+/*3*/ "MJR",
+/*4*/ "MJR+P",
+/*5*/ "CRT",
+/*6*/ "CRT+P",
+/*7*/ "UNK"
+};
+
+int decode_sensor_intel_nm(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype;
+ char mystr[60];
+ uchar nm_sa, chan, lun;
+
+ if (sdr == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ switch(sdr[3]) { /*SDR type*/
+ case 0xC0: /*OEM sensor*/
+ if (sdr[8] == 0x0D) { /* OEM NM Reference SDR, no reading */
+ nm_sa = sdr[10];
+ chan = (sdr[11] & 0xf0) >> 4;
+ lun = (sdr[11] & 0x0f);
+ /* show NM location and sensor numbers for NM sensors */
+ sprintf(mystr,"NM(%x,%x,%x) health=%x excep=%x capab=%x thresh=%x",
+ chan,nm_sa,lun, sdr[12],sdr[13],sdr[14],sdr[15]);
+ strncpy(pstring, mystr, slen);
+ if ((int)strlen(mystr) > slen) pstring[slen-1] = 0; /*string*/
+ rv = 0;
+ }
+ break;
+ case 0x02: /*compact sensor*/
+ if (reading == NULL) return(rv);
+ stype = sdr[12]; /*sensor type*/
+ if (stype == 0xDC) { /* NM Capabilities sensor, usu snum 0x1a (26.)*/
+ mystr[0] = 0;
+ if (reading[2] == 0x00) strcat(mystr,"None");
+ else {
+ if (reading[2] & 0x01) strcat(mystr,"Policy ");
+ if (reading[2] & 0x02) strcat(mystr,"Monitor ");
+ if (reading[2] & 0x04) strcat(mystr,"Power ");
+ }
+ strncpy(pstring, mystr, slen);
+ if ((int)strlen(mystr) > slen) pstring[slen-1] = 0; /*string*/
+ rv = 0;
+ }
+ break;
+ default:
+ break;
+ }
+ return(rv);
+}
+
+static void show_oem_hex(uchar *sdr, int slen)
+{
+ int i;
+ for (i = 8; i < slen; i++)
+ printf("%02x ",sdr[i]);
+ printf("\n");
+}
+
+void show_oemsdr_nm(uchar *sdr)
+{
+ int rv, len;
+ char mystr[60];
+
+ /* vendor id has already been shown */
+ len = sdr[4] + 5;
+ rv = decode_sensor_intel_nm(sdr,NULL,mystr,sizeof(mystr));
+ if (rv == 0) printf("%s\n",mystr);
+ else show_oem_hex(sdr, len);
+ return;
+}
+
+/*
+ * show_oemsdr_intel
+ */
+void show_oemsdr_intel(uchar *sdr)
+{
+ uchar idx, len, c, i, n, j, k, t;
+ int vend;
+
+ len = sdr[4] + 5;
+ /*double-check that this is an Intel OEM SDR*/
+ vend = sdr[5] | (sdr[6] << 8) | (sdr[7] << 16);
+ if (vend != VENDOR_INTEL) {
+ if (fdebug) printf("show_oemsdr_intel: vendor %x != %x (Intel)\n",
+ vend,VENDOR_INTEL);
+ return;
+ }
+ printf("Intel: ");
+ switch(sdr[8]) { /*OEM subtype*/
+ case 0x53: /* SDR version subtype (has ASCII) */
+ for (i = 8; i < len; i++) {
+ c = sdr[i];
+ if (c < 0x20 || c > 0x7f) printf("[%02x]",c);
+ else printf("%c",c);
+ }
+ printf("\n");
+ break;
+ case 0x60: /* BMC TAM subtype */
+ idx = (sdr[10] & 0xf0) >> 4;
+ n = (sdr[10] & 0x0f) + 1; /*number of TAM records*/
+ printf("BMC_TAM%d ",idx);
+ for (i = 8; i < len; i++)
+ printf("%02x ",sdr[i]);
+ if (idx == 0) {
+ printf(" nrec=%d cfg=%02x",n,sdr[11]);
+ }
+ printf("\n");
+ if (fdebug || sens_verbose) {
+ /* show decoded BMC_TAM rules */
+ if (idx > 0) {
+ uchar map, off, sev, sa;
+ const char *tstr;
+ sa = sdr[12];
+ for (i = 13; i < len; ) {
+ k = (sdr[i] & 0xf0) >> 4;
+ t = sdr[i+1];
+ tstr = get_sensor_type_desc(t);
+ printf("\tBMC_TAM%d sa=%02x %s (",idx,sa,tstr);
+ for (j = 0; j < k; j++) {
+ map = sdr[i+3+j];
+ off = (map & 0xf0) >> 4;
+ sev = map & 0x0f;
+ if (sev >= NTAMSEV) sev = NTAMSEV - 1;
+ printf("%d=%s ",off,tam_sev[sev]);
+ }
+ printf(")\n");
+ i += 3 + k;
+ }
+ }
+ }
+ break;
+ case 0x0C: /* Fan Speed Control */
+ printf("FanCtl ");
+ show_oem_hex(sdr, len);
+ break;
+ case 0x0D: /* ME NM Reference SDR */
+ show_oemsdr_nm(sdr);
+ break;
+ case 0x02: /*S5500 Power Unit Redundancy subtype*/
+ case 0x05: /*S5500 Fan Redundancy subtype*/
+ case 0x06: /*S5000 System Information/Capab */
+ case 0x09: /*S5500 Voltage sensor scaling*/
+ case 0x0A: /*S5500 Fan sensor scaling*/
+ case 0x0B: /*S5500 Thermal Profile data*/
+ default: /* other subtypes 07,0e,15 etc. */
+ show_oem_hex(sdr, len);
+ break;
+ } /*end switch*/
+} /*end show_oemsdr_intel*/
+
+#ifdef NO_EVENTS
+/* if not linking with ievents.c, need to skip decode_sel_intel because it
+ * would have unresolved externals for fmt_time, get_sev_str, get_sensor_tag */
+#else
+/*
+ * decode_sel_intel
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_intel(uchar *evt, char *outbuf, int outsz, char fdesc,
+ char fdebug)
+{
+ int rv = -1;
+ ushort id;
+ uchar rectype;
+ ulong timestamp;
+ char mybuf[64];
+ char oembuf[64];
+ char *type_str = NULL;
+ char *pstr = NULL;
+ int sevid;
+ ushort genid;
+ uchar snum;
+ char *p1;
+ int d, f;
+
+ sevid = SEV_INFO;
+ id = evt[0] + (evt[1] << 8);
+ rectype = evt[2];
+ snum = evt[11];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ if (rectype == 0x00) {
+ if (snum == 0x0A && evt[12] == 0x03) rectype = 0x02; /*internal wdog*/
+ }
+ if (rectype == 0x02) {
+ type_str = "";
+ sprintf(mybuf,"%02x [%02x %02x %02x]", evt[12],evt[13],evt[14],evt[15]);
+ pstr = ""; /*default*/
+ switch(evt[10]) { /*sensor type*/
+ case 0x00: /* type undefined */
+ // type_str = get_sensor_type_desc(0x28);
+ type_str = "Management Subsystem Health";
+ if (snum == 0x0A && evt[12] == 0x03) { /*internal wd event*/
+ pstr = "BMC wd restart";
+ sevid = SEV_CRIT;
+ rv = 0;
+ }
+ break;
+ case 0x13: /* Critical Interrupt */
+ type_str = "Critical Interrupt";
+ if (evt[12] == 0x70) { /*event trigger/type = OEM AER events */
+ /* AER doc uses 'Fatal' here, but they are not really fatal.*/
+ pstr = &oembuf[0];
+ switch(evt[13]) { /*data1/offset*/
+ case 0xA0: p1 = "PCIe Data Link Protocol Error"; break;
+ case 0xA1: p1 = "PCIe Surprise Link Down"; break;
+ case 0xA2: p1 = "PCIe Unexpected Completion"; break;
+ case 0xA3: p1 = "PCIe Unsupported Request"; break;
+ case 0xA4: p1 = "PCIe Poisoned TLP"; break;
+ case 0xA5: p1 = "PCIe Flow Control Protocol"; break;
+ case 0xA6: p1 = "PCIe Completion Timeout"; break;
+ case 0xA7: p1 = "PCIe Completer Abort"; break;
+ case 0xA8: p1 = "PCIe Recv Buffer Overflow"; break;
+ case 0xA9: p1 = "PCIe ACS Violation"; break;
+ case 0xAA: p1 = "PCIe Malformed TLP"; break;
+ case 0xAB: p1 = "PCIe Recvd Fatal Message"; break;
+ case 0xAC: p1 = "PCIe Unexpected Completion Error"; break;
+ case 0xAD: p1 = "PCIe Recvd Warning Message"; break;
+ default: p1 = "PCIe Other AER"; break;
+ }
+ rv = 0;
+ sevid = SEV_MAJ;
+ /* also include the bus dev/func bytes (as shown by lspci) */
+ d = (evt[15] & 0xF8) >> 3;
+ f = (evt[15] & 0x07);
+ snprintf(oembuf,sizeof(oembuf),"%s on (%02x:%02x.%d)",
+ p1,evt[14],d,f);
+ }
+ if (evt[12] == 0x71) { /*event trigger/type = OEM AER warnings */
+ pstr = &oembuf[0];
+ switch(evt[13]) { /*data1/offset*/
+ case 0xA0: p1 = "PCIe Warn Receiver Error"; break;
+ case 0xA1: p1 = "PCIe Warn Bad DLLP"; break;
+ case 0xA2: p1 = "PCIe Warn Bad TLLP"; break;
+ case 0xA3: p1 = "PCIe Warn Replay Num Rollover"; break;
+ case 0xA4: p1 = "PCIe Warn Replay Timeout"; break;
+ case 0xA5: p1 = "PCIe Warn Advisory Non-Fatal"; break;
+ case 0xA6: p1 = "PCIe Warn Link BW Changed"; break;
+ default: p1 = "PCIe Warn Other AER"; break;
+ }
+ rv = 0;
+ sevid = SEV_MIN;
+ /* also include the bus dev/func bytes (as shown by lspci) */
+ d = (evt[15] & 0xF8) >> 3;
+ f = (evt[15] & 0x07);
+ snprintf(oembuf,sizeof(oembuf),"%s on (%02x:%02x.%d)",
+ p1,evt[14],d,f);
+ }
+ break;
+ case 0x2B: /* Version Change */
+ type_str = "Version Change";
+ if (evt[12] == 0x70) { /*event trigger/type */
+ switch(evt[13]) { /*data1/offset*/
+ case 0x00: pstr = "Update started"; break;
+ case 0x01: pstr = "Update completed"; break;
+ case 0x02: pstr = "Update failed"; sevid = SEV_MIN; break;
+ default: pstr = "-"; break;
+ }
+ rv = 0;
+ }
+ break;
+ default: break;
+ }
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,mybuf,outbuf,outsz);
+ }
+ }
+ return rv;
+} /*end decode_sel_intel*/
+#endif
+
+const struct valstr intel_mem_s2600[] = {
+ { 0, "DIMM_A1" },
+ { 1, "DIMM_A2" },
+ { 2, "DIMM_A3" },
+ { 3, "DIMM_B1" },
+ { 4, "DIMM_B2" },
+ { 5, "DIMM_B3" },
+ { 6, "DIMM_C1" },
+ { 7, "DIMM_C2" },
+ { 8, "DIMM_C3" },
+ { 9, "DIMM_D1" },
+ { 10, "DIMM_D2" },
+ { 11, "DIMM_D3" },
+ { 12, "DIMM_E1" },
+ { 13, "DIMM_E2" },
+ { 14, "DIMM_E3" },
+ { 15, "DIMM_F1" },
+ { 16, "DIMM_F2" },
+ { 17, "DIMM_F3" },
+ { 18, "DIMM_G1" },
+ { 19, "DIMM_G2" },
+ { 20, "DIMM_G3" },
+ { 21, "DIMM_H1" },
+ { 22, "DIMM_H2" },
+ { 23, "DIMM_H3" },
+ { 24, "DIMM_I1" },
+ { 25, "DIMM_I2" },
+ { 26, "DIMM_I3" },
+ { 27, "DIMM_J1" },
+ { 28, "DIMM_J2" },
+ { 29, "DIMM_J3" },
+ { 30, "DIMM_K1" },
+ { 31, "DIMM_K2" },
+ { 32, "DIMM_K3" },
+ { 33 , NULL } /*end of list*/
+};
+
+const struct valstr intel_mem_s5520ur[] = {
+ { 0, "DIMM_A1" },
+ { 1, "DIMM_A2" },
+ { 2, "DIMM_B1" },
+ { 3, "DIMM_B2" },
+ { 4, "DIMM_C1" },
+ { 5, "DIMM_C2" },
+ { 6, "DIMM_D1" },
+ { 7, "DIMM_D2" },
+ { 8, "DIMM_E1" },
+ { 9, "DIMM_E2" },
+ { 10, "DIMM_F1" },
+ { 11, "DIMM_F2" },
+ { 12 , NULL } /*end of list*/
+};
+const struct valstr intel_mem_s5000phb[] = {
+ { 0, "DIMM_A1" },
+ { 1, "DIMM_A2" },
+ { 2, "DIMM_A3" },
+ { 3, "DIMM_B1" },
+ { 4, "DIMM_B2" },
+ { 5, "DIMM_B3" },
+ { 6 , NULL } /*end of list*/
+};
+const struct valstr intel_mem_s5000pal[] = {
+ { 0, "DIMM_A1" },
+ { 1, "DIMM_A2" },
+ { 2, "DIMM_B1" },
+ { 3, "DIMM_B2" },
+ { 4, "DIMM_C1" },
+ { 5, "DIMM_C2" },
+ { 6, "DIMM_D1" },
+ { 7, "DIMM_D2" },
+ { 8 , NULL } /*end of list*/
+};
+const struct valstr intel_mem_tigi2u[] = {
+ { 0, "DIMM_1B" },
+ { 1, "DIMM_1A" },
+ { 2, "DIMM_2B" },
+ { 3, "DIMM_2A" },
+ { 4, "DIMM_3B" },
+ { 5, "DIMM_3A" },
+ { 6 , NULL } /*end of list*/
+};
+
+#define LIDS 8
+ushort lan2i_ids[LIDS] = { /*Intel prod_ids that use lan2i, rest use lan2*/
+ 0x0000, /*uninitialized */
+ 0x0022, /*TIGI2U */
+ 0x0026, /*Bridgeport */
+ 0x0028, /*S5000PAL, Alcolu*/
+ 0x0029, /*S5000PSL, StarLake*/
+ 0x002B, /*S5000VSA */
+ 0x002D, /*ClearBay*/
+ 0x0811 /*S5000PHB, TIGW1U*/ };
+
+#define RIDS 21 /* Intel Romley product ids: */
+struct { ushort id; char *desc; } romleys[RIDS] = {
+ { 0x0048, "S1200BT" }, /* S1200BT, BearTooth Pass */
+ { 0x0049, "S2600GL" }, /* S2600GL, S2600GZ */
+ { 0x004A, "S2600CP" }, /* S2600CP, Canoe Pass */
+ { 0x004D, "S2600JF" }, /* S2600JF, Jefferson Pass, Appro 512X */
+ { 0x004E, "S2600WP" }, /* S2600WP */
+ { 0x004F, "S2400SC" }, /* S2400SC */
+ { 0x0050, "S2400LP" }, /* S2400LP */
+ { 0x0051, "S2400EP" }, /* S2400EP, Eagle Pass */
+ { 0x0052, "S1400FP" }, /* S1400FP */
+ { 0x0053, "S1400SP" }, /* S1400SP */
+ { 0x0054, "S2600KI" }, /* S2600KI */
+ { 0x0055, "S2600IP" }, /* S2600IP, Iron Pass */
+ { 0x0056, "W2600CR" }, /* W2600CR */
+ { 0x0057, "S2400GP" }, /* S2400GP */
+ { 0x0058, "Badger Pass" }, /* Badger Pass */
+ { 0x0059, "S2400BB" }, /* S2400BB */
+ { 0x005A, "Taylor Pass" }, /* Taylor Pass */
+ { 0x005B, "S1600JP" }, /* S1600JP */
+ { 0x005C, "S4600LH" }, /* S4600LH, Lizard Head Pass */
+ { 0x005D, "CG2200" }, /* S2600CO, Copper Pass, Kontron CG2200 */
+ { 0x005E, "Big Ridge"} /* Big Ridge */
+};
+
+#define TIDS 5
+ushort thurley_ids[TIDS] = { /* Intel Thurley product ids: */
+ 0x003A, /* Snow Hill */
+ 0x003B, /* Shoffner */
+ 0x003D, /* Melstone */
+ 0x003E, /* S5520UR, S5500WB, Kontron CG2100, Penguin Computing Relion 700 */
+ 0x0040 }; /* Stoutland, Quanta QSSC-S4R/Appro GB812X-CN (Nehalem-EX) */
+
+int is_romley(int vend, int prod)
+{
+ int ret = 0;
+ int i;
+ if (vend != VENDOR_INTEL) return(ret);
+ for (i = 0; i < RIDS; i++)
+ if ((ushort)prod == romleys[i].id) { ret = 1; break; }
+ return(ret);
+}
+
+int intel_romley_desc(int vend, int prod, char **pdesc)
+{
+ int ret = -1;
+ int i;
+ if (vend != VENDOR_INTEL) return(ret);
+ if (pdesc == NULL) return(ret);
+ for (i = 0; i < RIDS; i++) {
+ if ((ushort)prod == romleys[i].id) {
+ *pdesc = romleys[i].desc;
+ ret = 0;
+ break;
+ }
+ }
+ return(ret);
+}
+
+int is_thurley(int vend, int prod)
+{
+ int ret = 0;
+ int i;
+ if (vend != VENDOR_INTEL) return(ret);
+ for (i = 0; i < TIDS; i++)
+ if ((ushort)prod == thurley_ids[i]) { ret = 1; break; }
+ return(ret);
+}
+
+int is_lan2intel(int vend, int prod)
+{
+ int ret = 0;
+ int i;
+ if (vend != VENDOR_INTEL) return(ret);
+ if (is_thurley(vend,prod) || is_romley(vend,prod))
+ ret = 0; /*iBMC does not use lan2i*/
+ else {
+ for (i = 0; i < LIDS; i++)
+ if ((ushort)prod == lan2i_ids[i]) { ret = 1; break; }
+ }
+ return(ret);
+}
+
+int decode_mem_intel(int prod, uchar b2, uchar b3, char *desc, int *psz)
+{
+ const char *pstr = NULL;
+ int array, dimm;
+ int node, chan, sock, n;
+ int rv = -1;
+ uchar bdata;
+ int vend;
+ int iBMC = 0;
+
+ if ((desc == NULL) || (psz == NULL)) return -1;
+
+ vend = VENDOR_INTEL;
+ if (is_thurley(vend,prod)) iBMC = 1;
+ if (is_romley(vend,prod)) iBMC = 2;
+ if (iBMC != 0) {
+ /* custom DIMM decoding for iBMC on Intel S5500 and S2600 */
+ // rank = (b2 & 0x03); /* psel->event_data2 & 0x03; */
+ node = (b3 & 0xE0) >> 5; /*socket*/
+ chan = (b3 & 0x18) >> 3;
+ sock = (b3 & 0x07);
+ array = 0; /* is 0 for Thurley & Romley currently, else see b2. */
+ if (iBMC == 1) dimm = (node * 6) + (chan * 2) + sock;
+ else dimm = (node * 12) + (chan * 3) + sock;
+ if (fdebug) printf("iBMC DIMM (%d,%d,%d) = idx %d\n",
+ node,chan,sock,dimm);
+ } else { /* use straight DIMM index */
+ /* for mini-BMC, data2 is dimm index, data3 is syndrome */
+ if (prod == 0x4311) bdata = b2; /*mini-BMC*/
+ else if (b3 == 0xff) bdata = b2; /*ff is reserved*/
+ else bdata = b3; /* normal case */
+ /* (data3 & 0xc0) = SMBIOS type 16 mem array */
+ array = (bdata & 0xc0) >> 6;
+ /* (data3 & 0x3f) = SMBIOS type 17 dimm index */
+ dimm = bdata & 0x3f;
+ }
+
+ if (! is_remote()) {
+ fsm_debug = fdebug;
+ rv = get_MemDesc(array,dimm,desc,psz);
+ /* if (rv != 0) desc has "DIMM[%d}" */
+ }
+ if (rv != 0) {
+ /* either remote, or get_MemDesc failed, use common product defaults*/
+ switch(prod) {
+ case 0x0811: /*S5000PHB*/
+ pstr = val2str(dimm,intel_mem_s5000phb);
+ break;
+ case 0x0028: /*S5000PAL*/
+ pstr = val2str(dimm,intel_mem_s5000pal);
+ break;
+ case 0x0022: /*TIGI2U*/
+ pstr = val2str(dimm,intel_mem_tigi2u);
+ break;
+ default:
+ if (iBMC == 1) pstr = val2str(dimm,intel_mem_s5520ur);
+ else if (iBMC == 2) pstr = val2str(dimm,intel_mem_s2600);
+ else rv = -2; /*do not guess, use raw index below*/
+ break;
+ }
+ if (pstr != NULL) rv = 0;
+ if (rv == 0) {
+ /* These strings are usually 7 chars, desc is 80 chars */
+ n = strlen_(pstr);
+ strncpy(desc, pstr, n+1);
+ } else {
+ n = sprintf(desc,"DIMM[%d]",dimm);
+ }
+ *psz = n;
+ }
+ return(rv);
+} /*end decode_mem_intel*/
+
+/*
+ * decode_sensor_intel
+ * inputs:
+ * sdr = the SDR buffer
+ * reading = the 3 or 4 bytes of data from GetSensorReading
+ * pstring = points to the output string buffer
+ * slen = size of the output buffer
+ * outputs:
+ * rv = 0 if this sensor was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_intel(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype;
+ char *pstr = NULL;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ if (sdr[3] == 0x02) { /*Compact SDR*/
+ stype = sdr[12];
+ switch(stype) {
+ case 0xC0: /* SMI State, NMI State */
+ case 0xC7: /* FanBoost */
+ case 0xCC: /* Debug Info */
+ case 0xD8: /* BIST */
+ case 0xF0: /* ATCA HotSwap, TODO: refine this */
+ case 0xF3: /* SMI Timeout, etc. */
+ case 0xF6: /* Sensor Failure */
+ case 0xF7: /* FSB Mismatch */
+ if (reading[2] & 0x01) pstr = "Asserted"; /*Asserted, error*/
+ else pstr = "OK"; /*deasserted*/
+ strncpy(pstring, pstr, slen);
+ rv = 0;
+ break;
+ case 0xDC: /* NM Capabilities sensor */
+ rv = decode_sensor_intel_nm(sdr,reading,pstring,slen);
+ break;
+ default:
+ break;
+ }
+ } else if (sdr[3] == 0xC0) { /*OEM SDR*/
+ rv = decode_sensor_intel_nm(sdr,reading,pstring,slen);
+ }
+ return(rv);
+}
+
+const struct valstr intel_s5000_post[] = { /*from S5000 TPS*/
+ { 0x0012, "CMOS date/time not set" },
+ { 0x0048, "Password check failed" },
+ { 0x004C, "Keyboard/interface error" },
+ { 0x0108, "Keyboard locked error" },
+ { 0x0109, "Keyboard stuck key error" },
+ { 0x0113, "The SAS RAID firmware cannot run properly, reflash" },
+ { 0x0140, "PCI PERR detected" },
+ { 0x0141, "PCI resource conflict" },
+ { 0x0146, "Insufficient memory to shadow PCI ROM" },
+ { 0x0192, "L3 cache size mismatch" },
+ { 0x0194, "CPUID, processor family are different" },
+ { 0x0195, "Front side bus mismatch" },
+ { 0x0197, "Processor speeds mismatched" },
+ { 0x5220, "Configuration cleared by jumper" },
+ { 0x5221, "Passwords cleared by jumper" },
+ { 0x5223, "Configuration default loaded" },
+ { 0x8110, "Proc1 internal error (IERR) on last boot" },
+ { 0x8111, "Proc2 internal error (IERR) on last boot" },
+ { 0x8120, "Proc1 thermal trip error on last boot" },
+ { 0x8121, "Proc2 thermal trip error on last boot" },
+ { 0x8130, "Proc1 disabled" },
+ { 0x8131, "Proc2 disabled" },
+ { 0x8160, "Proc1 unable to apply BIOS update" },
+ { 0x8161, "Proc2 unable to apply BIOS update" },
+ { 0x8170, "Proc1 failed Self Test (BIST)" },
+ { 0x8171, "Proc2 failed Self Test (BIST)" },
+ { 0x8180, "Proc1 BIOS does not support current CPU stepping" },
+ { 0x8181, "Proc2 BIOS does not support current CPU stepping" },
+ { 0x8190, "Watchdog timer failed on last boot" },
+ { 0x8198, "OS boot watchdog timer expired on last boot" },
+ { 0x8300, "Baseboard management controller failed self-test" },
+ { 0x8306, "Front panel controller locked" },
+ { 0x8305, "Hot swap controller failed" },
+ { 0x84F2, "Baseboard management controller failed to respond" },
+ { 0x84F3, "Baseboard management controller in update mode" },
+ { 0x84F4, "Sensor data record empty" },
+ { 0x84FF, "System event log full" },
+ { 0x8500, "Memory could not be configured in the selected RAS mode" },
+ { 0x8510, "Memory above 16GB maximum" }, /*S5000V only*/
+ { 0x8520, "DIMM_A1 failed Self Test (BIST)" },
+ { 0x8521, "DIMM_A2 failed Self Test (BIST)" },
+ { 0x8522, "DIMM_A3 failed Self Test (BIST)" },
+ { 0x8523, "DIMM_A4 failed Self Test (BIST)" },
+ { 0x8524, "DIMM_B1 failed Self Test (BIST)" },
+ { 0x8525, "DIMM_B2 failed Self Test (BIST)" },
+ { 0x8526, "DIMM_B3 failed Self Test (BIST)" },
+ { 0x8527, "DIMM_B4 failed Self Test (BIST)" },
+ { 0x8528, "DIMM_C1 failed Self Test (BIST)" },
+ { 0x8529, "DIMM_C2 failed Self Test (BIST)" },
+ { 0x852A, "DIMM_C3 failed Self Test (BIST)" },
+ { 0x852B, "DIMM_C4 failed Self Test (BIST)" },
+ { 0x852C, "DIMM_D1 failed Self Test (BIST)" },
+ { 0x852D, "DIMM_D2 failed Self Test (BIST)" },
+ { 0x852E, "DIMM_D3 failed Self Test (BIST)" },
+ { 0x852F, "DIMM_D4 failed Self Test (BIST)" },
+ { 0x8540, "Memory lost redundancy during last boot" },
+ { 0x8580, "DIMM_A1 Correctable ECC error" },
+ { 0x8581, "DIMM_A2 Correctable ECC error" },
+ { 0x8582, "DIMM_A3 Correctable ECC error" },
+ { 0x8583, "DIMM_A4 Correctable ECC error" },
+ { 0x8584, "DIMM_B1 Correctable ECC error" },
+ { 0x8585, "DIMM_B2 Correctable ECC error" },
+ { 0x8586, "DIMM_B3 Correctable ECC error" },
+ { 0x8587, "DIMM_B4 Correctable ECC error" },
+ { 0x8588, "DIMM_C1 Correctable ECC error" },
+ { 0x8589, "DIMM_C2 Correctable ECC error" },
+ { 0x858A, "DIMM_C3 Correctable ECC error" },
+ { 0x858B, "DIMM_C4 Correctable ECC error" },
+ { 0x858C, "DIMM_D1 Correctable ECC error" },
+ { 0x858D, "DIMM_D2 Correctable ECC error" },
+ { 0x858E, "DIMM_D3 Correctable ECC error" },
+ { 0x858F, "DIMM_D4 Correctable ECC error" },
+ { 0x8600, "Primary and secondary BIOS IDs do not match" },
+ { 0x8601, "BIOS Bank Override jumper set to lower bank" },
+ { 0x8602, "WatchDog timer expired (check secondary BIOS bank)" },
+ { 0x8603, "Secondary BIOS checksum fail" },
+ { 0xffff , NULL } /*end of list*/
+};
+const struct valstr intel_s5500_post[] = { /*from S5520UR TPS*/
+ { 0x0012, "CMOS date/time not set" },
+ { 0x0048, "Password check failed" },
+ { 0x0108, "Keyboard locked error" },
+ { 0x0109, "Keyboard stuck key error" },
+ { 0x0113, "The SAS RAID firmware cannot run properly" },
+ { 0x0140, "PCI PERR detected" },
+ { 0x0141, "PCI resource conflict" },
+ { 0x0146, "PCI out of resources error" },
+ { 0x0192, "Processor cache size mismatch" },
+ { 0x0194, "Processor family mismatch" },
+ { 0x0195, "Processor QPI speed mismatch" },
+ { 0x0196, "Processor Model mismatch" },
+ { 0x0197, "Processor speeds mismatched" },
+ { 0x0198, "Processor family is unsupported" },
+ { 0x019F, "Processor/chipset stepping configuration is unsupported" },
+ { 0x5220, "CMOS/NVRAM Configuration Cleared" },
+ { 0x5221, "Passwords cleared by jumper" },
+ { 0x5224, "Password clear jumper is Set" },
+ { 0x8110, "Proc1 internal error (IERR) on last boot" }, /*not used*/
+ { 0x8111, "Proc2 internal error (IERR) on last boot" }, /*not used*/
+ { 0x8120, "Proc1 thermal trip error on last boot" }, /*not used*/
+ { 0x8121, "Proc2 thermal trip error on last boot" }, /*not used*/
+ { 0x8130, "Proc1 disabled" }, /*not used*/
+ { 0x8131, "Proc2 disabled" }, /*not used*/
+ { 0x8140, "Proc1 Failed FRB-3 Timer" }, /*not used*/
+ { 0x8141, "Proc2 Failed FRB-3 Timer" }, /*not used*/
+ { 0x8160, "Proc1 unable to apply microcode update" },
+ { 0x8161, "Proc2 unable to apply microcode update" },
+ { 0x8170, "Proc1 failed Self Test (BIST)" }, /*not used*/
+ { 0x8171, "Proc2 failed Self Test (BIST)" }, /*not used*/
+ { 0x8180, "Processor microcode update not found" },
+ { 0x8190, "Watchdog timer failed on last boot" },
+ { 0x8198, "OS boot watchdog timer expired on last boot" },
+ { 0x8300, "iBMC failed self-test" },
+ { 0x8305, "Hotswap controller failure" },
+ { 0x84F2, "iBMC failed to respond" },
+ { 0x84F3, "iBMC in update mode" },
+ { 0x84F4, "Sensor data record empty" },
+ { 0x84FF, "System event log full" },
+ { 0x8500, "Memory could not be configured in the selected RAS mode" },
+ { 0x8520, "DIMM_A1 failed Self Test (BIST)" },
+ { 0x8521, "DIMM_A2 failed Self Test (BIST)" },
+ { 0x8522, "DIMM_B1 failed Self Test (BIST)" },
+ { 0x8523, "DIMM_B2 failed Self Test (BIST)" },
+ { 0x8524, "DIMM_C1 failed Self Test (BIST)" },
+ { 0x8525, "DIMM_C2 failed Self Test (BIST)" },
+ { 0x8526, "DIMM_D1 failed Self Test (BIST)" },
+ { 0x8527, "DIMM_D2 failed Self Test (BIST)" },
+ { 0x8528, "DIMM_E1 failed Self Test (BIST)" },
+ { 0x8529, "DIMM_E2 failed Self Test (BIST)" },
+ { 0x852A, "DIMM_F1 failed Self Test (BIST)" },
+ { 0x852B, "DIMM_F2 failed Self Test (BIST)" },
+ { 0x8540, "DIMM_A1 Disabled" },
+ { 0x8541, "DIMM_A2 Disabled" },
+ { 0x8542, "DIMM_B1 Disabled" },
+ { 0x8543, "DIMM_B2 Disabled" },
+ { 0x8544, "DIMM_C1 Disabled" },
+ { 0x8545, "DIMM_C2 Disabled" },
+ { 0x8546, "DIMM_D1 Disabled" },
+ { 0x8547, "DIMM_D2 Disabled" },
+ { 0x8548, "DIMM_E1 Disabled" },
+ { 0x8549, "DIMM_E2 Disabled" },
+ { 0x854A, "DIMM_F1 Disabled" },
+ { 0x854B, "DIMM_F2 Disabled" },
+ { 0x8560, "DIMM_A1 SPD fail error." },
+ { 0x8561, "DIMM_A2 SPD fail error" },
+ { 0x8562, "DIMM_B1 SPD fail error" },
+ { 0x8563, "DIMM_B2 SPD fail error" },
+ { 0x8564, "DIMM_C1 SPD fail error" },
+ { 0x8565, "DIMM_C2 SPD fail error" },
+ { 0x8566, "DIMM_D1 SPD fail error" },
+ { 0x8567, "DIMM_D2 SPD fail error" },
+ { 0x8568, "DIMM_E1 SPD fail error" },
+ { 0x8569, "DIMM_E2 SPD fail error" },
+ { 0x856A, "DIMM_F1 SPD fail error" },
+ { 0x856B, "DIMM_F2 SPD fail error" },
+ { 0x8580, "DIMM_A1 Correctable ECC error" },
+ { 0x8581, "DIMM_A2 Correctable ECC error" },
+ { 0x8582, "DIMM_B1 Correctable ECC error" },
+ { 0x8583, "DIMM_B2 Correctable ECC error" },
+ { 0x8584, "DIMM_C1 Correctable ECC error" },
+ { 0x8585, "DIMM_C2 Correctable ECC error" },
+ { 0x8586, "DIMM_D1 Correctable ECC error" },
+ { 0x8587, "DIMM_D2 Correctable ECC error" },
+ { 0x8588, "DIMM_E1 Correctable ECC error" },
+ { 0x8589, "DIMM_E2 Correctable ECC error" },
+ { 0x858A, "DIMM_F1 Correctable ECC error" },
+ { 0x858B, "DIMM_F2 Correctable ECC error" },
+ { 0x85A0, "DIMM_A1 Uncorrectable ECC error" },
+ { 0x85A1, "DIMM_A2 Uncorrectable ECC error" },
+ { 0x85A2, "DIMM_B1 Uncorrectable ECC error" },
+ { 0x85A3, "DIMM_B2 Uncorrectable ECC error" },
+ { 0x85A4, "DIMM_C1 Uncorrectable ECC error" },
+ { 0x85A5, "DIMM_C2 Uncorrectable ECC error" },
+ { 0x85A6, "DIMM_D1 Uncorrectable ECC error" },
+ { 0x85A7, "DIMM_D2 Uncorrectable ECC error" },
+ { 0x85A8, "DIMM_E1 Uncorrectable ECC error" },
+ { 0x85A9, "DIMM_E2 Uncorrectable ECC error" },
+ { 0x85AA, "DIMM_F1 Uncorrectable ECC error" },
+ { 0x85AB, "DIMM_F2 Uncorrectable ECC error" },
+ { 0x8601, "BIOS Bank Override jumper set to lower bank" }, /*not used*/
+ { 0x8602, "WatchDog timer expired (check secondary BIOS bank)" }, /*not used*/
+ { 0x8603, "Secondary BIOS checksum fail" }, /*not used*/
+ { 0x8604, "Chipset Reclaim of non critical variables complete" },
+ { 0x9000, "Unspecified processor component error" },
+ { 0x9223, "Keyboard was not detected" }, /*not used*/
+ { 0x9226, "Keyboard controller error" },
+ { 0x9243, "Mouse was not detected" },
+ { 0x9246, "Mouse controller error" },
+ { 0x9266, "Local Console controller error" },
+ { 0x9268, "Local Console output error" },
+ { 0x9269, "Local Console resource conflict error" },
+ { 0x9286, "Remote Console controller error" },
+ { 0x9287, "Remote Console input error" },
+ { 0x9288, "Remote Console output error" },
+ { 0x92A3, "Serial port was not detected" },
+ { 0x92A9, "Serial port resource conflict error" },
+ { 0x92C6, "Serial Port controller error" },
+ { 0x92C7, "Serial Port input error" },
+ { 0x92C8, "Serial Port output error" },
+ { 0x94C6, "LPC controller error" },
+ { 0x94C9, "LPC resource conflict error" },
+ { 0x9506, "ATA/ATPI controller error" },
+ { 0x95A6, "PCI controller error" },
+ { 0x95A7, "PCI read error" },
+ { 0x95A8, "PCI write error" },
+ { 0x9609, "Unspecified software start error" },
+ { 0x9641, "PEI Core load error" },
+ { 0x9667, "PEI module Illegal software state error" },
+ { 0x9687, "DXE core Illegal software state error" },
+ { 0x96A7, "DXE driver Illegal software state error" },
+ { 0x96AB, "DXE driver Invalid configuration" },
+ { 0x96E7, "SMM driver Illegal software state error" },
+ { 0xA000, "TPM device not detected" },
+ { 0xA001, "TPM device missing" },
+ { 0xA002, "TPM device failure" },
+ { 0xA003, "TPM device failed self-test" },
+ { 0xA022, "Processor mismatch error" },
+ { 0xA027, "Processor low voltage error" },
+ { 0xA028, "Processor high voltage error" },
+ { 0xA421, "PCI SERR detected" },
+ { 0xA500, "ATA/ATPI ATA bus SMART not supported" },
+ { 0xA501, "ATA/ATPI ATA SMART is disabled" },
+ { 0xA5A0, "PCI Express PERR" },
+ { 0xA5A1, "PCI Express SERR" },
+ { 0xA5A4, "PCI Express IBIST error" },
+ { 0xA6A0, "DXE driver Not enough memory to shadow legacy OpROM" },
+ { 0xB6A3, "DXE driver unrecognized" },
+ { 0xffff , NULL } /*end of list*/
+};
+const struct valstr intel_s2600_post[] = { /*from S2600CP TPS*/
+ { 0x0012, "CMOS date/time not set" },
+ { 0x0048, "Password check failed" },
+ { 0x0108, "Keyboard locked error" },
+ { 0x0109, "Keyboard stuck key error" },
+ { 0x0113, "The SAS RAID firmware cannot run properly" },
+ { 0x0140, "PCI PERR detected" },
+ { 0x0141, "PCI resource conflict" },
+ { 0x0146, "PCI out of resources error" },
+ { 0x0191, "Processor core/thread count mismatch" },
+ { 0x0192, "Processor cache size mismatch" },
+ { 0x0194, "Processor family mismatch" },
+ { 0x0195, "Processor QPI speed mismatch" },
+ { 0x0196, "Processor Model mismatch" },
+ { 0x0197, "Processor speeds mismatched" },
+ { 0x0198, "Processor family is unsupported" },
+ { 0x019F, "Processor/chipset stepping configuration is unsupported" },
+ { 0x5220, "CMOS/NVRAM Configuration Cleared" },
+ { 0x5221, "Passwords cleared by jumper" },
+ { 0x5224, "Password clear jumper is Set" },
+ { 0x8110, "Proc1 internal error (IERR) on last boot" }, /*not used*/
+ { 0x8111, "Proc2 internal error (IERR) on last boot" }, /*not used*/
+ { 0x8120, "Proc1 thermal trip error on last boot" }, /*not used*/
+ { 0x8121, "Proc2 thermal trip error on last boot" }, /*not used*/
+ { 0x8130, "Proc1 disabled" }, /*not used*/
+ { 0x8131, "Proc2 disabled" }, /*not used*/
+ { 0x8140, "Proc1 Failed FRB-3 Timer" }, /*not used*/
+ { 0x8141, "Proc2 Failed FRB-3 Timer" }, /*not used*/
+ { 0x8160, "Proc1 unable to apply microcode update" },
+ { 0x8161, "Proc2 unable to apply microcode update" },
+ { 0x8170, "Proc1 failed Self Test (BIST)" }, /*not used*/
+ { 0x8171, "Proc2 failed Self Test (BIST)" }, /*not used*/
+ { 0x8180, "Processor microcode update not found" },
+ { 0x8181, "Proc2 microcode update not found" },
+ { 0x8190, "Watchdog timer failed on last boot" },
+ { 0x8198, "OS boot watchdog timer expired on last boot" },
+ { 0x8300, "iBMC failed self-test" },
+ { 0x8305, "Hotswap controller failure" },
+ { 0x84F2, "iBMC failed to respond" },
+ { 0x84F3, "iBMC in update mode" },
+ { 0x84F4, "Sensor data record empty" },
+ { 0x84FF, "System event log full" },
+ { 0x8500, "Memory could not be configured in the selected RAS mode" },
+ { 0x8501, "DIMM Population Error" },
+ { 0x8520, "DIMM_A1 failed test/initialization" },
+ { 0x8521, "DIMM_A2 failed test/initialization" },
+ { 0x8522, "DIMM_A3 failed test/initialization" },
+ { 0x8523, "DIMM_B1 failed test/initialization" },
+ { 0x8524, "DIMM_B2 failed test/initialization" },
+ { 0x8525, "DIMM_B3 failed test/initialization" },
+ { 0x8526, "DIMM_C1 failed test/initialization" },
+ { 0x8527, "DIMM_C2 failed test/initialization" },
+ { 0x8528, "DIMM_C3 failed test/initialization" },
+ { 0x8529, "DIMM_D1 failed test/initialization" },
+ { 0x852A, "DIMM_D2 failed test/initialization" },
+ { 0x852B, "DIMM_D3 failed test/initialization" },
+ { 0x852C, "DIMM_E1 failed test/initialization" },
+ { 0x852D, "DIMM_E2 failed test/initialization" },
+ { 0x852E, "DIMM_E3 failed test/initialization" },
+ { 0x852F, "DIMM_F1 failed test/initialization" },
+ { 0x8530, "DIMM_F2 failed test/initialization" },
+ { 0x8531, "DIMM_F3 failed test/initialization" },
+ { 0x8532, "DIMM_G1 failed test/initialization" },
+ { 0x8533, "DIMM_G2 failed test/initialization" },
+ { 0x8534, "DIMM_G3 failed test/initialization" },
+ { 0x8535, "DIMM_H1 failed test/initialization" },
+ { 0x8536, "DIMM_H2 failed test/initialization" },
+ { 0x8537, "DIMM_H3 failed test/initialization" },
+ { 0x8538, "DIMM_I1 failed test/initialization" },
+ { 0x8539, "DIMM_I2 failed test/initialization" },
+ { 0x853A, "DIMM_I3 failed test/initialization" },
+ { 0x853B, "DIMM_J1 failed test/initialization" },
+ { 0x853C, "DIMM_J2 failed test/initialization" },
+ { 0x853D, "DIMM_J3 failed test/initialization" },
+ { 0x853E, "DIMM_K1 failed test/initialization" },
+ { 0x853F, "DIMM_K2 failed test/initialization" },
+ { 0x8540, "DIMM_A1 Disabled" },
+ { 0x8541, "DIMM_A2 Disabled" },
+ { 0x8542, "DIMM_A3 Disabled" },
+ { 0x8543, "DIMM_B1 Disabled" },
+ { 0x8544, "DIMM_B2 Disabled" },
+ { 0x8545, "DIMM_B3 Disabled" },
+ { 0x8546, "DIMM_C1 Disabled" },
+ { 0x8547, "DIMM_C2 Disabled" },
+ { 0x8548, "DIMM_C3 Disabled" },
+ { 0x8549, "DIMM_D1 Disabled" },
+ { 0x854A, "DIMM_D2 Disabled" },
+ { 0x854B, "DIMM_D3 Disabled" },
+ { 0x854C, "DIMM_E1 Disabled" },
+ { 0x854D, "DIMM_E2 Disabled" },
+ { 0x854E, "DIMM_E3 Disabled" },
+ { 0x854F, "DIMM_F1 Disabled" },
+ { 0x8550, "DIMM_F2 Disabled" },
+ { 0x8551, "DIMM_F3 Disabled" },
+ { 0x8552, "DIMM_G1 Disabled" },
+ { 0x8553, "DIMM_G2 Disabled" },
+ { 0x8554, "DIMM_G3 Disabled" },
+ { 0x8555, "DIMM_H1 Disabled" },
+ { 0x8556, "DIMM_H1 Disabled" },
+ { 0x8557, "DIMM_H1 Disabled" },
+ { 0x8558, "DIMM_I1 Disabled" },
+ { 0x8559, "DIMM_I2 Disabled" },
+ { 0x855A, "DIMM_I3 Disabled" },
+ { 0x855B, "DIMM_J1 Disabled" },
+ { 0x855C, "DIMM_J2 Disabled" },
+ { 0x855D, "DIMM_J3 Disabled" },
+ { 0x855E, "DIMM_K1 Disabled" },
+ { 0x855F, "DIMM_K2 Disabled" },
+ { 0x8560, "DIMM_A1 SPD fail error" },
+ { 0x8561, "DIMM_A2 SPD fail error" },
+ { 0x8562, "DIMM_A3 SPD fail error" },
+ { 0x8563, "DIMM_B1 SPD fail error" },
+ { 0x8564, "DIMM_B2 SPD fail error" },
+ { 0x8565, "DIMM_B3 SPD fail error" },
+ { 0x8566, "DIMM_C1 SPD fail error" },
+ { 0x8567, "DIMM_C2 SPD fail error" },
+ { 0x8568, "DIMM_C3 SPD fail error" },
+ { 0x8569, "DIMM_D1 SPD fail error" },
+ { 0x856A, "DIMM_D2 SPD fail error" },
+ { 0x856B, "DIMM_D3 SPD fail error" },
+ { 0x856C, "DIMM_E1 SPD fail error" },
+ { 0x856D, "DIMM_E2 SPD fail error" },
+ { 0x856E, "DIMM_E3 SPD fail error" },
+ { 0x856F, "DIMM_F1 SPD fail error" },
+ { 0x8570, "DIMM_F2 SPD fail error" },
+ { 0x8571, "DIMM_F3 SPD fail error" },
+ { 0x8572, "DIMM_G1 SPD fail error" },
+ { 0x8573, "DIMM_G2 SPD fail error" },
+ { 0x8574, "DIMM_G3 SPD fail error" },
+ { 0x8575, "DIMM_H1 SPD fail error" },
+ { 0x8576, "DIMM_H1 SPD fail error" },
+ { 0x8577, "DIMM_H1 SPD fail error" },
+ { 0x8578, "DIMM_I1 SPD fail error" },
+ { 0x8579, "DIMM_I2 SPD fail error" },
+ { 0x857A, "DIMM_I3 SPD fail error" },
+ { 0x857B, "DIMM_J1 SPD fail error" },
+ { 0x857C, "DIMM_J2 SPD fail error" },
+ { 0x857D, "DIMM_J3 SPD fail error" },
+ { 0x857E, "DIMM_K1 SPD fail error" },
+ { 0x857F, "DIMM_K2 SPD fail error" },
+ /* some missing here for DIMM_K3 thru DIMM_P3 */
+ { 0x8604, "Chipset Reclaim of non critical variables complete" },
+ { 0x8605, "BIOS settings are corrupt" },
+ { 0x92A3, "Serial port was not detected" },
+ { 0x92A9, "Serial port resource conflict error" },
+ { 0xA000, "TPM device not detected" },
+ { 0xA001, "TPM device missing" },
+ { 0xA002, "TPM device failure" },
+ { 0xA003, "TPM device failed self-test" },
+ { 0xA100, "BIOS ACM errord" },
+ { 0xA421, "PCI SERR detected" },
+ { 0xA5A0, "PCI Express PERR" },
+ { 0xA5A1, "PCI Express SERR" },
+ { 0xffff , NULL } /*end of list*/
+};
+
+/* decode Intel POST codes for some platforms*/
+int decode_post_intel(int prod, ushort code, char *outbuf,int szbuf)
+{
+ int rv = -1;
+ const char *poststr = NULL;
+ if (is_thurley(VENDOR_INTEL,prod)) /* S5520UR/T5520UR (CG2100 or NSN2U)*/
+ poststr = val2str(code,intel_s5500_post);
+ else if (is_romley(VENDOR_INTEL,prod)) /* S2600CO, CG2200 */
+ poststr = val2str(code,intel_s2600_post);
+ else switch(prod) {
+ case 0x0028: /*S5000PAL*/
+ case 0x0029: /*S5000PSL*/
+ case 0x0811: /*S5000PHB*/
+ poststr = val2str(code,intel_s5000_post);
+ break;
+ default: break;
+ }
+ if (poststr != NULL) {
+ strncpy(outbuf, poststr, szbuf);
+ rv = 0;
+ }
+ return(rv);
+}
+
+#define ENC_LED_SLEEP 50000
+#define ENC_RCMD_SLEEP 500000
+
+int get_hsbp_version_intel(uchar *maj, uchar *min)
+{
+ uchar idata[8];
+ uchar rdata[4];
+ int rv, rlen, i;
+ uchar cc;
+
+ *maj = 0;
+ *min = 0;
+ /* For Romley/CG2200 get HSBP FW Version */
+ for (i = 0; i < 3; i++) {
+ idata[0] = 0x0A; // 0x0A
+ idata[1] = 0xD0;
+ idata[2] = 0x01; // return one byte of LED data
+ idata[3] = 0x0A; // HSBP Major version
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(MASTER_WRITE_READ, idata, 4, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ os_usleep(0,ENC_LED_SLEEP); /* wait before re-reading values */
+ if (rv == 0) {
+ *maj = rdata[0];
+ break;
+ }
+ /*else retry reading it*/
+ }
+ for (i = 0; i < 3; i++) {
+ idata[0] = 0x0A; // 0x0A
+ idata[1] = 0xD0;
+ idata[2] = 0x01; // return one byte of LED data
+ idata[3] = 0x0B; // HSBP Minor version
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(MASTER_WRITE_READ, idata, 4, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ os_usleep(0,ENC_LED_SLEEP); /* wait before re-reading values */
+ if (rv == 0) {
+ *min = rdata[0];
+ break;
+ }
+ /*else retry reading it*/
+ }
+ return (rv);
+}
+
+static uchar rdisk_led_method = 0; /* 0=initial, 1=rcmd, 2=i2c */
+static uchar rdisk_led_override = 0x00; /*override is off by default*/
+
+static int get_enc_leds_i2c(uchar *val)
+{
+ uchar idata[8];
+ uchar rdata[4];
+ int rv, rv2, rlen, i;
+ uchar cc;
+
+ *val = 0; /*make sure to initialize the reading*/
+ for (i = 0; i < 3; i++) {
+ /* For Romley/Patsburg get disk fault LED status */
+ idata[0] = 0x0A; // 0x0A
+ idata[1] = 0xD0;
+ idata[2] = 0x01; // return one byte of LED data
+ idata[3] = 0x0E; // LED_Status
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(MASTER_WRITE_READ, idata, 4, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ os_usleep(0,ENC_LED_SLEEP); /* wait before re-reading values */
+ if (rv == 0) {
+ *val = rdata[0];
+ break;
+ }
+ /*else retry reading the LED Status*/
+ }
+
+ /* get & save the override status for use in show() */
+ idata[0] = 0x0A; // 0x0A
+ idata[1] = 0xD0;
+ idata[2] = 0x01; // return one byte of LED data
+ idata[3] = 0x0D; // LED_Override
+ rlen = sizeof(rdata);
+ rv2 = ipmi_cmd(MASTER_WRITE_READ, idata, 4, rdata, &rlen, &cc, fdebug);
+ if (rv2 == 0 && cc != 0) rv2 = cc;
+ if (rv2 == 0) rdisk_led_override = rdata[0];
+
+ return (rv);
+}
+
+static int set_enc_override_i2c(uchar val)
+{
+ uchar idata[8];
+ uchar rdata[4];
+ int rv, rlen, i;
+ uchar cc;
+
+ if (val != 0) val = 1;
+ for (i = 0; i < 3; i++) {
+ /* Set LED Override to 0=off or 1=on */
+ idata[0] = 0x0A; // 0x0A bus
+ idata[1] = 0xD0;
+ idata[2] = 0x00; // return no data
+ idata[3] = 0x0D; // LED_Override
+ idata[4] = val; /* turn on override */
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(MASTER_WRITE_READ, idata, 5, rdata, &rlen, &cc, fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ os_usleep(0,ENC_LED_SLEEP); /* wait before next LED cmd */
+ if (rv == 0) break;
+ }
+ return(rv);
+}
+
+static int set_enc_leds_i2c(uchar val)
+{
+ uchar idata[8];
+ uchar rdata[4];
+ int rv, rv2, rlen, i;
+ uchar cc;
+
+ if ((val != 0) && (rdisk_led_override == 0)) {
+ /* setting some LED, so set disk led override*/
+ rv2 = set_enc_override_i2c(1);
+ }
+
+ for (i = 0; i < 3; i++) {
+ /* For Romley/Patsburg set disk fault LED status */
+ idata[0] = 0x0A; // 0x0A bus
+ idata[1] = 0xD0;
+ idata[2] = 0x00; // return one byte of LED data
+ idata[3] = 0x0E; // LED_Status
+ idata[4] = val;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmd(MASTER_WRITE_READ, idata, 5, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ os_usleep(0,ENC_LED_SLEEP); /* wait before next LED cmd */
+ if (rv == 0) break;
+ }
+
+ if (val == 0x00) { /* clear the disk led override */
+ rv2 = set_enc_override_i2c(0);
+ }
+ return (rv);
+}
+
+void show_enc_leds_i2c(uchar val, int numd)
+{
+ char *enc_pattn = "disk slot %d LED: %s %s\n";
+ char *pstat;
+ char *pover;
+ uchar mask;
+ int i;
+ if (fdebug) printf("leds = %02x override = %02x\n",val,rdisk_led_override);
+ /* Some backplanes support 6 slots, but max is 8. */
+ if (numd > 8) numd = 8;
+ mask = 0x01;
+ for (i = 0; i < numd; i++) {
+ if (val & mask) pstat = "ON";
+ else pstat = "off";
+ if (rdisk_led_override) pover = "(override)";
+ else pover = "";
+ printf(enc_pattn,i,pstat,pover);
+ mask = (mask << 1);
+ }
+}
+
+static int set_enc_override_rcmd(uchar val)
+{
+ rdisk_led_override = val;
+ return(0);
+}
+
+static int get_enc_leds_rcmd(uchar *val)
+{
+ uchar rdata[8];
+ uchar slot[12];
+ int rv, rlen, i;
+ uchar cc;
+ uchar v = 0;
+
+ /* This command is only supported on Intel Romley w BMC >= 1.10 */
+ for (i = 0; i < 12; i++) slot[i] = 0;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x65, 0x30, g_sa,g_bus,g_lun,
+ NULL, 0, rdata, &rlen, &cc, fdebug);
+ if (fdebug) printf("get_enc_leds_rcmd: rv = %d, cc=%02x\n", rv,cc);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) {
+ rdisk_led_override = (rdata[0] & 0x07);
+/*
+rdata[1]: Slot 1 to 4 status
+ [7:6]Slot4 status
+ 00-Off
+ 01-Locate (Amber 4HZ)
+ 10-Fail (Amber solid on)
+ 11-Rebuild (Amber 1HZ)
+ [5:4] Slot3 status
+ 00-Off
+ 01-Locate (Amber 4HZ)
+ 10-Fail (Amber solid on)
+ 11-Rebuild (Amber 1HZ)
+ [3:2] Slot2 status
+ 00-Off
+ 01-Locate (Amber 4HZ)
+ 10-Fail (Amber solid on)
+ 11-Rebuild (Amber 1HZ)
+ [1:0] Slot1 status
+ 00-Off
+ 01-Locate (Amber 4HZ)
+ 10-Fail (Amber solid on)
+ 11-Rebuild (Amber 1HZ)
+ */
+ if (rdata[1] & 0x02) slot[0] = 1;
+ if (rdata[1] & 0x08) slot[1] = 1;
+ if (rdata[1] & 0x20) slot[2] = 1;
+ if (rdata[1] & 0x80) slot[3] = 1;
+ if (rdata[2] & 0x02) slot[4] = 1;
+ if (rdata[2] & 0x08) slot[5] = 1;
+ if (rdata[2] & 0x20) slot[6] = 1;
+ if (rdata[2] & 0x80) slot[7] = 1;
+ if (rdata[3] & 0x02) slot[8] = 1;
+ if (rdata[3] & 0x08) slot[9] = 1;
+ if (rdata[3] & 0x20) slot[10] = 1;
+ if (rdata[3] & 0x80) slot[11] = 1;
+ }
+ for (i = 0; i < 8; i++) {
+ if (slot[i] == 1) v |= (1 << i);
+ }
+ *val = v;
+ return(rv);
+}
+
+static int set_enc_leds_rcmd(uchar val)
+{
+ uchar idata[8];
+ uchar rdata[4];
+ int rlen, rv;
+ uchar cc;
+
+ if ((val != 0) && (rdisk_led_override == 0))
+ set_enc_override_rcmd(1);
+
+ /* This command is only supported on Intel Romley w BMC >= 1.10 */
+ idata[0] = rdisk_led_override;
+ idata[1] = val; /*first 8 slots*/
+ idata[2] = 0;
+ idata[3] = 0;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x64, 0x30, g_sa,g_bus,g_lun,
+ idata, 4, rdata, &rlen, &cc, fdebug);
+ if (fdebug) printf("set_enc_leds_rcmd: rv = %d, cc=%02x\n", rv,cc);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) os_usleep(0,ENC_RCMD_SLEEP);
+
+ if ((rv == 0) && (val == 0)) { /*repeat with override off*/
+ os_usleep(1,0); /* wait before next LED cmd */
+ idata[0] = 0;
+ idata[1] = val;
+ idata[2] = 0;
+ idata[3] = 0;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x64, 0x30, g_sa,g_bus,g_lun,
+ idata, 4, rdata, &rlen, &cc, fdebug);
+ if (fdebug) printf("set_enc_leds_rcmd0: rv = %d, cc=%02x\n", rv,cc);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) os_usleep(0,ENC_RCMD_SLEEP);
+ set_enc_override_rcmd(0);
+ }
+ os_usleep(1,0); /* wait before next LED cmd */
+ return(rv);
+}
+
+static void show_enc_leds_rcmd(uchar val, int numd)
+{
+ char *enc_pattn = "disk slot %d LED: %s %s\n";
+ char *pstat;
+ char *pover;
+ uchar mask;
+ int i;
+ if (fdebug) printf("leds = %02x override = %02x\n",val,rdisk_led_override);
+ /* Some backplanes support 6 slots, but max is 8. */
+ if (numd > 8) numd = 8;
+ mask = 0x01;
+ for (i = 0; i < numd; i++) {
+ if (val & mask) pstat = "ON";
+ else pstat = "off";
+ if (rdisk_led_override) pover = "(override)";
+ else pover = "";
+ printf(enc_pattn,i,pstat,pover);
+ mask = (mask << 1);
+ }
+}
+
+int set_enc_override_intel(uchar val)
+{
+ int rv;
+ if (rdisk_led_method == 1) rv = set_enc_override_rcmd(val);
+ else rv = set_enc_override_i2c(val);
+ return(rv);
+}
+
+int get_enc_leds_intel(uchar *val)
+{
+ int rv = -1;
+ if (rdisk_led_method < 2) rv = get_enc_leds_rcmd(val);
+ if ((rv != 0) && (rdisk_led_method == 0)) rdisk_led_method = 2;
+ if (rdisk_led_method == 2) rv = get_enc_leds_i2c(val);
+ return(rv);
+}
+
+int set_enc_leds_intel(uchar val)
+{
+ int rv = -1;
+ if (rdisk_led_method < 2) rv = set_enc_leds_rcmd(val);
+ if ((rv != 0) && (rdisk_led_method == 0)) rdisk_led_method = 2;
+ if (rdisk_led_method == 2) rv = set_enc_leds_i2c(val);
+ return(rv);
+}
+
+void show_enc_leds_intel(uchar val, int numd)
+{
+ if (rdisk_led_method == 1) show_enc_leds_rcmd(val, numd);
+ else show_enc_leds_i2c(val, numd);
+}
+
+/* end oem_intel.c */
diff --git a/util/oem_intel.h b/util/oem_intel.h
new file mode 100644
index 0000000..79587d5
--- /dev/null
+++ b/util/oem_intel.h
@@ -0,0 +1,79 @@
+/*
+ * oem_intel.h
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2010 Kontron America, Inc.
+ *
+ * 09/02/10 Andy Cress - separated from ialaems.c
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+
+#define PRIVATE_BUS_ID 0x03 // w Sahalee, the 8574 is on Private Bus 1
+#define PRIVATE_BUS_ID5 0x05 // for Intel TIGI2U
+#define PRIVATE_BUS_ID7 0x07 // for Intel S5000
+#define PERIPHERAL_BUS_ID 0x24 // w mBMC, the 8574 is on the Peripheral Bus
+#define ALARMS_PANEL_WRITE 0x40
+#define ALARMS_PANEL_READ 0x41
+#define DISK_LED_WRITE 0x44 // only used for Chesnee mBMC
+#define DISK_LED_READ 0x45 // only used for Chesnee mBMC
+
+#define HAS_ALARMS_MASK 0x0001
+#define HAS_BMCTAM_MASK 0x0002
+#define HAS_ENCL_MASK 0x0004
+#define HAS_PICMG_MASK 0x0008
+#define HAS_NSC_MASK 0x0010
+#define HAS_ROMLEY_MASK 0x0020
+
+uchar get_nsc_diskleds(uchar busid);
+int set_nsc_diskleds(uchar val, uchar busid);
+void show_nsc_diskleds(uchar val);
+
+uchar get_alarms_intel(uchar busid);
+int set_alarms_intel(uchar val, uchar busid);
+void show_alarms_intel(uchar val);
+int check_bmctam_intel(void);
+int detect_capab_intel(int vend_id,int prod_id, int *cap, int *ndsk,char fdbg);
+int get_led_status_intel(uchar *pstate);
+int is_lan2intel(int vend, int prod);
+int decode_sensor_intel(uchar *sdr,uchar *reading,char *pstring, int slen);
+int decode_sensor_intel_nm(uchar *sdr,uchar *reading,char *pstring, int slen);
+void show_oemsdr_intel(uchar *sdr);
+void show_oemsdr_nm(uchar *sdr);
+int is_romley(int vend, int prod);
+int is_thurley(int vend, int prod);
+int get_enc_leds_intel(uchar *val);
+int set_enc_leds_intel(uchar val);
+void show_enc_leds_intel(uchar val, int numd);
+int lan_failover_intel(uchar func, uchar *mode);
+int intel_romley_desc(int vend, int prod, char **pdesc);
+int get_power_restore_delay_intel(int *delay);
+int get_hsbp_version_intel(uchar *maj, uchar *min);
+
+/* end oem_intel.h */
diff --git a/util/oem_kontron.c b/util/oem_kontron.c
new file mode 100644
index 0000000..263560f
--- /dev/null
+++ b/util/oem_kontron.c
@@ -0,0 +1,1107 @@
+/*
+ * oem_kontron.c
+ * This code implements Kontron OEM proprietary commands.
+ *
+ * Change history:
+ * 08/25/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2004 Kontron Canada, Inc. All Rights Reserved.
+ *
+ * Base on code from
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+/*
+ * Tue Mar 7 14:36:12 2006
+ * <stephane.filion@ca.kontron.com>
+ *
+ * This code implements an Kontron OEM proprietary commands.
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#include <winsock.h>
+#include <time.h>
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+typedef uint32_t socklen_t;
+#else
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+#include "oem_kontron.h"
+
+#define FRU_TYPE_COMPONENT 0x01
+#define FRU_TYPE_BASEBOARD 0x07
+
+const struct valstr ktc5520_post[] = { /*from EAS*/
+ { 0x0003, "Start POST Init" },
+ { 0x0004, "Check CMOS" },
+ { 0x0005, "Init interrupt HW" },
+ { 0x0006, "Init INT1Ch" },
+ { 0x0008, "Init CPUs" },
+ { 0x000A, "Init 8042 Keyboard" },
+ { 0x000B, "Detect PS2 Mouse" },
+ { 0x000C, "Detect KBC Keyboard" },
+ { 0x000E, "Test Input Devices" },
+ { 0x0013, "PreInit chipset regs" },
+ { 0x0024, "Init platform modules" },
+ { 0x002A, "Init PCI devices" },
+ { 0x002C, "Init Video" },
+ { 0x002E, "Init Output devices" },
+ { 0x0030, "Init SMI" },
+ { 0x0031, "Init ADM module" },
+ { 0x0033, "Init Silent boot" },
+ { 0x0037, "Show first message" },
+ { 0x0038, "Init Buses" },
+ { 0x0039, "Init DMAC" },
+ { 0x003A, "Init RTC" },
+ { 0x003B, "Memory Test" },
+ { 0x003C, "MidInit chipset regs" },
+ { 0x0040, "Detect Ports" },
+ { 0x0050, "Adjust RAM size" },
+ { 0x0052, "Update CMOS size" },
+ { 0x0060, "Init Kbd Numlock" },
+ { 0x0075, "Init Int13" },
+ { 0x0078, "Init IPL" },
+ { 0x007A, "Init OpRoms" },
+ { 0x007C, "Write ESCD to NV" },
+ { 0x0084, "Log errors" },
+ { 0x0085, "Display errors" },
+ { 0x0087, "Run BIOS Setup" },
+ { 0x008C, "LateInit chipset regs" },
+ { 0x008D, "Build ACPI Tables" },
+ { 0x008E, "Program peripherals" },
+ { 0x0090, "LateInit SMI" },
+ { 0x00A0, "Check Boot password" },
+ { 0x00A1, "PreBoot Cleanup" },
+ { 0x00A2, "Init Runtime image" },
+ { 0x00A4, "Init Runtime lang" },
+ { 0x00A7, "Show Config, Init MTRR" },
+ { 0x00A8, "Prep CPU for OS boot" },
+ { 0x00A9, "Wait for input" },
+ { 0x00AA, "Deinit ADM, Int1C" },
+ { 0x00AB, "Prepare BBS" },
+ { 0x00AC, "EndInit chipse regs" },
+ { 0x00B1, "Save context for ACPI" },
+ { 0x00C0, "EarlyCPU Init APIC" },
+ { 0x00C1, "Setup BSP info" },
+ { 0x00C2, "Setup BSP for POST" },
+ { 0x00C5, "Setup App Processors" },
+ { 0x00C6, "Setup BSP cache" },
+ { 0x00C7, "EarlyCPU Init exit" },
+ { 0x0000, "OS Loader" },
+ { 0xffff , NULL } /*end of list*/
+};
+/*
+61-70, OEM POST Error. This range is reserved for chipset vendors & system manufacturers. The error associated with this value may be different from one platform to the next.
+DD-DE, OEM PCI init debug POST code during DIMM init, See DIM Code Checkpoints section of document for more information.
+DD-DE, OEM PCI init debug POST code during DIMM init. DEh during BUS number
+*/
+
+extern int verbose; /*ipmilanplus.c*/
+#ifdef METACOMMAND
+extern int load_fru(uchar sa, uchar frudev, uchar frutype, uchar **pfrubuf);
+extern int write_fru_data(uchar id, ushort offset, uchar *data, int dlen,
+ char fdebug); /*ifru.c*/
+#endif
+
+/* local function prototypes */
+static void ipmi_kontron_help(void);
+static int ipmi_kontron_set_serial_number(void * intf);
+static int ipmi_kontron_set_mfg_date (void * intf);
+
+static void print_buf( uint8_t * buf, int len, char * desc)
+{
+ dump_buf(desc,buf,len,0);
+}
+
+#ifdef METACOMMAND
+/* get_fru_area_str - Parse FRU area string from raw data
+ * @data: raw FRU data
+ * @offset: offset into data for area
+ * returns pointer to FRU area string
+ */
+static char * get_fru_area_str(uint8_t * data, uint32_t * offset)
+{
+ static const char bcd_plus[] = "0123456789 -.:,_";
+ char * str;
+ int len, off, size, i, j, k, typecode;
+ union {
+ uint32_t bits;
+ char chars[4];
+ } u;
+
+ size = 0;
+ off = *offset;
+ /* bits 6:7 contain format */
+ typecode = ((data[off] & 0xC0) >> 6);
+
+ /* bits 0:5 contain length */
+ len = data[off++];
+ len &= 0x3f;
+
+ switch (typecode) {
+ case 0: /* 00b: binary/unspecified */
+ /* hex dump -> 2x length */
+ size = (len*2);
+ break;
+ case 2: /* 10b: 6-bit ASCII */
+ /* 4 chars per group of 1-3 bytes */
+ size = ((((len+2)*4)/3) & ~3);
+ break;
+ case 3: /* 11b: 8-bit ASCII */
+ case 1: /* 01b: BCD plus */
+ /* no length adjustment */
+ size = len;
+ break;
+ }
+
+ if (size < 1) {
+ *offset = off;
+ return NULL;
+ }
+ str = malloc(size+1);
+ if (str == NULL)
+ return NULL;
+ memset(str, 0, size+1);
+
+ if (len == 0) {
+ str[0] = '\0';
+ *offset = off;
+ return str;
+ }
+
+ switch (typecode) {
+ case 0: /* Binary */
+ strncpy(str, buf2str(&data[off], len), len*2);
+ break;
+
+ case 1: /* BCD plus */
+ for (k=0; k<len; k++)
+ str[k] = bcd_plus[(data[off+k] & 0x0f)];
+ str[k] = '\0';
+ break;
+
+ case 2: /* 6-bit ASCII */
+ for (i=j=0; i<len; i+=3) {
+ u.bits = 0;
+ k = ((len-i) < 3 ? (len-i) : 3);
+#if WORDS_BIGENDIAN
+ u.chars[3] = data[off+i];
+ u.chars[2] = (k > 1 ? data[off+i+1] : 0);
+ u.chars[1] = (k > 2 ? data[off+i+2] : 0);
+#define CHAR_IDX 3
+#else
+ memcpy((void *)&u.bits, &data[off+i], k);
+#define CHAR_IDX 0
+#endif
+ for (k=0; k<4; k++) {
+ str[j++] = ((u.chars[CHAR_IDX] & 0x3f) + 0x20);
+ u.bits >>= 6;
+ }
+ }
+ str[j] = '\0';
+ break;
+
+ case 3:
+ memcpy(str, &data[off], len);
+ str[len] = '\0';
+ break;
+ }
+
+ off += len;
+ *offset = off;
+
+ return str;
+}
+#endif
+
+static char *bootdev[] = {"BIOS", "FDD", "HDD", "CDROM", "network", 0};
+
+static void
+ipmi_kontron_nextboot_help(void)
+{
+ int i;
+ printf("nextboot <device>\n"
+ "Supported devices:\n");
+ for (i = 0; bootdev[i] != 0; i++) {
+ printf("- %s\n", bootdev[i]);
+ }
+}
+
+/* ipmi_kontron_next_boot_set - Select the next boot order on CP6012
+ *
+ * @intf: ipmi interface
+ * @id: fru id
+ *
+ * returns -1 on error
+ * returns 1 if successful
+ */
+static int
+ipmi_kontron_nextboot_set(void * intf, int argc, char **argv)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t msg_data[8];
+ int i;
+
+ memset(msg_data, 0, sizeof(msg_data));
+ msg_data[0] = 0xb4;
+ msg_data[1] = 0x90;
+ msg_data[2] = 0x91;
+ msg_data[3] = 0x8b;
+ msg_data[4] = 0x9d;
+ msg_data[5] = 0xFF;
+ msg_data[6] = 0xFF; /* any */
+
+ for (i = 0; bootdev[i] != 0; i++) {
+ if (strcmp(argv[0], bootdev[i]) == 0) {
+ msg_data[5] = (uchar)i;
+ break;
+ }
+ }
+
+ /* Invalid device selected? */
+ if (msg_data[5] == 0xFF) {
+ printf("Unknown boot device: %s\n", argv[0]);
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = 0x3E;
+ req.msg.cmd = 0x02;
+ req.msg.data = msg_data;
+ req.msg.data_len = 7;
+
+ /* Set Lun temporary, necessary for this oem command */
+ req.msg.lun = 0x03;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf(" Device not present (No Response)\n");
+ return (rv);
+ }
+ if (rv > 0) {
+ printf(" NextBoot Device error (%s)\n",decode_cc(0,rv));
+ return(rv);
+ }
+ return (rv);
+}
+
+#ifdef METACOMMAND
+int
+ipmi_kontronoem_main(void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ if (argc == 0)
+ ipmi_kontron_help();
+ else if (strncmp(argv[0], "help", 4) == 0)
+ ipmi_kontron_help();
+
+ else if(!strncmp(argv[0], "setsn", 5))
+ {
+ if(argc >= 1)
+ {
+ rc = ipmi_kontron_set_serial_number(intf);
+ if(rc == 0) {
+ printf("FRU serial number set successfully\n");
+ } else {
+ printf("FRU serial number set failed\n");
+ }
+ }
+ else
+ {
+ printf("fru setsn\n");
+ }
+ }
+ else if(!strncmp(argv[0], "setmfgdate", 5))
+ {
+ if(argc >= 1)
+ {
+ rc = ipmi_kontron_set_mfg_date(intf);
+ if (rc == 0) {
+ printf("FRU manufacturing date set successfully\n");
+ } else {
+ printf("FRU manufacturing date set failed\n");
+ }
+ }
+ else
+ {
+ printf("fru setmfgdate\n");
+ }
+
+ }
+ else if (!strncmp(argv[0], "nextboot", sizeof("nextboot")-1))
+ {
+ if (argc > 1)
+ {
+ if ((rc = ipmi_kontron_nextboot_set(intf, argc-1, argv+1)) == 0)
+ {
+ printf("Nextboot set successfully\n");
+ } else {
+ printf("Nextboot set failed\n");
+ }
+ } else {
+ ipmi_kontron_nextboot_help();
+ }
+ }
+
+ else
+ {
+ printf("Invalid Kontron command: %s", argv[0]);
+ ipmi_kontron_help();
+ rc = ERR_USAGE;
+ }
+
+ return rc;
+}
+
+static void ipmi_kontron_help(void)
+{
+ printf("Kontron Commands: setsn setmfgdate nextboot\n");
+}
+
+/* ipmi_fru_set_serial_number - Set the Serial Number in FRU
+ *
+ * @intf: ipmi interface
+ * @id: fru id
+ *
+ * returns -1 on error
+ * returns 1 if successful
+ */
+static int
+ipmi_kontron_set_serial_number(void * intf)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct fru_info fru;
+ struct fru_header header;
+ uint8_t msg_data[4];
+ char *sn;
+ uint8_t sn_size, checksum;
+ uint8_t *fru_data;
+ char *fru_area;
+ uint32_t fru_data_offset, fru_data_offset_tmp, board_sec_len, prod_sec_len, i;
+ uint8_t bus, sa, lun, mtype;
+
+ sn = NULL;
+ fru_data = NULL;
+
+ ipmi_get_mc(&bus, &sa, &lun, &mtype);
+
+ memset(msg_data, 0, 4);
+ msg_data[0] = 0xb4;
+ msg_data[1] = 0x90;
+ msg_data[2] = 0x91;
+ msg_data[3] = 0x8b;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = 0x3E;
+ req.msg.cmd = 0x0C;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ /* Set Lun, necessary for this oem command */
+ req.msg.lun = 0x03;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf(" Device not present (No Response)\n");
+ return (rv);
+ }
+
+ if (rv > 0)
+ {
+ if (verbose) printf("sernum cmd ccode = %02x\n",rv);
+ printf(" This option is not implemented for this board\n");
+#ifdef TEST
+ strcpy(rsp,"serialnumber");
+ rsp_len = 12;
+#else
+ return (rv);
+#endif
+ }
+
+ sn_size = (uchar)rsp_len;
+ if (sn_size < 1)
+ {
+ printf(" Original serial number is zero length, was cleared.\n");
+ return(ERR_BAD_LENGTH);
+ }
+ sn = malloc(sn_size + 1);
+ if(sn == NULL)
+ {
+ printf("Out of memory!");
+ return(-1);
+ }
+
+ memset(sn, 0, sn_size + 1);
+ memcpy(sn, rsp, sn_size);
+
+ if(verbose >= 1)
+ {
+ printf("Original serial number is : [%s]\n", sn);
+ }
+
+ memset(msg_data, 0, 4);
+ msg_data[0] = 0;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = GET_FRU_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ printf(" Device not present (No Response)\n");
+ free(sn);
+ return (rv);
+ }
+ if (rv > 0) {
+ printf(" Device not present (%s)\n",decode_cc(0,rv));
+ free(sn);
+ return (rv);
+ }
+
+ fru.size = (rsp[1] << 8) | rsp[0];
+ fru.access = rsp[2] & 0x1;
+
+ if (fru.size < 1) {
+ printf(" Invalid FRU size %d", fru.size);
+ free(sn);
+ return(ERR_BAD_LENGTH);
+ }
+
+ /*
+ * retrieve the FRU header
+ */
+ msg_data[0] = 0;
+ msg_data[1] = 0;
+ msg_data[2] = 0;
+ msg_data[3] = 8;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = GET_FRU_DATA;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf(" Device not present (No Response)\n");
+ free(sn);
+ return(rv);
+ }
+ if (rv > 0)
+ {
+ printf(" Device not present (%s)\n",decode_cc(0,rv));
+ free(sn);
+ return(rv);
+ }
+
+ if (verbose >= 1)
+ print_buf(rsp, rsp_len, "FRU DATA");
+
+ memcpy(&header, rsp + 1, 8);
+
+ if (header.version != 1)
+ {
+ printf(" Unknown FRU header version 0x%02x\n", header.version);
+ free(sn);
+ return(-1);
+ }
+
+ /* Set the Board Section */
+ board_sec_len = (header.offset.product * 8) - (header.offset.board * 8);
+
+ rv = load_fru(sa,0, FRU_TYPE_BASEBOARD, &fru_data);
+ if (rv != 0)
+ {
+ printf(" Cannot Read FRU, error %d\n",rv);
+ free(sn);
+ if (fru_data != NULL) free(fru_data);
+ return(rv);
+ }
+
+ if (verbose >= 1)
+ print_buf(fru_data, fru.size, "FRU BUFFER");
+
+ /*Position at Board Manufacturer*/
+ fru_data_offset = (header.offset.board * 8) + 6;
+ fru_area = &fru_data[fru_data_offset];
+ if (verbose)
+ printf("board_area: offset=0x%x len=%d\n",fru_data_offset,board_sec_len);
+
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+ /*Position at Board Product Name*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+ fru_data_offset_tmp = fru_data_offset;
+
+ /*Position at Serial Number*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset_tmp);
+ if (fru_area == NULL) {
+ printf("Bad FRU area data read.\n");
+ free(sn);
+ free(fru_data);
+ return(-1);
+ }
+
+ fru_data_offset ++;
+ if (verbose)
+ printf("%x: Old board sernum [%s], New board sernum [%s]\n",
+ fru_data_offset,fru_area,sn);
+
+ if (strlen(fru_area) != sn_size)
+ {
+ printf("The length of the serial number in the FRU Board Area is wrong.\n");
+ free(sn);
+ free(fru_data);
+ return(ERR_BAD_LENGTH);
+ }
+
+ /* Copy the new serial number in the board section saved in memory*/
+ memcpy(fru_data + fru_data_offset, sn, sn_size);
+
+ /* Calculate Header Checksum */
+ checksum = 0;
+ for( i = (header.offset.board * 8); i < (((header.offset.board * 8)+board_sec_len) - 2) ; i ++ )
+ {
+ checksum += fru_data[i];
+ }
+ checksum = (~checksum) + 1;
+ fru_data[(header.offset.board * 8)+board_sec_len - 1] = checksum;
+
+#ifdef TEST
+ if (verbose >= 1)
+ print_buf(fru_data, fru.size, "FRU BUFFER, New");
+
+ /* Write the new FRU Board section */
+ rv = write_fru_data(0, 0, fru_data, fru.size, verbose);
+ // if(write_fru_area(intf, &fru, 0, (header.offset.board * 8), (header.offset.board * 8), board_sec_len, fru_data) < 0)
+ if ( rv != 0 )
+ {
+ printf(" Cannot Write FRU, error %d\n",rv);
+ free(sn);
+ free(fru_data);
+ return(rv);
+ }
+
+ if (fru_data != NULL) { free(fru_data); fru_data = NULL; }
+ rv = load_fru(sa,0, FRU_TYPE_BASEBOARD, &fru_data);
+ if (rv != 0)
+ {
+ printf(" Cannot Read FRU, error %d\n",rv);
+ free(sn);
+ if (fru_data != NULL) free(fru_data);
+ return(rv);
+ }
+#endif
+
+ /* Set the Product Section */
+ prod_sec_len = (header.offset.multi * 8) - (header.offset.product * 8);
+
+ /*Position at Product Manufacturer*/
+ fru_data_offset = (header.offset.product * 8) + 3;
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+ /*Position at Product Name*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+ /*Position at Product Part*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+ /*Position at Product Version*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset);
+
+
+
+ fru_data_offset_tmp = fru_data_offset;
+
+ /*Position at Serial Number*/
+ fru_area = get_fru_area_str(fru_data, &fru_data_offset_tmp);
+
+ fru_data_offset ++;
+ if (verbose)
+ printf("%x: Old product sernum [%s], New product sernum [%s]\n",
+ fru_data_offset,fru_area,sn);
+
+ if(strlen(fru_area) != sn_size)
+ {
+ free(sn);
+ free(fru_data);
+ printf("The length of the serial number in the FRU Product Area is wrong.\n");
+ return(ERR_BAD_LENGTH);
+ }
+
+ /* Copy the new serial number in the product section saved in memory*/
+ memcpy(fru_data + fru_data_offset, sn, sn_size);
+
+ /* Calculate Header Checksum */
+ checksum = 0;
+ for( i = (header.offset.product * 8); i < (((header.offset.product * 8)+prod_sec_len) - 2) ; i ++ )
+ {
+ checksum += fru_data[i];
+ }
+ checksum = (~checksum) + 1;
+ fru_data[(header.offset.product * 8)+prod_sec_len - 1] = checksum;
+
+ if (verbose >= 1)
+ print_buf(fru_data, fru.size, "FRU BUFFER, New");
+
+ /* Write the new FRU Board section */
+ rv = write_fru_data(0, 0, fru_data, fru.size, (char)verbose);
+ if ( rv != 0 )
+ {
+ printf(" Cannot Write FRU, error %d\n",rv);
+ /* fall through and free(sn); free(fru_data); return(rv); */
+ }
+
+ free(sn);
+ free(fru_data);
+ return(rv);
+}
+
+
+/* ipmi_fru_set_mfg_date - Set the Manufacturing Date in FRU
+ *
+ * @intf: ipmi interface
+ * @id: fru id
+ *
+ * returns -1 on error
+ * returns 1 if successful
+ */
+static int
+ipmi_kontron_set_mfg_date (void * intf)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ struct fru_info fru;
+ struct fru_header header;
+ uint8_t msg_data[4];
+ uint8_t mfg_date[3];
+
+ uint32_t board_sec_len, i;
+ uint8_t *fru_data, checksum;
+ uint8_t bus, sa, lun, mtype;
+
+ ipmi_get_mc(&bus, &sa, &lun, &mtype);
+
+ memset(msg_data, 0, 4);
+ msg_data[0] = 0xb4;
+ msg_data[1] = 0x90;
+ msg_data[2] = 0x91;
+ msg_data[3] = 0x8b;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = 0x3E;
+ req.msg.cmd = 0x0E;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ /* Set Lun temporary, necessary for this oem command */
+ req.msg.lun = 0x03;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf("Device not present (No Response)\n");
+ return(rv);
+ }
+
+ if (rv > 0)
+ {
+ printf("This option is not implemented for this board\n");
+ return(rv);
+ }
+
+ if(rsp_len != 3)
+ {
+ printf("Invalid response for the Manufacturing date\n");
+ return(ERR_BAD_LENGTH);
+ }
+ if(rsp[0] == 0 && rsp[1] == 0 && rsp[2] == 0)
+ {
+ printf("Manufacturing date is zero, has been cleared\n");
+ return(ERR_BAD_FORMAT);
+ }
+
+ memset(mfg_date, 0, 3);
+ memcpy(mfg_date, rsp, 3);
+
+ memset(msg_data, 0, 4);
+ msg_data[0] = 0;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = GET_FRU_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ printf(" Device not present (No Response)\n");
+ return(rv);
+ }
+ if (rv > 0) {
+ printf(" Device not present (%s)\n",decode_cc(0,rv));
+ return(rv);
+ }
+
+ fru.size = (rsp[1] << 8) | rsp[0];
+ fru.access = rsp[2] & 0x1;
+
+ if (fru.size < 1) {
+ printf(" Invalid FRU size %d", fru.size);
+ return(ERR_BAD_LENGTH);
+ }
+
+ /*
+ * retrieve the FRU header
+ */
+ msg_data[0] = 0;
+ msg_data[1] = 0;
+ msg_data[2] = 0;
+ msg_data[3] = 8;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = GET_FRU_DATA;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0)
+ {
+ printf(" Device not present (No Response)\n");
+ return(rv);
+ }
+ if (rv > 0)
+ {
+ printf(" Device not present (%s)\n",decode_cc(0,rv));
+ return(rv);
+ }
+
+ if (verbose > 1)
+ print_buf(rsp, rsp_len, "FRU DATA");
+
+ memcpy(&header, &rsp[1], 8);
+
+ if (header.version != 1)
+ {
+ printf(" Unknown FRU header version 0x%02x",
+ header.version);
+ return(ERR_BAD_FORMAT);
+ }
+
+
+ board_sec_len = (header.offset.product * 8) - (header.offset.board * 8);
+
+ rv = load_fru(sa,0, FRU_TYPE_BASEBOARD, &fru_data);
+ if (rv != 0)
+#ifdef NOT
+ /* do not re-read the same fru buffer */
+ fru_data = malloc( fru.size);
+ if(fru_data == NULL)
+ {
+ printf("Out of memory!");
+ return(-1);
+ }
+
+ memset(fru_data, 0, fru.size);
+ rv = read_fru_area(intf ,&fru ,0 ,(header.offset.board * 8) ,board_sec_len , fru_data);
+ if(rv < 0)
+#endif
+ {
+ if (fru_data != NULL) free(fru_data);
+ return(rv);
+ }
+
+ /* Copy the new manufacturing date in the board section saved in memory*/
+ memcpy(fru_data + (header.offset.board * 8) + 3, mfg_date, 3);
+
+ checksum = 0;
+ /* Calculate Header Checksum */
+ for( i = (header.offset.board * 8); i < (((header.offset.board * 8)+board_sec_len) - 2) ; i ++ )
+ {
+ checksum += fru_data[i];
+ }
+ checksum = (~checksum) + 1;
+
+ fru_data[(header.offset.board * 8)+board_sec_len - 1] = checksum;
+
+ /* Write the new FRU Board section */
+#ifdef NOT
+ if(write_fru_area(intf, &fru, 0, (header.offset.board * 8), (header.offset.board * 8), board_sec_len, fru_data) < 0)
+#endif
+ rv = write_fru_data(0, 0, fru_data, fru.size, (char)verbose);
+ if ( rv != 0 )
+ {
+ printf(" Cannot Write FRU, error %d\n",rv);
+ /* fall through and free(fru_data); return(rv); */
+ }
+
+ free(fru_data);
+ return(rv);
+}
+#endif
+
+static char *assert_str(uchar val)
+{
+ char *pstr;
+ if ((val & 0x0f) == 0) pstr = "Deasserted";
+ else pstr = "Asserted";
+ return(pstr);
+}
+
+/*
+ * decode_sel_kontron
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_kontron(uint8_t *evt, char *outbuf, int outsz, char fdesc,
+ char fdebug)
+{
+ int rv = -1;
+ uint16_t id;
+ uint8_t rectype;
+ int oemid;
+ uint32_t timestamp;
+ char timestr[40];
+ char mybuf[64];
+ char oembuf[64];
+ char *type_str = NULL;
+ char *gstr = NULL;
+ char *pstr = NULL;
+ int sevid;
+ ushort genid;
+ uchar snum;
+ int isdr = 0;
+ char *p1, *p2;
+
+ sevid = SEV_INFO;
+ id = evt[0] + (evt[1] << 8);
+ /* instead try to decode some events manually */
+ rectype = evt[2];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ snum = evt[11];
+ if (rectype == 0xc1) { /* OEM type C1 */
+ oemid = evt[7] + (evt[8] << 8) + (evt[9] << 16);
+ if (oemid == VENDOR_KONTRON) {
+ fmt_time(timestamp, timestr, sizeof(timestr));
+ type_str = "Kontron";
+ gstr = "BMC ";
+ switch(evt[10]) {
+ case 0x01:
+ default:
+ sprintf(mybuf,"OEM Event %02x %02x %02x %02x %02x %02x",
+ evt[10], evt[11], evt[12], evt[13], evt[14], evt[15]);
+ break;
+ }
+ snprintf(outbuf, outsz, "%04x %s %s %s %s %s\n",
+ id,timestr,get_sev_str(sevid), gstr, type_str, mybuf);
+ rv = 0;
+ } /*endif kontron*/
+ } else if (rectype == 0x02) {
+ type_str = "";
+ gstr = "BMC ";
+ sprintf(mybuf,"%02x [%02x %02x %02x]", evt[12],evt[13],evt[14],evt[15]);
+ switch(evt[10]) { /*sensor type*/
+ /* TODO: 0xC0, 0xC2, 0xC6 */
+ case 0xCF: /* Board Reset */
+ type_str = "Board Reset";
+ if (evt[12] == 0x03) { /*event trigger/type = discrete [de]assert */
+ pstr = ""; /*default*/
+ switch(evt[13]) { /*data1/offset*/
+ case 0x01:
+ pstr = "Asserted";
+ break;
+ case 0xa1: /*data2,3 bytes have meaning*/
+ /* data2: usually 0x01 */
+ /* data3: 05, 08, ff */
+ switch(evt[14]) { /*data2*/
+ case 0x00: p1 = "warm reset"; break;
+ case 0x01: p1 = "cold reset"; break;
+ case 0x02: p1 = "forced cold"; break;
+ case 0x03: p1 = "soft reset"; break;
+ case 0x04: p1 = "hard reset"; break;
+ case 0x05: p1 = "forced hard"; break;
+ default: p1 = "other"; break;
+ }
+ switch(evt[15]) { /*data3*/
+ case 0x00: p2 = "IPMI watchdog"; break;
+ case 0x01: p2 = "IPMI command"; break;
+ case 0x02: p2 = "Proc check stop"; break; /*internal*/
+ case 0x03: p2 = "Proc reset request"; break; /*internal*/
+ case 0x04: p2 = "Reset button"; break;
+ case 0x05: p2 = "Power up"; break;
+ case 0x06: p2 = "Legacy int watchdog"; break; /*internal*/
+ case 0x07: p2 = "Legacy prg watchdog"; break; /*programmable*/
+ case 0x08: p2 = "Software initiated"; break;
+ case 0x09: p2 = "Setup reset"; break;
+ case 0x0a: p2 = "Power cycle"; break;
+ default: p2 = "Other"; break;
+ }
+ sprintf(oembuf,"%s/%s",p1,p2);
+ pstr = oembuf;
+ break;
+ default: break;
+ }
+ rv = 0;
+ }
+ break;
+ case 0x12: /* System Event */
+ /* snum 38, 6f 00, or ef 00 */
+ /* if (snum == 0x38) */
+ type_str = "System Event";
+ if (evt[12] == 0x6f) pstr = assert_str(1); /*asserted*/
+ else pstr = assert_str(0); /*0xef means deasserted*/
+ rv = 0;
+ break;
+ case 0x24: /* Platform Alert */
+ /* usu 03 01 */
+ type_str = "Platform Alert";
+ pstr = assert_str(evt[13]); /*data1*/
+ rv = 0;
+ break;
+ case 0x2B: /* Version Change */
+ /* 6f c1 02 ff */
+ type_str = "Version Change";
+ if ((evt[13] & 0x80) == 0) pstr = "";
+ else switch(evt[14]) { /*data2*/
+ case 0x01: pstr = "HW Changed"; break;
+ case 0x02: pstr = "SW Changed"; break;
+ case 0x03: pstr = "HW incompatible"; break;
+ default: pstr = "Change failed"; break; /*TODO: add detail here*/
+ }
+ rv = 0;
+ break;
+ case 0x70:
+ type_str = "OEM Firmware Info 1";
+ pstr = assert_str(evt[13]); /*data1*/
+ rv = 0;
+ break;
+ case 0x71:
+ type_str = "OEM Firmware Info 2";
+ pstr = assert_str(evt[13]); /*data1*/
+ rv = 0;
+ break;
+ default: break;
+ }
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,mybuf,outbuf,outsz);
+ }
+ }
+ return rv;
+} /*end decode_sel_kontron*/
+
+int decode_sensor_kontron(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype;
+ char *pstr = NULL;
+ int rdval;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ if (sdr[3] != 0x02) return(rv); /*skip if not compact sensor*/
+ stype = sdr[12];
+ rdval = reading[2] | ((reading[3] & 0x7f) << 8);
+ /* usually reading3 == 0x80 */
+ switch(stype) {
+ case 0x08: /* Power Supply or PwrGood ... */
+ if (sdr[14] == 0x02) {
+ if (reading[2] & 0x02) pstr = "Failed";
+ else pstr = "OK";
+ rv = 0;
+ }
+ break;
+ case 0xC0: /* IPMI Info-N */
+ if (reading[2] == 0) pstr = "OK";
+ else pstr = "Asserted";
+ rv = 0;
+ break;
+ case 0xC2: /* IniAgent Err */
+ if ((reading[2] & 0x01) == 1) pstr = "OK";
+ else pstr = "Error"; /*could be 0x02*/
+ rv = 0;
+ break;
+ case 0xC6: /* POST Value */
+ pstr = (char *)val2str((ushort)rdval,ktc5520_post);
+ if (pstr == NULL) {
+ if (rdval >= 0x61 && rdval <= 0x71) pstr = "Error";
+ else if (rdval >= 0xDD && rdval <= 0xDE) pstr = "DIMM Debug";
+ else pstr = "Other";
+ }
+ rv = 0;
+ break;
+ case 0xCF: /* Board Reset */
+ if ((reading[2] & 0x01) == 1) pstr = "OK";
+ else pstr = "Asserted";
+ rv = 0;
+ break;
+ default:
+ break;
+ }
+ if (rv == 0) strncpy(pstring, pstr, slen);
+ return(rv);
+}
+
+/* end oem_kontron.c */
diff --git a/util/oem_kontron.h b/util/oem_kontron.h
new file mode 100644
index 0000000..b95e6a6
--- /dev/null
+++ b/util/oem_kontron.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2004 Kontron Canada, Inc. All Rights Reserved.
+ *
+ * Base on code from
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_KONTRONOEM_H
+#define IPMI_KONTRONOEM_H
+
+
+#define IPMI_BUF_SIZE 1024
+#ifdef HAVE_LANPLUS
+#include "../lib/lanplus/lanplus_defs.h"
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+#define IPMI_NETFN_APP 0x06
+#define IPMI_NETFN_STORAGE 0x0a
+#define IPMI_NETFN_PICMG 0x2C
+
+#define IPMI_BMC_SLAVE_ADDR 0x20
+
+#define BMC_GET_DEVICE_ID 0x1
+#define GET_FRU_INFO 0x10
+#define GET_FRU_DATA 0x11
+
+#pragma pack(1)
+struct fru_info {
+ uint16_t size;
+ uint8_t access:1;
+};
+struct fru_header {
+ uint8_t version;
+ struct {
+ uint8_t internal;
+ uint8_t chassis;
+ uint8_t board;
+ uint8_t product;
+ uint8_t multi;
+ } offset;
+ uint8_t pad;
+ uint8_t checksum;
+};
+#pragma pack()
+
+/* the ERRs are defined in ipmicmd.h */
+int ipmi_kontronoem_main(void *intf, int argc, char **argv);
+
+#endif /* IPMI_KONTRONOEM_H */
diff --git a/util/oem_newisys.c b/util/oem_newisys.c
new file mode 100644
index 0000000..7b78532
--- /dev/null
+++ b/util/oem_newisys.c
@@ -0,0 +1,129 @@
+/*
+ * oem_newisys.c
+ *
+ * This module handles OEM-specific functions for newisys firmware.
+ *
+ * Copyright (c) 2012 Kontron America, Inc.
+ *
+ * 04/05/12 Andy Cress v1.0 new, with input from ipmitool
+ */
+/*M*
+Copyright (c) 2012 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+
+#define DESC_MAX 200
+/*
+ * decode_sel_newisys
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_newisys(uchar *evt, char *outbuf, int outsz, char fdesc,
+ char fdbg)
+{
+ int rv = -1;
+ ushort id, genid;
+ ulong timestamp;
+ char *type_str = NULL;
+ char *gstr = NULL;
+ char *pstr = NULL;
+ int sevid;
+ char description[DESC_MAX];
+ int rlen, i;
+ uchar idata[16];
+ uchar rdata[DESC_MAX];
+ uchar cc;
+ uchar snum, stype, rectype;
+
+ fdebug = fdbg;
+ id = evt[0] + (evt[1] << 8);
+ rectype = evt[2];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ stype = evt[10];
+ snum = evt[11];
+ gstr = "BMC ";
+ if (genid == 0x0033) gstr = "Bios";
+ type_str = "";
+ if (rectype == 0x02) type_str = get_sensor_type_desc(stype);
+ sevid = SEV_INFO;
+
+ idata[0] = 0x15; /* IANA LSB */
+ idata[1] = 0x24; /* IANA */
+ idata[2] = 0x00; /* IANA MSB */
+ idata[3] = 0x01; /* Subcommand */
+ idata[4] = id & 0x00FF; /* SEL Record ID LSB */
+ idata[5] = (id & 0xFF00) >> 8; /* SEL Record ID MSB */
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(0x01, 0x2E, g_sa,g_bus,g_lun,
+ idata, 6, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+
+ if (rv == 0) {
+ if (rlen < 5) {
+ printf("Newisys OEM response too short");
+ return LAN_ERR_TOO_SHORT;
+ } else if (rlen != (4 + rdata[3])) {
+ printf("Newisys OEM response has unexpected length");
+ return LAN_ERR_TOO_SHORT;
+ }
+
+ /* copy the description */
+ i = rdata[3];
+ if (i >= DESC_MAX) i = DESC_MAX - 1;
+ if (i > (rlen-4)) i = rlen - 4;
+ memcpy(description, &rdata[4], i);
+ description[i] = 0;;
+ pstr = description;
+ /*TODO: parse for severity, setting sevid */
+
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,NULL,outbuf,outsz);
+ }
+ return rv;
+}
+
+/* end oem_newisys.c */
diff --git a/util/oem_quanta.c b/util/oem_quanta.c
new file mode 100644
index 0000000..a0ee3bb
--- /dev/null
+++ b/util/oem_quanta.c
@@ -0,0 +1,142 @@
+/*
+ * oem_quanta.c
+ * Handle Quanta OEM command functions
+ *
+ * Change history:
+ * 01/11/2012 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+
+extern int decode_sensor_intel_nm(uchar *sdr,uchar *reading,
+ char *pstring,int slen); /*oem_intel.c*/
+static char fdbg = 0;
+
+/*
+ * decode_sensor_quanta
+ * inputs:
+ * sdr = the SDR buffer
+ * reading = the 3 or 4 bytes of data from GetSensorReading
+ * pstring = points to the output string buffer
+ * slen = size of the output buffer
+ * outputs:
+ * rv = 0 if this sensor was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_quanta(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ int vend, prod;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ get_mfgid(&vend,&prod); /*saved from ipmi_getdeviceid */
+ if (vend != VENDOR_QUANTA) return(rv);
+ if (prod != PRODUCT_QUANTA_S99Q) return(rv); /*only handle S99Q product*/
+ if (sdr[3] != 0x02) return(rv); /*skip if not compact sensor*/
+
+ /* OEM SDR for Intel Node Manager */
+ rv = decode_sensor_intel_nm(sdr,reading,pstring,slen);
+ return(rv);
+}
+
+/*
+ * decode_sel_quanta
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ *
+ * Also case 7 was added to mem_str() in ievents.c for Quanta QSSC-S4R.
+ */
+int decode_sel_quanta(uchar *evt, char *outbuf, int outsz, char fdesc,
+ char fdebug)
+{
+ int rv = -1;
+ ushort id;
+ uchar rectype;
+ ulong timestamp;
+ char mybuf[64];
+ char *type_str = "";
+ char *gstr = NULL;
+ char *pstr = NULL;
+ int sevid;
+ ushort genid;
+ uchar snum;
+ int vend, prod;
+
+ fdbg = fdebug;
+ get_mfgid(&vend,&prod); /*saved from ipmi_getdeviceid */
+ if (vend != VENDOR_QUANTA) return(rv);
+ if (prod != PRODUCT_QUANTA_S99Q) return(rv); /*only handle S99Q product*/
+
+ sevid = SEV_INFO;
+ id = evt[0] + (evt[1] << 8);
+ rectype = evt[2];
+ snum = evt[11];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ if (genid == 0x0033) gstr = "Bios";
+ else gstr = "BMC ";
+ if (rectype == 0x02) {
+ sprintf(mybuf,"%02x [%02x %02x %02x]", evt[12],evt[13],evt[14],evt[15]);
+ switch(evt[10]) { /*sensor type*/
+ case 0xC0: /* CPU Temp Sensor, EvTyp=0x70 */
+ switch(evt[13]) { /*offset/data1*/
+ case 0x02: pstr = "Overheat"; sevid = SEV_MAJ; rv = 0; break;
+ default: break;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,mybuf,outbuf,outsz);
+ }
+
+ return(rv);
+}
+
+/* end oem_quanta.c */
diff --git a/util/oem_sun.c b/util/oem_sun.c
new file mode 100644
index 0000000..da413a8
--- /dev/null
+++ b/util/oem_sun.c
@@ -0,0 +1,1058 @@
+/*
+ * oem_sun.c
+ * Handle Sun OEM command functions
+ *
+ * Change history:
+ * 09/02/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+#include "getopt.h"
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <ctype.h>
+#include <limits.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <stdint.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+
+#ifndef ULONG_MAX
+/*needed for WIN32*/
+#define ULONG_MAX 4294967295UL
+#define UCHAR_MAX 255
+#endif
+
+#include "ipmicmd.h"
+#include "isensor.h"
+#include "oem_sun.h"
+
+extern int verbose; /*ipmilanplus.c*/
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+extern void set_loglevel(int level);
+
+static const struct valstr sunoem_led_type_vals[] = {
+ { 0, "OK2RM" },
+ { 1, "SERVICE" },
+ { 2, "ACT" },
+ { 3, "LOCATE" },
+ { 0xFF, NULL }
+};
+
+static const struct valstr sunoem_led_mode_vals[] = {
+ { 0, "OFF" },
+ { 1, "ON" },
+ { 2, "STANDBY" },
+ { 3, "SLOW" },
+ { 4, "FAST" },
+ { 0xFF, NULL }
+};
+static const struct valstr sunoem_led_mode_optvals[] = {
+ { 0, "STEADY_OFF" },
+ { 1, "STEADY_ON" },
+ { 2, "STANDBY_BLINK" },
+ { 3, "SLOW_BLINK" },
+ { 4, "FAST_BLINK" },
+ { 0xFF, NULL }
+};
+
+/* global variables */
+static char * progname = "isunoem";
+static char * progver = "2.93";
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static int is_sbcmd = 0;
+static int csv_output = 0;
+static uchar *sdrcache = NULL;
+static int vend_id = 0;
+static int prod_id = 0;
+
+static void
+ipmi_sunoem_usage(void)
+{
+ lprintf(LOG_NOTICE, "usage: sunoem <command> [option...]");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " fan speed <0-100>");
+ lprintf(LOG_NOTICE, " Set system fan speed (PWM duty cycle)");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " sshkey set <userid> <id_rsa.pub>");
+ lprintf(LOG_NOTICE, " Set ssh key for a userid into authorized_keys,");
+ lprintf(LOG_NOTICE, " view users with 'user list' command.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " sshkey del <userid>");
+ lprintf(LOG_NOTICE, " Delete ssh key for userid from authorized_keys,");
+ lprintf(LOG_NOTICE, " view users with 'user list' command.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " led get <sensorid> [ledtype]");
+ lprintf(LOG_NOTICE, " Read status of LED found in Generic Device Locator.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " led set <sensorid> <ledmode> [ledtype]");
+ lprintf(LOG_NOTICE, " Set mode of LED found in Generic Device Locator.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " sbled get <sensorid> [ledtype]");
+ lprintf(LOG_NOTICE, " Read status of LED found in Generic Device Locator");
+ lprintf(LOG_NOTICE, " for Sun Blade Modular Systems.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " sbled set <sensorid> <ledmode> [ledtype]");
+ lprintf(LOG_NOTICE, " Set mode of LED found in Generic Device Locator");
+ lprintf(LOG_NOTICE, " for Sun Blade Modular Systems.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " Use 'sdr list generic' command to get list of Generic");
+ lprintf(LOG_NOTICE, " Devices that are controllable LEDs.");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " Required SIS LED Mode:");
+ lprintf(LOG_NOTICE, " OFF Off");
+ lprintf(LOG_NOTICE, " ON Steady On");
+ lprintf(LOG_NOTICE, " STANDBY 100ms on 2900ms off blink rate");
+ lprintf(LOG_NOTICE, " SLOW 1HZ blink rate");
+ lprintf(LOG_NOTICE, " FAST 4HZ blink rate");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE, " Optional SIS LED Type:");
+ lprintf(LOG_NOTICE, " OK2RM OK to Remove");
+ lprintf(LOG_NOTICE, " SERVICE Service Required");
+ lprintf(LOG_NOTICE, " ACT Activity");
+ lprintf(LOG_NOTICE, " LOCATE Locate");
+ lprintf(LOG_NOTICE, "");
+}
+
+/*
+ * IPMI Request Data: 1 byte
+ *
+ * [byte 0] FanSpeed Fan speed as percentage
+ */
+static int
+ipmi_sunoem_fan_speed(void * intf, uint8_t speed)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ /*
+ * sunoem fan speed <percent>
+ */
+
+ if (speed > 100) {
+ lprintf(LOG_NOTICE, "Invalid fan speed: %d", speed);
+ return -1;
+ }
+
+ req.msg.netfn = IPMI_NETFN_SUNOEM;
+ req.msg.cmd = IPMI_SUNOEM_SET_FAN_SPEED;
+ req.msg.data = &speed;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Sun OEM Set Fan Speed command failed");
+ return (rv);
+ } else if (rv > 0) {
+ lprintf(LOG_ERR, "Sun OEM Set Fan Speed command failed: %s",
+ decode_cc(0,rv));
+ return (rv);
+ }
+
+ printf("Set Fan speed to %d%%\n", speed);
+
+ return rv;
+}
+
+
+static void
+led_print(const char * name, uint8_t state)
+{
+ if (csv_output)
+ printf("%s,%s\n", name, val2str(state, sunoem_led_mode_vals));
+ else
+ printf("%-16s | %s\n", name, val2str(state, sunoem_led_mode_vals));
+}
+
+int
+sunoem_led_get(void * intf, uchar *sdr, uchar ledtype, uchar *prsp)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t rqdata[7];
+ int rqdata_len = 5;
+ struct sdr_record_generic_locator * dev;
+
+ if (sdr == NULL) return -1;
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+
+ rqdata[0] = dev->dev_slave_addr;
+ if (ledtype == 0xFF)
+ rqdata[1] = dev->oem;
+ else
+ rqdata[1] = ledtype;
+ rqdata[2] = dev->dev_access_addr;
+ rqdata[3] = dev->oem;
+ if (is_sbcmd) {
+ rqdata[4] = dev->entity.id;
+ rqdata[5] = dev->entity.instance;
+ rqdata[6] = 0;
+ rqdata_len = 7;
+ }
+ else {
+ rqdata[4] = 0;
+ }
+
+ req.msg.netfn = IPMI_NETFN_SUNOEM;
+ req.msg.cmd = IPMI_SUNOEM_LED_GET;
+ req.msg.lun = dev->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = (uchar)rqdata_len;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Sun OEM Get LED command failed");
+ return rv;
+ }
+ else if (rv > 0) {
+ lprintf(LOG_ERR, "Sun OEM Get LED command failed: %s",
+ decode_cc(0,rv));
+ return rv;
+ }
+ if (prsp != NULL) memcpy(prsp,rsp,rsp_len);
+ if (rsp_len != 1) {
+ lprintf(LOG_ERR, "Sun OEM Get LED command error len=%d",
+ rsp_len);
+ return -1;
+ }
+ return rv;
+}
+
+int
+sunoem_led_set(void * intf, uchar *sdr, uchar ledtype, uchar ledmode)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+ uint8_t rqdata[9];
+ int rqdata_len = 7;
+ struct sdr_record_generic_locator * dev;
+
+ if (sdr == NULL) return -1;
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+
+ rqdata[0] = dev->dev_slave_addr;
+ if (ledtype == 0xFF)
+ rqdata[1] = dev->oem;
+ else
+ rqdata[1] = ledtype;
+ rqdata[2] = dev->dev_access_addr;
+ rqdata[3] = dev->oem;
+ rqdata[4] = ledmode;
+ if (is_sbcmd) {
+ rqdata[5] = dev->entity.id;
+ rqdata[6] = dev->entity.instance;
+ rqdata[7] = 0;
+ rqdata[8] = 0;
+ rqdata_len = 9;
+ }
+ else {
+ rqdata[5] = 0;
+ rqdata[6] = 0;
+ }
+
+ req.msg.netfn = IPMI_NETFN_SUNOEM;
+ req.msg.cmd = IPMI_SUNOEM_LED_SET;
+ req.msg.lun = dev->lun;
+ req.msg.data = rqdata;
+ req.msg.data_len = (uchar)rqdata_len;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Sun OEM Set LED command failed");
+ } else if (rv > 0) {
+ lprintf(LOG_ERR, "Sun OEM Set LED command failed: %s",
+ decode_cc(0,rv));
+ }
+ return rv;
+}
+
+static void
+sunoem_led_get_byentity(void * intf, uchar entity_id,
+ uchar entity_inst, uchar ledtype)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rv;
+ uchar *elist;
+ struct entity_id entity;
+ struct sdr_record_generic_locator *dev;
+ uchar sdr[IPMI_RSPBUF_SIZE];
+ ushort id;
+
+ if (entity_id == 0)
+ return;
+
+ /* lookup sdrs with this entity */
+ memset(&entity, 0, sizeof(struct entity_id));
+ entity.id = entity_id;
+ entity.instance = entity_inst;
+
+ if (sdrcache == NULL) rv = get_sdr_cache(&elist);
+ else elist = sdrcache;
+ id = 0;
+ /* for each generic sensor set its led state */
+ while(find_sdr_next(sdr,elist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
+ continue;
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+ if ((dev->entity.id == entity_id) &&
+ (dev->entity.instance == entity_inst)) {
+ rv = sunoem_led_get(intf, sdr, ledtype, rsp);
+ if (rv == 0) {
+ led_print((const char *)dev->id_string, rsp[0]);
+ }
+ }
+ }
+
+ if (sdrcache == NULL) free_sdr_cache(elist);
+}
+
+static void
+sunoem_led_set_byentity(void * intf, uchar entity_id,
+ uchar entity_inst, uchar ledtype, uchar ledmode)
+{
+ int rv;
+ uchar *elist;
+ struct entity_id entity;
+ struct sdr_record_generic_locator * dev;
+ uchar sdr[IPMI_RSPBUF_SIZE];
+ ushort id;
+
+ if (entity_id == 0)
+ return;
+
+ /* lookup sdrs with this entity */
+ memset(&entity, 0, sizeof(struct entity_id));
+ entity.id = entity_id;
+ entity.instance = entity_inst;
+
+ if (sdrcache == NULL) rv = get_sdr_cache(&elist);
+ else elist = sdrcache;
+ id = 0;
+ /* for each generic sensor set its led state */
+ while(find_sdr_next(sdr,elist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
+ continue;
+ /* match entity_id and entity_inst */
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+ if ((dev->entity.id == entity_id) &&
+ (dev->entity.instance == entity_inst)) {
+ rv = sunoem_led_set(intf, sdr, ledtype, ledmode);
+ if (rv == 0) {
+ led_print((const char *)dev->id_string, ledmode);
+ }
+ }
+ }
+
+ if (sdrcache == NULL) free_sdr_cache(elist);
+}
+
+/*
+ * IPMI Request Data: 5 bytes
+ *
+ * [byte 0] devAddr Value from the "Device Slave Address" field in
+ * LED's Generic Device Locator record in the SDR
+ * [byte 1] led LED Type: OK2RM, ACT, LOCATE, SERVICE
+ * [byte 2] ctrlrAddr Controller address; value from the "Device
+ * Access Address" field, 0x20 if the LED is local
+ * [byte 3] hwInfo The OEM field from the SDR record
+ * [byte 4] force 1 = directly access the device
+ * 0 = go thru its controller
+ * Ignored if LED is local
+ *
+ * The format below is for Sun Blade Modular systems only
+ * [byte 4] entityID The entityID field from the SDR record
+ * [byte 5] entityIns The entityIns field from the SDR record
+ * [byte 6] force 1 = directly access the device
+ * 0 = go thru its controller
+ * Ignored if LED is local
+ */
+static int
+ipmi_sunoem_led_get(void * intf, int argc, char ** argv)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rv;
+ uchar *alist;
+ struct sdr_record_entity_assoc *assoc;
+ struct sdr_record_generic_locator * dev;
+ uchar sdr[IPMI_RSPBUF_SIZE];
+ uchar sdr1[IPMI_RSPBUF_SIZE];
+ ushort id;
+ uchar ledtype = 0xFF;
+ int i;
+
+ /*
+ * sunoem led/sbled get <id> [type]
+ */
+
+ if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
+ ipmi_sunoem_usage();
+ return 0;
+ }
+
+ if (argc > 1) {
+ ledtype = (uchar)str2val(argv[1], sunoem_led_type_vals);
+ if (ledtype == 0xFF)
+ lprintf(LOG_ERR, "Unknown ledtype, will use data from the SDR oem field");
+ }
+
+ if (strncasecmp(argv[0], "all", 3) == 0) {
+ /* do all generic sensors */
+ lprintf(LOG_NOTICE, "Fetching SDRs ...");
+ rv = get_sdr_cache(&alist);
+ if (fdebug) lprintf(LOG_NOTICE, "get_sdr_cache rv = %d",rv);
+ id = 0;
+ rv = ERR_NOT_FOUND;
+ while(find_sdr_next(sdr,alist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
+ continue;
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+ if (dev->entity.logical) // (sdr[13] & 0x80 != 0)
+ continue;
+ rv = sunoem_led_get(intf, sdr, ledtype, rsp);
+ if (rv == 0) {
+ led_print((const char *)dev->id_string, rsp[0]);
+ }
+ }
+ free_sdr_cache(alist);
+ return rv;
+ }
+
+ /* look up generic device locator record in SDR */
+ id = (ushort)atoi(argv[0]);
+ lprintf(LOG_NOTICE, "Fetching SDRs ...");
+ rv = get_sdr_cache(&alist);
+ if (fdebug) lprintf(LOG_NOTICE, "get_sdr_cache rv = %d",rv);
+ if (rv == 0) {
+ sdrcache = alist;
+ rv = find_sdr_next(sdr1,alist,id);
+ }
+ if (rv != 0) {
+ lprintf(LOG_ERR, "No Sensor Data Record found for %s", argv[0]);
+ free_sdr_cache(alist);
+ return (rv);
+ }
+
+ if (sdr1[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {
+ lprintf(LOG_ERR, "Invalid SDR type %d", sdr1[3]);
+ free_sdr_cache(alist);
+ return (-1);
+ }
+
+ dev = (struct sdr_record_generic_locator *)&sdr1[5];
+ if (!dev->entity.logical) {
+ /*
+ * handle physical entity
+ */
+ rv = sunoem_led_get(intf, sdr1, ledtype, rsp);
+ if (rv == 0) {
+ led_print((const char *)dev->id_string, rsp[0]);
+ }
+ free_sdr_cache(alist);
+ return rv;
+ }
+
+ /*
+ * handle logical entity for LED grouping
+ */
+
+ lprintf(LOG_INFO, "LED %s is logical device", argv[0]);
+
+ /* get entity assoc records */
+ // rv = get_sdr_cache(&alist);
+ id = 0;
+ while(find_sdr_next(sdr,alist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_ENTITY_ASSOC)
+ continue;
+ assoc = (struct sdr_record_entity_assoc *)&sdr[5];
+ if (assoc == NULL) continue;
+ /* check that the entity id/instance matches our generic record */
+ if (assoc->entity.id != dev->entity.id ||
+ assoc->entity.instance != dev->entity.instance)
+ continue;
+
+ if (assoc->flags.isrange) {
+ /*
+ * handle ranged entity associations
+ *
+ * the test for non-zero entity id is handled in
+ * sunoem_led_get_byentity()
+ */
+
+ /* first range set - id 1 and 2 must be equal */
+ if (assoc->entity_id_1 == assoc->entity_id_2)
+ for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)
+ sunoem_led_get_byentity(intf, assoc->entity_id_1, (uchar)i, ledtype);
+
+ /* second range set - id 3 and 4 must be equal */
+ if (assoc->entity_id_3 == assoc->entity_id_4)
+ for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)
+ sunoem_led_get_byentity(intf, assoc->entity_id_3, (uchar)i, ledtype);
+ }
+ else {
+ /*
+ * handle entity list
+ */
+ sunoem_led_get_byentity(intf, assoc->entity_id_1,
+ assoc->entity_inst_1, ledtype);
+ sunoem_led_get_byentity(intf, assoc->entity_id_2,
+ assoc->entity_inst_2, ledtype);
+ sunoem_led_get_byentity(intf, assoc->entity_id_3,
+ assoc->entity_inst_3, ledtype);
+ sunoem_led_get_byentity(intf, assoc->entity_id_4,
+ assoc->entity_inst_4, ledtype);
+ }
+ }
+
+ free_sdr_cache(alist);
+ sdrcache = NULL;
+
+ return rv;
+}
+
+/*
+ * IPMI Request Data: 7 bytes
+ *
+ * [byte 0] devAddr Value from the "Device Slave Address" field in
+ * LED's Generic Device Locator record in the SDR
+ * [byte 1] led LED Type: OK2RM, ACT, LOCATE, SERVICE
+ * [byte 2] ctrlrAddr Controller address; value from the "Device
+ * Access Address" field, 0x20 if the LED is local
+ * [byte 3] hwInfo The OEM field from the SDR record
+ * [byte 4] mode LED Mode: OFF, ON, STANDBY, SLOW, FAST
+ * [byte 5] force TRUE - directly access the device
+ * FALSE - go thru its controller
+ * Ignored if LED is local
+ * [byte 6] role Used by BMC for authorization purposes
+ *
+ * The format below is for Sun Blade Modular systems only
+ * [byte 5] entityID The entityID field from the SDR record
+ * [byte 6] entityIns The entityIns field from the SDR record
+ * [byte 7] force TRUE - directly access the device
+ * FALSE - go thru its controller
+ * Ignored if LED is local
+ * [byte 8] role Used by BMC for authorization purposes
+ *
+ *
+ * IPMI Response Data: 1 byte
+ *
+ * [byte 0] mode LED Mode: OFF, ON, STANDBY, SLOW, FAST
+ */
+
+static int
+ipmi_sunoem_led_set(void * intf, int argc, char ** argv)
+{
+ int rv;
+ uchar *alist;
+ struct sdr_record_entity_assoc *assoc;
+ struct sdr_record_generic_locator * dev;
+ uchar sdr[IPMI_RSPBUF_SIZE];
+ uchar sdr1[IPMI_RSPBUF_SIZE];
+ ushort id;
+ uchar ledmode;
+ uchar ledtype = 0xFF;
+ int i;
+
+ /*
+ * sunoem led/sbled set <id> <mode> [type]
+ */
+
+ if (argc < 2 || strncmp(argv[0], "help", 4) == 0) {
+ ipmi_sunoem_usage();
+ return 0;
+ }
+
+ i = str2val(argv[1], sunoem_led_mode_vals);
+ if (i == 0xFF) {
+ i = str2val(argv[1], sunoem_led_mode_optvals);
+ if (i == 0xFF) {
+ lprintf(LOG_NOTICE, "Invalid LED Mode: %s", argv[1]);
+ return -1;
+ }
+ }
+ ledmode = (uchar)i;
+
+ if (argc > 3) {
+ ledtype = (uchar)str2val(argv[2], sunoem_led_type_vals);
+ if (ledtype == 0xFF)
+ lprintf(LOG_ERR, "Unknown ledtype, will use data from the SDR oem field");
+ }
+
+ if (strncasecmp(argv[0], "all", 3) == 0) {
+ /* do all generic sensors */
+ lprintf(LOG_NOTICE, "Fetching SDRs ...");
+ rv = get_sdr_cache(&alist);
+ if (fdebug) lprintf(LOG_NOTICE, "get_sdr_cache rv = %d",rv);
+ id = 0;
+ rv = ERR_NOT_FOUND;
+ while(find_sdr_next(sdr,alist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
+ continue;
+ dev = (struct sdr_record_generic_locator *)&sdr[5];
+ if ((sdr[13] & 0x80) != 0) /*logical entity*/
+ continue;
+ rv = sunoem_led_set(intf, sdr, ledtype, ledmode);
+ if (rv == 0) {
+ led_print((const char *)dev->id_string, ledmode);
+ }
+ }
+ free_sdr_cache(alist);
+ return rv;
+ }
+
+ /* look up generic device locator records in SDR */
+ id = (ushort)atoi(argv[0]);
+ lprintf(LOG_NOTICE, "Fetching SDRs ...");
+ rv = get_sdr_cache(&alist);
+ if (fdebug) lprintf(LOG_NOTICE, "get_sdr_cache rv = %d",rv);
+ if (rv == 0) {
+ sdrcache = alist;
+ rv = find_sdr_next(sdr1,alist,id);
+ }
+ if (rv != 0) {
+ lprintf(LOG_ERR, "No Sensor Data Record found for %s", argv[0]);
+ free_sdr_cache(alist);
+ return (rv);
+ }
+
+ if (sdr1[3] != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {
+ lprintf(LOG_ERR, "Invalid SDR type %d", sdr1[3]);
+ free_sdr_cache(alist);
+ return -1;
+ }
+ dev = (struct sdr_record_generic_locator *)&sdr1[5];
+
+ if (!dev->entity.logical) {
+ /*
+ * handle physical entity
+ */
+ rv = sunoem_led_set(intf, sdr, ledtype, ledmode);
+ if (rv == 0) {
+ led_print(argv[0], ledmode);
+ }
+ free_sdr_cache(alist);
+ return rv;
+ }
+
+ /*
+ * handle logical entity for LED grouping
+ */
+
+ lprintf(LOG_INFO, "LED %s is logical device", argv[0]);
+
+ /* get entity assoc records */
+ id = 0;
+ while(find_sdr_next(sdr,alist,id) == 0) {
+ id = sdr[0] + (sdr[1] << 8);
+ if (sdr[3] != SDR_RECORD_TYPE_ENTITY_ASSOC)
+ continue;
+ assoc = (struct sdr_record_entity_assoc *)&sdr[5];
+ if (assoc == NULL) continue;
+
+ /* check that the entity id/instance matches our generic record */
+ if (assoc->entity.id != dev->entity.id ||
+ assoc->entity.instance != dev->entity.instance)
+ continue;
+
+ if (assoc->flags.isrange) {
+ /*
+ * handle ranged entity associations
+ *
+ * the test for non-zero entity id is handled in
+ * sunoem_led_get_byentity()
+ */
+
+ /* first range set - id 1 and 2 must be equal */
+ if (assoc->entity_id_1 == assoc->entity_id_2)
+ for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)
+ sunoem_led_set_byentity(intf, assoc->entity_id_1, (uchar)i, ledtype, ledmode);
+
+ /* second range set - id 3 and 4 must be equal */
+ if (assoc->entity_id_3 == assoc->entity_id_4)
+ for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)
+ sunoem_led_set_byentity(intf, assoc->entity_id_3, (uchar)i, ledtype, ledmode);
+ }
+ else {
+ /*
+ * handle entity list
+ */
+ sunoem_led_set_byentity(intf, assoc->entity_id_1,
+ assoc->entity_inst_1, ledtype, ledmode);
+ sunoem_led_set_byentity(intf, assoc->entity_id_2,
+ assoc->entity_inst_2, ledtype, ledmode);
+ sunoem_led_set_byentity(intf, assoc->entity_id_3,
+ assoc->entity_inst_3, ledtype, ledmode);
+ sunoem_led_set_byentity(intf, assoc->entity_id_4,
+ assoc->entity_inst_4, ledtype, ledmode);
+ }
+ }
+
+ free_sdr_cache(alist);
+ sdrcache = NULL;
+
+ return rv;
+}
+
+static int
+ipmi_sunoem_sshkey_del(void * intf, uint8_t uid)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv;
+ struct ipmi_rq req;
+
+ memset(&req, 0, sizeof(struct ipmi_rq));
+ req.msg.netfn = IPMI_NETFN_SUNOEM;
+ req.msg.cmd = IPMI_SUNOEM_DEL_SSH_KEY;
+ req.msg.data = &uid;
+ req.msg.data_len = 1;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Unable to delete ssh key for UID %d", uid);
+ return rv;
+ }
+ else if (rv > 0) {
+ lprintf(LOG_ERR, "Unable to delete ssh key for UID %d: %s", uid,
+ decode_cc(0,rv));
+ return rv;
+ }
+
+ printf("Deleted SSH key for user id %d\n", uid);
+ return rv;
+}
+
+#define SSHKEY_BLOCK_SIZE 64
+static int
+ipmi_sunoem_sshkey_set(void * intf, uint8_t uid, char * ifile)
+{
+ uchar rsp[IPMI_RSPBUF_SIZE];
+ int rsp_len, rv = -1;
+ struct ipmi_rq req;
+ FILE * fp;
+ size_t count;
+ uint16_t i_size, r, f_size;
+ uint8_t wbuf[SSHKEY_BLOCK_SIZE + 3];
+
+ if (ifile == NULL) {
+ lprintf(LOG_ERR, "Invalid or missing input filename");
+ return -1;
+ }
+
+ fp = fopen(ifile, "r");
+ if (fp == NULL) {
+ lprintf(LOG_ERR, "Unable to open file %s for reading", ifile);
+ return -1;
+ }
+
+ printf("Setting SSH key for user id %d...", uid);
+
+ memset(&req, 0, sizeof(struct ipmi_rq));
+ req.msg.netfn = IPMI_NETFN_SUNOEM;
+ req.msg.cmd = IPMI_SUNOEM_SET_SSH_KEY;
+ req.msg.data = wbuf;
+
+ fseek(fp, 0, SEEK_END);
+ f_size = (uint16_t)ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ for (r = 0; r < f_size; r += i_size) {
+ i_size = f_size - r;
+ if (i_size > SSHKEY_BLOCK_SIZE)
+ i_size = SSHKEY_BLOCK_SIZE;
+
+ memset(wbuf, 0, SSHKEY_BLOCK_SIZE);
+ fseek(fp, r, SEEK_SET);
+ count = fread(wbuf+3, 1, i_size, fp);
+ if (count != i_size) {
+ lprintf(LOG_ERR, "Unable to read %d bytes from file %s", i_size, ifile);
+ fclose(fp);
+ return -1;
+ }
+
+ printf(".");
+ fflush(stdout);
+
+ wbuf[0] = uid;
+ if ((r + SSHKEY_BLOCK_SIZE) >= f_size)
+ wbuf[1] = 0xff;
+ else
+ wbuf[1] = (uint8_t)(r / SSHKEY_BLOCK_SIZE);
+ wbuf[2] = (uint8_t)i_size;
+ req.msg.data_len = i_size + 3;
+
+ rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+ if (rv < 0) {
+ lprintf(LOG_ERR, "Unable to set ssh key for UID %d", uid);
+ break;
+ }
+ }
+
+ printf("done\n");
+
+ fclose(fp);
+ return rv;
+}
+
+
+int
+ipmi_sunoem_main(void * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
+ ipmi_sunoem_usage();
+ return 0;
+ }
+
+ if (strncmp(argv[0], "fan", 3) == 0) {
+ uint8_t pct;
+ if (argc < 2) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ else if (strncmp(argv[1], "speed", 5) == 0) {
+ if (argc < 3) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ pct = atob(argv[2]);
+ rc = ipmi_sunoem_fan_speed(intf, pct);
+ }
+ else {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ }
+
+ if ((strncmp(argv[0], "led", 3) == 0) || (strncmp(argv[0], "sbled", 5) == 0)) {
+ if (argc < 2) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ if (strncmp(argv[0], "sbled", 5) == 0) {
+ is_sbcmd = 1;
+ }
+ if (strncmp(argv[1], "get", 3) == 0) {
+ if (argc < 3) {
+ char * arg[] = { "all" };
+ rc = ipmi_sunoem_led_get(intf, 1, arg);
+ } else {
+ rc = ipmi_sunoem_led_get(intf, argc-2, &(argv[2]));
+ }
+ }
+ else if (strncmp(argv[1], "set", 3) == 0) {
+ if (argc < 4) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ rc = ipmi_sunoem_led_set(intf, argc-2, &(argv[2]));
+ }
+ else {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ }
+
+ if (strncmp(argv[0], "sshkey", 6) == 0) {
+ uint8_t uid = 0;
+ unsigned long l;
+ if (argc < 2) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ else if (strncmp(argv[1], "del", 3) == 0) {
+ if (argc < 3) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ l = strtoul(argv[2], NULL, 0);
+ if ((l == ULONG_MAX) || (l > UCHAR_MAX)) {
+ printf("param %s is out of bounds\n",argv[2]);
+ return -17; /*ERR_BAD_PARAM*/
+ }
+ uid = (uint8_t)l;
+ rc = ipmi_sunoem_sshkey_del(intf, uid);
+ }
+ else if (strncmp(argv[1], "set", 3) == 0) {
+ if (argc < 4) {
+ ipmi_sunoem_usage();
+ return -1;
+ }
+ l = strtoul(argv[2], NULL, 0);
+ if ((l == ULONG_MAX) || (l > UCHAR_MAX)) {
+ printf("param %s is out of bounds\n",argv[2]);
+ return -17; /*ERR_BAD_PARAM*/
+ }
+ uid = (uint8_t)l;
+ rc = ipmi_sunoem_sshkey_set(intf, uid, argv[3]);
+ }
+ }
+
+ return rc;
+}
+
+int decode_sensor_sun(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype;
+ char *pstr = NULL;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ /* sdr[3] is the SDR type: 02=Compact, 01=Full) */
+ /* Usually compact sensors here, but type 0xC0 is a full sensor */
+ stype = sdr[12];
+ switch(stype) {
+ case 0x15: /* Module/Board State sensor (e.g. BL0/STATE) */
+ if ((reading[1] + reading[2]) == 0) pstr = "NotAvailable";
+ else if (reading[2] & 0x01) pstr = "OK"; /*deasserted/OK*/
+ else pstr = "Asserted"; /*Asserted, error*/
+ rv = 0;
+ break;
+ case 0xC0: /* Blade Error sensor (e.g. BL0/ERR, a Full SDR) */
+ if ((reading[1] + reading[2]) == 0) pstr = "NotAvailable";
+ else if (reading[2] & 0x01) pstr = "OK"; /*deasserted/OK*/
+ else pstr = "Asserted"; /*Asserted, error*/
+ rv = 0;
+ break;
+ default:
+ break;
+ }
+ if (rv == 0) strncpy(pstring, pstr, slen);
+ return(rv);
+}
+
+#ifdef METACOMMAND
+int i_sunoem(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ void *intf = NULL;
+ int rc = 0;
+ int c, i;
+ char *s1;
+ uchar devrec[16];
+
+ printf("%s ver %s\n", progname,progver);
+ set_loglevel(LOG_NOTICE);
+
+ while ( (c = getopt( argc, argv,"m:T:V:J:EYF:P:N:R:U:Z:x?")) != EOF )
+ switch (c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 1; verbose = 1;
+ set_debug();
+ break; /* debug messages */
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ case '?':
+ ipmi_sunoem_usage();
+ return 0;
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+
+ rc = ipmi_getdeviceid( devrec, sizeof(devrec),fdebug);
+ if (rc == 0) {
+ char ipmi_maj, ipmi_min;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+
+ rc = ipmi_sunoem_main(intf, argc, argv);
+ }
+ ipmi_close_();
+ // show_outcome(progname,rc);
+ return rc;
+}
diff --git a/util/oem_sun.h b/util/oem_sun.h
new file mode 100644
index 0000000..2f4f8c6
--- /dev/null
+++ b/util/oem_sun.h
@@ -0,0 +1,137 @@
+/*
+ * oem_sun.h
+ * Handle Sun OEM command functions
+ *
+ * Change history:
+ * 09/02/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_SUNOEM_H
+#define IPMI_SUNOEM_H
+
+
+#define IPMI_NETFN_SUNOEM 0x2e
+
+#define IPMI_SUNOEM_SET_SSH_KEY 0x01
+#define IPMI_SUNOEM_DEL_SSH_KEY 0x02
+#define IPMI_SUNOEM_GET_HEALTH_STATUS 0x10
+#define IPMI_SUNOEM_SET_FAN_SPEED 0x20
+#define IPMI_SUNOEM_LED_GET 0x21
+#define IPMI_SUNOEM_LED_SET 0x22
+
+#define SDR_RECORD_TYPE_ENTITY_ASSOC 0x08
+#define SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR 0x10
+
+//struct valstr {
+ //uint16_t val;
+ //const char * str;
+//};
+// const char * val2str(ushort val, const struct valstr *vs);
+ushort str2val(const char *str, const struct valstr *vs);
+
+#pragma pack(1)
+struct entity_id {
+ uint8_t id; /* physical entity id */
+#if WORDS_BIGENDIAN
+ uint8_t logical : 1; /* physical/logical */
+ uint8_t instance : 7; /* instance number */
+#else
+ uint8_t instance : 7; /* instance number */
+ uint8_t logical : 1; /* physical/logical */
+#endif
+}; // __attribute__ ((packed));
+
+struct sdr_record_generic_locator {
+ uint8_t dev_access_addr;
+ uint8_t dev_slave_addr;
+#if WORDS_BIGENDIAN
+ uint8_t channel_num:3;
+ uint8_t lun:2;
+ uint8_t bus:3;
+#else
+ uint8_t bus:3;
+ uint8_t lun:2;
+ uint8_t channel_num:3;
+#endif
+#if WORDS_BIGENDIAN
+ uint8_t addr_span:3;
+ uint8_t __reserved1:5;
+#else
+ uint8_t __reserved1:5;
+ uint8_t addr_span:3;
+#endif
+ uint8_t __reserved2;
+ uint8_t dev_type;
+ uint8_t dev_type_modifier;
+ struct entity_id entity;
+ uint8_t oem;
+ uint8_t id_code;
+ uint8_t id_string[16];
+}; // __attribute__ ((packed));
+
+struct sdr_record_entity_assoc {
+ struct entity_id entity; /* container entity ID and instance */
+ struct {
+#if WORDS_BIGENDIAN
+ uint8_t isrange:1;
+ uint8_t islinked:1;
+ uint8_t isaccessable:1;
+ uint8_t __reserved:5;
+#else
+ uint8_t __reserved:5;
+ uint8_t isaccessable:1;
+ uint8_t islinked:1;
+ uint8_t isrange:1;
+#endif
+ } flags;
+ uint8_t entity_id_1; /* entity ID 1 | range 1 entity */
+ uint8_t entity_inst_1; /* entity inst 1 | range 1 first instance */
+ uint8_t entity_id_2; /* entity ID 2 | range 1 entity */
+ uint8_t entity_inst_2; /* entity inst 2 | range 1 last instance */
+ uint8_t entity_id_3; /* entity ID 3 | range 2 entity */
+ uint8_t entity_inst_3; /* entity inst 3 | range 2 first instance */
+ uint8_t entity_id_4; /* entity ID 4 | range 2 entity */
+ uint8_t entity_inst_4; /* entity inst 4 | range 2 last instance */
+}; // __attribute__ ((packed));
+#pragma pack()
+
+int ipmi_sunoem_main(void *, int, char **);
+int sunoem_led_get(void * intf, uchar * dev, uchar ledtype, uchar *prsp);
+int sunoem_led_set(void * intf, uchar * dev, uchar ledtype, uchar ledmode);
+int decode_sensor_sun(uchar *sdr,uchar *reading,char *pstring, int slen);
+
+#endif /*IPMI_SUNOEM_H*/
+
diff --git a/util/oem_supermicro.c b/util/oem_supermicro.c
new file mode 100644
index 0000000..528e4f7
--- /dev/null
+++ b/util/oem_supermicro.c
@@ -0,0 +1,595 @@
+/*
+ * oem_supermicro.c
+ * Handle SuperMicro OEM command functions
+ *
+ * Change history:
+ * 12/06/2010 ARCress - included in source tree
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#ifdef WIN32
+#include <windows.h>
+#include "getopt.h"
+#else
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <sys/time.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "ipmicmd.h"
+#include "ievents.h"
+#include "oem_supermicro.h"
+
+#ifdef MOVED /*moved to oem_supermicro.h*/
+#define SUPER_NETFN_OEM 0x30
+#define SUPER_CMD_BMCSTATUS 0x70
+#define SUPER_CMD_RESET_INTRUSION 0x03
+#define SUPER_NETFN_OEMFW 0x3C
+#define SUPER_CMD_OEMFWINFO 0x20
+#endif
+
+void set_loglevel(int level); /*prototype */
+extern char fsm_debug; /*mem_if.c*/
+
+static char * progver = "2.93";
+static char * progname = "ismcoem";
+static int verbose = 0;
+static char fdebug = 0;
+static uchar g_bus = PUBLIC_BUS;
+static uchar g_sa = BMC_SA;
+static uchar g_lun = BMC_LUN;
+static uchar g_addrtype = ADDR_SMI;
+static int vend_id = 0;
+static int prod_id = 0;
+
+int oem_supermicro_get_bmc_status(uchar *sts)
+{
+ int rv;
+ int rlen, ilen;
+ uchar rdata[16];
+ uchar idata[16];
+ uchar cc;
+
+ if (sts == NULL) return(LAN_ERR_INVPARAM);
+ if ((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) {
+ /* subfunc 0xF0 is invalid for newer SMC systems */
+ idata[0] = 0x02; /* action: get status */
+ ilen = 1;
+ } else {
+ idata[0] = 0xF0; /* subfunction */
+ idata[1] = 0x02; /* action: get status */
+ // idata[2] = 0;
+ ilen = 2;
+ }
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_BMCSTATUS, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, ilen, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) { *sts = rdata[0]; }
+ return(rv);
+}
+
+int oem_supermicro_set_bmc_status(uchar sts)
+{
+ int rv;
+ int rlen, ilen;
+ uchar rdata[16];
+ uchar idata[16];
+ uchar cc;
+
+ if (sts > 1) sts = 1; /* actions: 0=disable, 1=enable, 2=status*/
+ if ((vend_id == VENDOR_SUPERMICROX) ||
+ (vend_id == VENDOR_SUPERMICRO)) {
+ idata[0] = sts;
+ ilen = 1;
+ } else {
+ idata[0] = 0xF0; /* subfunction */
+ idata[1] = sts;
+ ilen = 2;
+ }
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_BMCSTATUS, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, ilen, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ return(rv);
+}
+
+int oem_supermicro_get_lan_port(uchar *val)
+{
+ int rv;
+ int rlen, ilen;
+ uchar rdata[16];
+ uchar idata[16];
+ uchar cc;
+
+ idata[0] = 0x0c; /* subfunction */
+ idata[1] = 0x00; /* get */
+ ilen = 2;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_BMCSTATUS, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, ilen, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) { *val = rdata[0]; }
+ return(rv);
+}
+
+int oem_supermicro_set_lan_port(uchar val)
+{
+ int rv;
+ int rlen, ilen;
+ uchar rdata[16];
+ uchar idata[16];
+ uchar cc;
+
+ idata[0] = 0x0c; /* subfunction */
+ idata[1] = 0x01; /* set */
+ idata[2] = val;
+ ilen = 3;
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_BMCSTATUS, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, ilen, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ return(rv);
+}
+
+char *oem_supermicro_lan_port_string(uchar val)
+{
+ char *p;
+ switch(val) {
+ case 0: p = "Dedicated"; break;
+ case 1: p = "Onboard_LAN1"; break;
+ case 2: p = "Failover"; break;
+ default: p = "unknown"; break;
+ }
+ return(p);
+}
+
+static void oem_supermicro_show_lan_port(uchar val)
+{
+ printf("Current LAN interface is %s\n",
+ oem_supermicro_lan_port_string(val));
+}
+
+int oem_supermicro_get_health(char *pstr, int sz)
+{
+ int rv;
+ uchar bsts;
+ char *str;
+
+ rv = oem_supermicro_get_bmc_status(&bsts);
+ if (rv == 0) {
+ if (bsts == 0x01) str = "BMC status = enabled";
+ else str = "BMC status = disabled";
+ strncpy(pstr, str, sz);
+ }
+ return(rv);
+}
+
+/*
+ * oem_supermicro_get_firmware_info
+ *
+ * From post by ipmitool developer.
+ * http://sourceforge.net/mailarchive/message.php?msg_name=49ABCCC3.4040004%40cern.ch
+ *
+ * Request
+ * 0x3C - OEM network function
+ * 0x20 - OEM cmd (SUPER_CMD_OEMFWINFO)
+ *
+ * Response data:
+ * 4 bytes - firmware major version (LSB first)
+ * 4 bytes - firmware minor version (LSB first)
+ * 4 bytes - firmware sub version (LSB first)
+ * 4 bytes - firmware build number (LSB first)
+ * 1 byte - hardware ID
+ * ? bytes - firmware tag, null terminated string
+ */
+int oem_supermicro_get_firmware_info(uchar *info)
+{
+ int rv;
+ int rlen;
+ uchar rdata[32];
+ uchar idata[16];
+ uchar cc;
+
+ if (info == NULL) return(LAN_ERR_INVPARAM);
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_OEMFWINFO, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, 0, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) { memcpy(info,rdata,rlen); }
+ return(rv);
+}
+
+int oem_supermicro_get_firmware_str(char *pstr, int sz)
+{
+ int rv;
+ uchar info[32];
+ uint32 fwmaj;
+ uint32 fwmin;
+ uint32 fwsub;
+ uint32 fwbld;
+ uchar hwid;
+ rv = oem_supermicro_get_firmware_info(info);
+ if (rv == 0) {
+ fwmaj = info[0] + (info[1] << 8) + (info[2] << 16) + (info[3] << 24);
+ fwmin = info[4] + (info[5] << 8) + (info[6] << 16) + (info[7] << 24);
+ fwsub = info[8] + (info[9] << 8) + (info[10] << 16) + (info[11] << 24);
+ fwbld = info[12] +(info[13] << 8) + (info[14] << 16) + (info[15] << 24);
+ hwid = info[16];
+ /*info[17] = fw tag string */
+ snprintf(pstr,sz,"Firmware %d.%d.%d.%d HW %d %s\n",fwmaj,fwmin,fwsub,
+ fwbld,hwid,&info[17]);
+ }
+ return(rv);
+}
+
+
+int oem_supermicro_reset_intrusion(void)
+{
+ int rv;
+ int rlen;
+ uchar rdata[32];
+ uchar idata[16];
+ uchar cc;
+ // if (state == NULL) return(LAN_ERR_INVPARAM);
+ rlen = sizeof(rdata);
+ rv = ipmi_cmdraw(SUPER_CMD_RESET_INTRUSION, SUPER_NETFN_OEM,
+ BMC_SA, PUBLIC_BUS, BMC_LUN,
+ idata, 0, rdata, &rlen, &cc, fdebug);
+ if ((rv == 0) && (cc != 0)) rv = cc;
+ if (rv == 0) { /* check rdata for more info */ }
+ return(rv);
+}
+
+/*
+ * decode_sensor_supermicro
+ * inputs:
+ * sdr = the SDR buffer
+ * reading = the 3 or 4 bytes of data from GetSensorReading
+ * pstring = points to the output string buffer
+ * slen = size of the output buffer
+ * outputs:
+ * rv = 0 if this sensor was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_supermicro(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+ int rv = -1;
+ uchar stype;
+ uchar bval;
+ char *pstr = NULL;
+
+ if (sdr == NULL || reading == NULL) return(rv);
+ if (pstring == NULL || slen == 0) return(rv);
+ /* sdr[3] is 0x01 for Full, 0x02 for Compact */
+ bval = reading[2];
+ stype = sdr[12];
+ switch(stype) {
+ case 0xC0: /* CPU Temp Sensor, EvTyp=0x70 (Full) */
+ //if (dbg) printf("supermicro %x sensor reading %x\n",stype,reading);
+ rv = 0;
+ switch(bval) {
+ case 0x0000: pstr = "00 Low"; break;
+ case 0x0001: pstr = "01 Medium"; break;
+ case 0x0002: pstr = "02 High"; break;
+ case 0x0004: pstr = "04 Overheat"; break;
+ case 0x0007: pstr = "07 Not Installed"; break;
+ default: rv = -1; break;
+ }
+ break;
+ case 0x08: /* Power Supply Status (Full/Discrete) Table 42-3 */
+ rv = 0;
+ switch(bval) {
+ case 0x00: pstr = "00 Absent"; break; /*bit 0*/
+ case 0x01: pstr = "01 Present"; break; /*bit 0*/
+ case 0x02: pstr = "02 Failure"; break; /*bit 1*/
+ case 0x04: pstr = "04 Predict Fail"; break; /*bit 2*/
+ case 0x08: pstr = "08 Input Lost"; break; /*bit 3*/
+ default: rv = -1; break;
+ }
+ break;
+ default:
+ break;
+ }
+ if (rv == 0) strncpy(pstring, pstr, slen);
+ return(rv);
+}
+
+int decode_mem_supermicro(int prod, uchar b2, uchar b3, char *desc, int *psz)
+{
+ int array, dimm, n;
+ int rv = -1;
+ uchar bdata;
+ if ((desc == NULL) || (psz == NULL)) return -1;
+ if (b2 == 0xff) bdata = b3; /*ff is reserved*/
+ else bdata = b2; /* normal case */
+ array = (bdata & 0xc0) >> 6;
+ dimm = bdata & 0x3f;
+ /* bdata = 0x10 (16.) means CPU 1, DIMM 6 */
+ array = bdata / 10;
+ dimm = bdata % 10;
+
+#ifdef DMIOK
+ /* Use DMI if we get confirmation about array/dimm indices. */
+ if (! is_remote()) {
+ fsm_debug = fdebug;
+ rv = get_MemDesc(array,dimm,desc,psz);
+ /* if (rv != 0) desc has "DIMM[%d}" */
+ }
+#endif
+
+ if (rv != 0) {
+ n = sprintf(desc,"DIMM%d/CPU%d",dimm,array);
+ *psz = n;
+ rv = 0;
+ }
+ return(rv);
+} /*end decode_mem_supermicro*/
+
+/*
+ * decode_sel_supermicro
+ * inputs:
+ * evt = the 16-byte IPMI SEL event
+ * outbuf = points to the output string buffer
+ * outsz = size of the output buffer
+ * outputs:
+ * rv = 0 if this event was successfully interpreted here,
+ * non-zero otherwise, to use default interpretations.
+ * outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_supermicro(uchar *evt, char *outbuf, int outsz, char fdesc,
+ char fdbg)
+{
+ int rv = -1;
+ ushort id;
+ uchar rectype;
+ ulong timestamp;
+ char mybuf[64];
+ char *type_str = "";
+ char *pstr = NULL;
+ int sevid;
+ ushort genid;
+ uchar snum;
+
+ fdebug = fdbg;
+ sevid = SEV_INFO;
+ id = evt[0] + (evt[1] << 8);
+ rectype = evt[2];
+ snum = evt[11];
+ timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+ genid = evt[7] | (evt[8] << 8);
+ if (rectype == 0x02)
+ {
+ sprintf(mybuf,"%02x [%02x %02x %02x]", evt[12],evt[13],evt[14],evt[15]);
+ switch(evt[10]) { /*sensor type*/
+ case 0xC0: /* CPU Temp Sensor */
+ type_str = "OEM_CpuTemp";
+ switch((evt[13] &0x0f)) { /*offset/data1 l.o. nibble*/
+ case 0x02: /* CPU Temp Sensor Overheat event offset */
+ if (evt[12] & 0x80) { /*EvTyp==0xF0 if deassert*/
+ pstr = "CpuTemp Overheat OK"; sevid = SEV_INFO;
+ } else { /* EvTyp=0x70 assert */
+ pstr = "CpuTemp Overheat "; sevid = SEV_MAJ;
+ }
+ rv = 0;
+ break;
+ default: pstr = "CpuTemp Event"; break;
+ }
+ break;
+ case 0xC2: /* CPLD Event */
+ type_str = "OEM_CPLD";
+ switch((evt[13] & 0x0f)) { /* data1 usu 0xa0*/
+ case 0x00:
+ if (evt[14] == 0x1c)
+ { pstr = "CPLD CATERR Asserted"; sevid = SEV_CRIT; }
+ else { pstr = "CPLD Event Asserted"; sevid = SEV_MIN; }
+ rv = 0;
+ break;
+ default: pstr = "CPLD Event"; break;
+ }
+ break;
+ default: /*other sensor types*/
+ break;
+ }
+ }
+ if (rv == 0) {
+ format_event(id,timestamp, sevid, genid, type_str,
+ snum,NULL,pstr,mybuf,outbuf,outsz);
+ }
+ return(rv);
+}
+
+static void usage(void)
+{
+ printf("Usage: %s <command> [arg]\n",progname);
+ printf(" intrusion = reset chassis intrusion\n");
+ printf(" bmcstatus [enable| disable] = get/set BMC status\n");
+ printf(" firmware = get extra firmware info\n");
+ printf(" lanport [dedicated| lan1| failover] = get/set IPMI LAN port\n");
+ printf("These commands may not work on all SuperMicro systems\n");
+}
+
+static int ipmi_smcoem_main(int argc, char **argv)
+{
+ int rv = 0;
+ char msg[80];
+ uchar val;
+
+ if (strncmp(argv[0],"intrusion",9) == 0) {
+ printf("Clearing Chassis Intrusion ...\n");
+ rv = oem_supermicro_reset_intrusion();
+ } else if (strncmp(argv[0],"bmcstatus",9) == 0) {
+ printf("Getting BMC status ...\n");
+ rv = oem_supermicro_get_health(msg, sizeof(msg));
+ if (rv != 0) return(rv);
+ printf("%s\n",msg);
+ if (argv[1] != NULL) {
+ if (strncmp(argv[1],"disable",7) == 0) {
+ val = 0;
+ } else if (strncmp(argv[1],"enable",6) == 0) {
+ val = 1;
+ } else {
+ usage();
+ return(ERR_USAGE);
+ }
+ printf("Setting BMC status to %s ...\n",argv[1]);
+ rv = oem_supermicro_set_bmc_status(val);
+ if (rv != 0) return(rv);
+ rv = oem_supermicro_get_health(msg, sizeof(msg));
+ if (rv == 0) printf("%s\n",msg);
+ }
+ } else if (strncmp(argv[0],"firmware",8) == 0) {
+ printf("Getting SMC Firmare Information ...\n");
+ rv = oem_supermicro_get_firmware_str(msg, sizeof(msg));
+ if (rv == 0) printf("%s\n",msg);
+ } else if (strncmp(argv[0],"lanport",9) == 0) {
+ rv = oem_supermicro_get_lan_port(&val);
+ if (rv == 0) {
+ oem_supermicro_show_lan_port(val);
+ if (argv[1] != NULL) {
+ if (strncmp(argv[1],"dedicated",9) == 0) {
+ val = 0;
+ } else if (strncmp(argv[1],"lan1",4) == 0) {
+ val = 1;
+ } else if (strncmp(argv[1],"failover",8) == 0) {
+ val = 2;
+ } else {
+ usage();
+ return(ERR_USAGE);
+ }
+ printf("Setting LAN interface to %s ...\n",argv[1]);
+ rv = oem_supermicro_set_lan_port(val);
+ if (rv != 0) return(rv);
+ rv = oem_supermicro_get_lan_port(&val);
+ if (rv == 0) oem_supermicro_show_lan_port(val);
+ }
+ }
+ } else {
+ usage();
+ rv = ERR_USAGE;
+ }
+ return(rv);
+}
+
+#ifdef METACOMMAND
+int i_smcoem(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+ int rv = 0;
+ uchar devrec[16];
+ int c, i;
+ char *s1;
+
+ printf("%s ver %s\n", progname,progver);
+ set_loglevel(LOG_NOTICE);
+ parse_lan_options('V',"4",0); /*default to admin priv*/
+
+ while ( (c = getopt( argc, argv,"m:xzEF:J:N:P:R:T:U:V:YZ:?")) != EOF )
+ switch(c) {
+ case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+ g_bus = htoi(&optarg[0]); /*bus/channel*/
+ g_sa = htoi(&optarg[2]); /*device slave address*/
+ g_lun = htoi(&optarg[4]); /*LUN*/
+ g_addrtype = ADDR_IPMB;
+ if (optarg[6] == 's') {
+ g_addrtype = ADDR_SMI; s1 = "SMI";
+ } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+ ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+ printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+ s1,g_bus,g_sa,g_lun);
+ break;
+ case 'x': fdebug = 2; /* normal (dbglog if isol) */
+ verbose = 1;
+ break;
+ case 'z': fdebug = 3; /*full debug (for isol)*/
+ verbose = 1;
+ break;
+ case 'N': /* nodename */
+ case 'U': /* remote username */
+ case 'P': /* remote password */
+ case 'R': /* remote password */
+ case 'E': /* get password from IPMI_PASSWORD environment var */
+ case 'F': /* force driver type */
+ case 'T': /* auth type */
+ case 'J': /* cipher suite */
+ case 'V': /* priv level */
+ case 'Y': /* prompt for remote password */
+ case 'Z': /* set local MC address */
+ parse_lan_options(c,optarg,fdebug);
+ break;
+ default:
+ usage();
+ return(ERR_USAGE);
+ break;
+ }
+ for (i = 0; i < optind; i++) { argv++; argc--; }
+ if (argc == 0) {
+ usage();
+ return(ERR_USAGE);
+ }
+
+ rv = ipmi_getdeviceid(devrec,16,fdebug);
+ if (rv == 0) {
+ char ipmi_maj, ipmi_min;
+ ipmi_maj = devrec[4] & 0x0f;
+ ipmi_min = devrec[4] >> 4;
+ vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+ prod_id = devrec[9] + (devrec[10] << 8);
+ show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min);
+ }
+
+ rv = ipmi_smcoem_main(argc, argv);
+
+ ipmi_close_();
+ return(rv);
+}
+/* end oem_supermicro.c */
diff --git a/util/oem_supermicro.h b/util/oem_supermicro.h
new file mode 100644
index 0000000..daf08d6
--- /dev/null
+++ b/util/oem_supermicro.h
@@ -0,0 +1,56 @@
+/*
+ * oem_supermicro.h
+ * SuperMicro OEM command functions
+ *
+ *---------------------------------------------------------------------
+ */
+/*M*
+Copyright (c) 2013 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+
+#define SUPER_NETFN_OEM 0x30
+#define SUPER_CMD_BMCSTATUS 0x70
+#define SUPER_CMD_RESET_INTRUSION 0x03
+#define SUPER_NETFN_OEMFW 0x3C /*for SuperMicro/Peppercon*/
+#define SUPER_CMD_OEMFWINFO 0x20
+
+int oem_supermicro_get_bmc_status(uchar *sts);
+int oem_supermicro_set_bmc_status(uchar sts);
+int oem_supermicro_get_health(char *pstr, int sz);
+int oem_supermicro_get_firmware_info(uchar *info);
+int oem_supermicro_get_firmware_str(char *pstr, int sz);
+int oem_supermicro_reset_intrusion(void);
+int oem_supermicro_get_lan_port(uchar *val);
+int oem_supermicro_set_lan_port(uchar val);
+char *oem_supermicro_lan_port_string(uchar val);
+
+int decode_sensor_supermicro(uchar *sdr,uchar *reading,char *pstring, int slen);
+int decode_mem_supermicro(int prod, uchar b2, uchar b3, char *desc, int *psz);
+int decode_sel_supermicro(uchar *evt, char *outbuf, int outsz, char fdesc,
+ char fdebug);
+
+/* end oem_supermicro.h */
diff --git a/util/subs.c b/util/subs.c
new file mode 100644
index 0000000..9f11423
--- /dev/null
+++ b/util/subs.c
@@ -0,0 +1,848 @@
+/*
+ * subs.c
+ *
+ * Some common helper subroutines
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2010 Kontron America, Inc.
+ *
+ * 08/18/11 Andy Cress - created to consolidate subroutines
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ a.. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ b.. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ c.. Neither the name of Kontron nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *M*/
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#ifdef WIN32
+#include <windows.h>
+// #if !defined(LONG_MAX)
+// # if __WORDSIZE == 64
+// # define LONG_MAX 9223372036854775807L
+// # else
+// # define LONG_MAX 2147483647L
+// # endif
+// # define LONG_MIN (-LONG_MAX - 1L)
+// #endif
+
+#else
+/* Linux */
+#include <unistd.h>
+#include <syslog.h>
+#include <errno.h>
+#endif
+
+#include "ipmicmd.h"
+
+extern char fdebug; /*ipmicmd.c*/
+extern char fdbglog; /*ipmilanplus.c*/
+extern int verbose; /*ipmilanplus.c*/
+extern FILE *fpdbg; /*ipmicmd.c*/
+extern FILE *fplog; /*ipmicmd.c */
+extern char log_name[60]; /*log_name global, from ipmicmd.c*/
+
+static int loglevel = LOG_WARN;
+#ifdef WIN32
+#define SELMSG_ID 0x40000101 /* showselmsg.dll EventID 257. = 0x101 */
+static HANDLE hLog = NULL;
+#endif
+
+/* decode_rv, decode_cc are in ipmicmd.c */
+
+/* strlen_ wrapper for size_t/int warnings*/
+int strlen_(const char *s)
+{
+ return((int)strlen(s));
+}
+
+/* Need our own copy of strdup(), named strdup_(), since Windows does
+ * not have the same subroutine. */
+char * strdup_(const char *instr)
+{
+ char *newstr = NULL;
+ if (instr != NULL) {
+ newstr = malloc(strlen_(instr)+1);
+ if (newstr != NULL) strcpy(newstr,instr);
+ }
+ return (newstr);
+}
+
+#ifdef WIN32
+int strncasecmp(const char *s1, const char *s2, int n)
+{
+ int i, val;
+ char c1, c2;
+ if (s1 == NULL || s2 == NULL) return (-1);
+ val = 0;
+ for (i = 0; i < n; i++) {
+ c1 = s1[i] & 0x5f;
+ c2 = s2[i] & 0x5f;
+ if (c1 < c2) { val = -1; break; }
+ if (c1 > c2) { val = 1; break; }
+ }
+ return(val);
+}
+#endif
+
+/* case insensitive string compare */
+int str_icmp(char *s1, char *s2)
+{
+ int n1, n2, val;
+ if (s1 == NULL || s2 == NULL) return (-1);
+ n1 = strlen_(s1);
+ n2 = strlen_(s2);
+ if (n1 != n2) return(-1);
+ val = strncasecmp(s1,s2,n1);
+ return(val);
+}
+void set_loglevel(int level)
+{
+ loglevel = level;
+}
+
+void lprintf(int level, const char * format, ...)
+{
+ va_list vptr;
+ static char logtmp[LOG_MSG_LENGTH];
+ FILE *fp = stderr;
+ if (!verbose && (level > loglevel)) return;
+ if (fdbglog && (fplog != NULL)) fp = fplog;
+#ifdef WIN32
+ va_start(vptr, format);
+ vfprintf(fp, format, vptr);
+ va_end(vptr);
+ fprintf(fp,"\r\n");
+#else
+ va_start(vptr, format);
+ vsnprintf(logtmp, LOG_MSG_LENGTH, format, vptr);
+ va_end(vptr);
+ fprintf(fp, "%s\r\n", logtmp);
+#endif
+ return;
+}
+
+void lperror(int level, const char * format, ...)
+{
+ va_list vptr;
+ FILE *fp;
+ if (level > loglevel) return;
+ fp = stderr;
+ if (fdbglog && verbose > 1) {
+ if (fplog != NULL) fp = fplog;
+ }
+ va_start(vptr, format);
+ vfprintf(fp, format, vptr);
+ va_end(vptr);
+ fprintf(fp,"\r\n");
+ return;
+}
+
+void printbuf(const uchar * buf, int len, const char * desc)
+{
+ int i;
+ FILE *fp = stderr;
+
+ if (len <= 0) return;
+ if (verbose < 1) return;
+ if (fdbglog && (fplog != NULL)) fp = fplog;
+ fprintf(fp, "%s (%d bytes)\r\n", desc, len);
+ for (i=0; i<len; i++) {
+ if (((i%16) == 0) && (i != 0))
+ fprintf(fp, "\r\n");
+ fprintf(fp, " %2.2x", buf[i]);
+ }
+ fprintf(fp, "\r\n");
+}
+
+const char * buf2str(uchar * buf, int len)
+{
+ static char str[1024];
+ int i;
+ if (len <= 0 || len > sizeof(str)) return NULL;
+ memset(str, 0, sizeof(str));
+ for (i=0; i<len; i++) sprintf(str+i+i, "%2.2x", buf[i]);
+ str[len*2] = '\0';
+ return (const char *)str;
+}
+ushort buf2short(uchar * buf)
+{
+ return (ushort)(buf[1] << 8 | buf[0]);
+}
+ulong buf2long(uchar * buf)
+{
+ return (ulong)(buf[3] << 24 | buf[2] << 16 | buf[1] << 8 | buf[0]);
+}
+
+#define IPMI_OEM_PICMG 12634
+#define SZUN 32
+const char * oemval2str(ushort oem, uchar val, const struct oemvalstr *vs)
+{
+ static char un_str[SZUN];
+ int i;
+ for (i = 0; vs[i].oem != 0x00 && vs[i].str != NULL; i++) {
+ if ( ( vs[i].oem == oem || vs[i].oem == IPMI_OEM_PICMG )
+ && vs[i].val == val ) {
+ return vs[i].str;
+ }
+ }
+ memset(un_str, 0, SZUN);
+ snprintf(un_str, SZUN, "OEM reserved #%02x", val);
+ return un_str;
+}
+const char * val2str(ushort val, const struct valstr *vs)
+{
+ static char un_str[SZUN];
+ int i;
+ for (i = 0; vs[i].str != NULL; i++) {
+ if (vs[i].val == val) return vs[i].str;
+ }
+ memset(un_str, 0, SZUN);
+ snprintf(un_str, SZUN, "Unknown (0x%x)", val);
+ return un_str;
+}
+ushort str2val( char *str, struct valstr *vs)
+{
+ int i, x, y;
+ for (i = 0; vs[i].str != NULL; i++) {
+ x = strlen_(str);
+ y = strlen_(vs[i].str);
+ if (strncasecmp(vs[i].str, str, (x > y)? x : y) == 0)
+ return vs[i].val;
+ }
+ return vs[i].val;
+}
+
+
+void dump_buf(char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+ char *stag;
+ FILE *fpdbg1;
+
+ if (fpdbg != NULL) fpdbg1 = fpdbg;
+ else fpdbg1 = stdout;
+ if (tag == NULL) stag = "dump_buf"; /*safety valve*/
+ else stag = tag;
+ fprintf(fpdbg1,"%s (len=%d): ", stag,sz);
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ if (sz < 0) { fprintf(fpdbg1,"\n"); return; } /*safety valve*/
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) {
+ line[j] = 0;
+ j = 0;
+ fprintf(fpdbg1,"%s\n %04x: ",line,i);
+ }
+ if (fshowascii) {
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ }
+ fprintf(fpdbg1,"%02x ",pbuf[i]);
+ }
+ if (fshowascii) {
+ if ((j > 0) && (j < 16)) {
+ /* space over the remaining number of hex bytes */
+ for (i = 0; i < (16-j); i++) fprintf(fpdbg1," ");
+ }
+ else j = 16;
+ line[j] = 0;
+ }
+ fprintf(fpdbg1,"%s\n",line);
+ return;
+}
+
+void close_log(void)
+{
+ if ((fplog != NULL) && (fplog != stderr) && (fplog != stdout)) {
+ fclose(fplog);
+ fplog = NULL;
+ }
+}
+
+FILE *open_log(char *mname)
+{
+ FILE *fp = NULL;
+ char *pname;
+ int len;
+
+ /* log_name is global, for reuse */
+ if (log_name[0] == 0) {
+ if (mname == NULL) { /*make a default name*/
+ pname = "ipmiutil";
+#ifdef WIN32
+ sprintf(log_name,"%s.log",pname);
+#elif defined(DOS)
+ sprintf(log_name,"%s.log",pname);
+#else
+ /*LINUX, SOLARIS, BSD */
+ sprintf(log_name,"/var/log/%s.log",pname);
+#endif
+ } else { /*use mname arg*/
+ len = strlen_(mname);
+ if (len >= sizeof(log_name)) len = sizeof(log_name) - 1;
+ strncpy(log_name, mname, len);
+ }
+ }
+ close_log();
+ if (log_name[0] != 0)
+ fp = fopen( log_name, "a+" );
+ if (fp == NULL) {
+ fp = stdout; /*was stderr*/
+ fprintf(fp,"cannot open log: %s\n",log_name);
+ }
+ fplog = fp;
+ return fp;
+}
+
+void flush_log(void)
+{
+ if (fplog != NULL) fflush(fplog);
+}
+
+void print_log( char *pattn, ... )
+{
+ va_list arglist;
+ if (fplog == NULL) fplog = open_log(NULL);
+ /* if error, open_log sets fplog = stdout */
+ va_start( arglist, pattn );
+ vfprintf( fplog, pattn, arglist );
+ va_end( arglist );
+}
+
+/*
+ * logmsg
+ * This does an open/close if no log is already open, but does not set fplog.
+ */
+void logmsg( char *pname, char *pattn, ... )
+{
+ va_list arglist;
+ FILE *fp = NULL;
+ int opened = 0;
+
+ if (fplog == NULL) { /*no log alread open, open temp fp*/
+ fp = open_log(pname);
+ if (fp == NULL) return;
+ opened = 1;
+ } else fp = fplog;
+ va_start( arglist, pattn );
+ vfprintf( fp, pattn, arglist );
+ va_end( arglist );
+ if ((opened) && (fp != stderr)) /*opened temp fp, so close it*/
+ { fclose(fp); }
+}
+
+void dump_log(FILE *fp, char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ FILE *fpsav;
+ fpsav = fpdbg;
+ if (fplog != NULL) fpdbg = fplog;
+ if (fp != NULL) fpdbg = fp;
+ dump_buf(tag, pbuf, sz, fshowascii); /*uses fpdbg*/
+ fflush(fpdbg);
+ fpdbg = fpsav;
+}
+
+
+extern int lasterr; /*defined in ipmilan.c */
+extern void show_LastError(char *tag, int err); /*ipmilan.c */
+
+#ifdef WIN32
+/* Windows stdlib.h: extern int * __cdecl _errno(void); */
+int get_errno(void)
+{
+ return(errno);
+}
+#else
+extern int errno; /* Linux<errno.h has this also */
+int get_errno(void)
+{
+ return(errno);
+}
+#endif
+
+ /* For a list of all IANA enterprise mfg vendor numbers,
+ * see http://www.iana.org/assignments/enterprise-numbers
+ * Product numbers are different for each mfg vendor. */
+#define N_MFG 43
+static struct { int val; char *pstr; } mfgs[N_MFG] = {
+ {0, " "},
+ {0x0000BA, "Toshiba"},
+ {0x000074, "Hitachi"},
+ {0x00018F, "Hitachi"},
+ {0x000175, "Tatung"},
+ {0x000614, "Performance Technologies"},
+ {0x000F85, "Aelita Software"}, /*3973. HP DL140*/
+ {0x0028B2, "Avocent"},
+ {0x002B5E, "OSA"},
+ {0x0035AE, "Raritan"}, /*13742.*/
+ {0x0051EE, "AMI"},
+ { 94, "Nokia-Siemens"},
+ { 107, "Bull"},
+ { 4337, "Radisys"},
+ { 4542, "ASF"},
+ { 6569, "Inventec"},
+ { 7154, "IPMI forum"},
+ { 11129, "Google"},
+ { 12634, "PICMG"},
+ { 16394, "Pigeon Point"},
+ { 20569, "Inventec ESC"},
+ { 24673, "ServerEngines"},
+ { 27768, "NAT"},
+ {VENDOR_CISCO, "Cisco"}, /*=5771.*/
+ {VENDOR_IBM, "IBM"}, /*0x000002*/
+ {VENDOR_NEWISYS, "Newisys"}, /*=9237. */
+ {VENDOR_XYRATEX, "Xyratex"}, /*=1993. */
+ {VENDOR_QUANTA, "Quanta"}, /*=7244. */
+ {VENDOR_MAGNUM, "Magnum Technologies"}, /*=5593. */
+ {VENDOR_SUPERMICROX, "xSuperMicro"}, /* 47488. used by Winbond/SuperMicro*/
+ {VENDOR_HP, "HP"}, /* 0x00000B for HP */
+ {VENDOR_DELL, "Dell"}, /*0x0002A2*/
+ {VENDOR_KONTRON, "Kontron"}, /*=0x003A98, 15000.*/
+ {VENDOR_SUPERMICRO, "SuperMicro"}, /*=0x002A7C, 10876. used in AOC-SIMSO*/
+ {VENDOR_FUJITSU, "Fujitsu-Siemens"}, /* 0x002880, 10368. */
+ {VENDOR_PEPPERCON, "Peppercon"}, /* 0x0028C5, 10437. now w Raritan*/
+ {VENDOR_MICROSOFT, "Microsoft"}, /*=0x000137, 311.*/
+ {VENDOR_NEC, "NEC"}, /*=0x000077*/
+ {VENDOR_NSC, "NSC"}, /*=0x000322*/
+ {VENDOR_LMC, "LMC"}, /*=0x000878 with SuperMicro*/
+ {VENDOR_TYAN, "Tyan"}, /*=0x0019FD*/
+ {VENDOR_SUN, "Sun"}, /*=0x00002A*/
+ {VENDOR_INTEL, "Intel"} /*=0x000157*/
+};
+
+char * get_iana_str(int mfg)
+{
+ char *mfgstr = "";
+ int i;
+ for (i = 0; i < N_MFG; i++) {
+ if (mfgs[i].val == mfg) {
+ mfgstr = mfgs[i].pstr;
+ break;
+ }
+ }
+ if (i >= N_MFG) mfgstr = mfgs[0].pstr;
+ return(mfgstr);
+}
+
+/*
+ * str2uchar
+ * Convert string into unsigned char and check for overflows
+ * @str: (input) array of chars to parse from
+ * @uchr_ptr: (output) pointer to address where uint8_t will be stored
+ * returns 0 if successful, or -1,-2,-3 if error
+ */
+int str2uchar(char *str, uchar *uchr_ptr)
+{
+ ulong lval = 0;
+ char *end_ptr = NULL;
+ if (str == NULL || uchr_ptr == NULL) return -1; /*NULL pointer arg*/
+ *uchr_ptr = 0; /*seed with default result*/
+ errno = 0;
+ /* handle use of 08, 09 to avoid octal overflow */
+ if (strncmp(str,"08",2) == 0) lval = 8;
+ else if (strncmp(str,"09",2) == 0) lval = 9;
+ else { /*else do strtoul*/
+ lval = strtoul(str, &end_ptr, 0);
+ if ((end_ptr == NULL) || *end_ptr != '\0' || errno != 0)
+ return -2; /* invalid input given by user/overflow occurred */
+ if (lval > 0xFF || lval == LONG_MIN || lval == LONG_MAX)
+ return -3; /* Argument is too big to fit unsigned char */
+ }
+ *uchr_ptr = (uchar)lval;
+ return 0;
+}
+
+/* atob is like atoi, but using str2uchar */
+uchar atob(char *str_in)
+{
+ uchar b = 0;
+ int rv;
+ rv = str2uchar(str_in,&b);
+ /* if error, show error, but use default. */
+ switch (rv) {
+ case -1:
+ printf("atob error: input pointer is NULL\n");
+ break;
+ case -2:
+ printf("atob error: string-to-number conversion overflow\n");
+ break;
+ case -3:
+ printf("atob error: numeric argument is too big for one byte\n");
+ break;
+ default:
+ break;
+ }
+ return(b);
+}
+
+void atoip(uchar *array,char *instr)
+{
+ int i,j,n;
+ char *pi;
+ char tmpstr[16];
+ /* converts ASCII input string into binary IP Address (array) */
+ if (array == NULL || instr == NULL) {
+ if (fdebug) printf("atoip(%p,%p) NULL pointer error\n",array,instr);
+ return;
+ }
+ j = 0;
+ n = strlen_(instr);
+ n++; /*include the null char*/
+ if (n > sizeof(tmpstr)) n = sizeof(tmpstr);
+ memcpy(tmpstr,instr,n);
+ pi = tmpstr;
+ for (i = 0; i < n; i++) {
+ if (tmpstr[i] == '.') {
+ tmpstr[i] = 0;
+ array[j++] = atob(pi);
+ pi = &tmpstr[i+1];
+ }
+ else if (tmpstr[i] == 0) {
+ array[j++] = atob(pi);
+ }
+ }
+ if (fdebug)
+ printf("atoip: %d %d %d %d\n", array[0],array[1],array[2],array[3]);
+} /*end atoip()*/
+
+/*
+ * htoi
+ * Almost all of the utilities use this subroutine
+ * Input: a 2 character string of hex digits.
+ * Output: a hex byte.
+ */
+uchar htoi(char *inhex)
+{
+ // char rghex[16] = "0123456789ABCDEF";
+ uchar val;
+ uchar c;
+ if (inhex[1] == 0) { /* short string, one char */
+ c = inhex[0] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val = (c & 0x0f);
+ } else {
+ c = inhex[0] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val = (c & 0x0f) << 4;
+ c = inhex[1] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val += (c & 0x0f);
+ }
+ return(val);
+}
+
+
+void os_usleep(int s, int u)
+{
+#ifdef WIN32
+ if (s == 0) {
+ int i;
+ if (u >= 1000) Sleep(u/1000);
+ else for (i=0; i<u; i++) s = 0; /*spin for u loops*/
+ } else {
+ Sleep(s * 1000);
+ }
+#elif defined(DOS)
+ if (s == 0) delay(u);
+ else delay(s * 1000);
+#else
+ if (s == 0) {
+ usleep(u);
+ } else {
+ sleep(s);
+ }
+#endif
+}
+
+#define SYS_INFO_MAX 64
+
+static int sysinfo_has_len(uchar enc, int vendor)
+{
+ int rv = 1;
+ int vend;
+ if (enc > (uchar)2) return(0); /*encoding max is 2*/
+ if (vendor == 0) get_mfgid(&vend, NULL);
+ else vend = vendor;
+ if (vend == VENDOR_INTEL) rv = 0;
+ if (vend == VENDOR_SUPERMICRO) rv = 0;
+ return(rv);
+}
+
+int get_device_guid(char *pbuf, int *szbuf)
+{
+ int rv = -1;
+ //uchar idata[8];
+ uchar rdata[32];
+ int rlen, len;
+ uchar cc;
+ ushort cmdw;
+
+ len = *szbuf;
+ *szbuf = 0;
+ cmdw = 0x08 | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, NULL,0,rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ if (rlen > len) rlen = len;
+ memcpy(pbuf,rdata,rlen);
+ *szbuf = rlen;
+ }
+ return(rv);
+}
+
+int get_sysinfo(uchar parm, uchar set, uchar block, uchar *pbuf, int *szbuf)
+{
+ uchar idata[8];
+ uchar rdata[32];
+ int rlen, j, len;
+ int rv = -1;
+ uchar cc;
+ ushort cmdw;
+
+ if (pbuf == NULL || szbuf == NULL) return(rv);
+ len = 0;
+ idata[0] = 0;
+ idata[1] = parm;
+ idata[2] = set;
+ idata[3] = block;
+ rlen = sizeof(rdata);
+ cmdw = CMD_GET_SYSTEM_INFO | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, idata,4,rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ j = 2;
+ if (set == 0) { /*NEW_FMT: first set includes type, len */
+ if (sysinfo_has_len(rdata[2],0)) { /*but len not used if Intel*/
+ j = 4;
+ len = rdata[3];
+ }
+ }
+ rdata[rlen] = 0; /*stringify for debug below*/
+ rlen -= j;
+ if (fdebug) printf("get_sysinfo(%d,%d) j=%d len=%d %s\n",
+ parm,set,j,rlen,&rdata[j]);
+ if (rlen > *szbuf) rlen = *szbuf;
+ memcpy(pbuf,&rdata[j],rlen);
+ *szbuf = rlen;
+ }
+ return(rv);
+}
+
+int set_system_info(uchar parm, uchar *pbuf, int szbuf)
+{
+ uchar idata[32];
+ uchar rdata[8];
+ int rlen, ilen, i, j, n;
+ int rv = -1;
+ uchar cc, set;
+ ushort cmdw;
+
+ if (pbuf == NULL) return(rv);
+ if (szbuf > SYS_INFO_MAX) szbuf = SYS_INFO_MAX;
+ n = 0; set = 0;
+ while ((n < szbuf) || (n == 0)) {
+ ilen = 16;
+ j = 2;
+ memset(idata,0,sizeof(idata));
+ idata[0] = parm;
+ idata[1] = set;
+ if (set == 0) { /*NEW_FMT: first set includes type, len */
+ if (sysinfo_has_len(0,0)) { /*but len not used if Intel*/
+ j = 4;
+ idata[2] = 0; /*type = ASCII+Latin1*/
+ idata[3] = szbuf; /*overall length*/
+ }
+ }
+ i = ilen;
+ if (i > (szbuf - n)) i = (szbuf - n);
+ memcpy(&idata[j],&pbuf[n],i);
+ rlen = sizeof(rdata);
+ cmdw = CMD_SET_SYSTEM_INFO | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, idata,(ilen+j),rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (fdebug) printf("set_system_info(%d,%d) rv=%d j=%d ilen=%d %s\n",
+ parm,set,rv,j,ilen,&pbuf[n]);
+ if (rv != 0) break;
+ else {
+ n += ilen;
+ set++;
+ }
+ }
+ return(rv);
+}
+
+int get_system_info(uchar parm, char *pbuf, int *szbuf)
+{
+ int rv = -1;
+ int i, off, len, szchunk;
+
+ off = 0; len = *szbuf;
+ /* SYS_INFO_MAX = 64 (4 * 16) */
+ for (i = 0; i < 4; i++) {
+ szchunk = 16;
+ if ((off + szchunk) > *szbuf) break;
+ rv = get_sysinfo(parm,i,0,&pbuf[off],&szchunk);
+ if (rv != 0) break;
+ off += szchunk;
+ if (off >= len) break;
+ }
+ if (off < *szbuf) *szbuf = off;
+ return(rv);
+}
+
+int ipmi_reserved_user(int vend, int userid)
+{
+ int ret = 0;
+ if (userid == 1) {
+ switch(vend) {
+ case VENDOR_INTEL: ret = 0; break;
+ case VENDOR_KONTRON: ret = 1; break;
+ case VENDOR_SUPERMICRO: ret = 1; break;
+ case VENDOR_SUPERMICROX: ret = 1; break;
+ default: ret = 0; break;
+ }
+ }
+ return(ret);
+}
+
+#define NSEV 4
+static char *sev_str[NSEV] = {
+ /*0*/ "INF",
+ /*1*/ "MIN",
+ /*2*/ "MAJ",
+ /*3*/ "CRT" };
+
+uchar find_msg_sev(char *msg)
+{
+ int i;
+ char *p;
+ uchar sev = SEV_INFO;
+
+ if (msg == NULL) return(sev);
+ for (i = 0; i < NSEV; i++) {
+ p = strstr(msg,sev_str[i]);
+ if (p != NULL) { sev = (uchar)i; break; }
+ }
+ return(sev);
+}
+
+int OpenSyslog(char *tag)
+{
+ int ret = -1;
+ if (tag == NULL) tag = "ipmiutil";
+#ifdef WIN32
+ /* Requires showselmsg.dll and this Registry entry:
+ HKLM/SYSTEM/CurrentControlSet/Services/EventLog/Application/showsel
+ EventMessageFile REG_EXPAND_SZ "%SystemRoot%\system32\showselmsg.dll"
+ TypesSupported REG_DWORD 0x000000007
+ */
+ hLog = RegisterEventSource(NULL, "showsel");
+ if (hLog == (void *)ERROR_INVALID_HANDLE) { hLog = NULL; }
+ if (hLog == NULL)
+ printf("RegisterEventSource error, %lx\n", GetLastError());
+ else ret = 0; /*success*/
+#elif defined(DOS)
+ ret = LAN_ERR_NOTSUPPORT;
+#else
+ // Open syslog
+ openlog( tag, LOG_CONS, LOG_KERN);
+ ret = 0; /* success if here */
+#endif
+ return(ret);
+}
+
+void CloseSyslog(void)
+{
+#ifdef WIN32
+ DeregisterEventSource(hLog);
+#elif defined(DOS)
+ ;
+#else
+ // Close syslog
+ closelog();
+#endif
+}
+
+void WriteSyslog(char *msgbuf)
+{
+ uchar sev;
+#ifdef WIN32
+ BOOL status;
+ char *rgstrings[2] = {NULL, NULL};
+ WORD level;
+ rgstrings[0] = msgbuf; /*decoded SEL entry*/
+ sev = find_msg_sev(msgbuf);
+ switch(sev) {
+ case SEV_MIN: level = EVENTLOG_WARNING_TYPE; break;
+ case SEV_MAJ: level = EVENTLOG_ERROR_TYPE; break;
+ case SEV_CRIT: level = EVENTLOG_ERROR_TYPE; break;
+ case SEV_INFO:
+ default: level = EVENTLOG_INFORMATION_TYPE; break;
+ }
+ if (hLog != NULL) {
+ status = ReportEvent(hLog,EVENTLOG_INFORMATION_TYPE,
+ 0, SELMSG_ID, NULL, 1,0,
+ rgstrings,NULL);
+ /* showsel eventid = 0x101. */
+ if (fdebug || (status == 0)) { /*error or debug*/
+ printf("ReportEvent status=%d, %lx\n",
+ status,GetLastError());
+ }
+ }
+#elif defined(DOS)
+ ;
+#else
+ int level;
+ sev = find_msg_sev(msgbuf);
+ switch(sev) {
+ case SEV_MIN: level = LOG_WARNING; break;
+ case SEV_MAJ: level = LOG_ERR; break;
+ case SEV_CRIT: level = LOG_CRIT; break;
+ case SEV_INFO:
+ default: level = LOG_INFO; break;
+ }
+ syslog(level,"%s",msgbuf);
+#endif
+} /*end WriteSyslog*/
+
+int write_syslog(char *msg)
+{ /* not used in showsel, but used by getevent, hwreset */
+ int rv;
+ rv = OpenSyslog("ipmiutil");
+ if (rv == 0) {
+ WriteSyslog(msg);
+ CloseSyslog();
+ }
+ return(rv);
+}
+
+/* end subs.c */