# -*- coding: UTF-8 -*- #------------------------------------------------------------------------- # Name: ruijieutil # Purpose: common configuration and api # # Author: rd # # Created: 02/07/2018 # Copyright: (c) rd 2018 #------------------------------------------------------------------------- import sys import os import re import syslog import time import binascii import tty import termios import threading import click import mmap from sonic_py_common.general import getstatusoutput_noshell, getstatusoutput_noshell_pipe from ruijieconfig import rg_eeprom, FRULISTS, MAC_DEFAULT_PARAM, MAC_AVS_PARAM, FANS_DEF, \ FAN_PROTECT, E2_LOC, E2_PROTECT, RUIJIE_SERVICE_TAG, RUIJIE_DIAG_VERSION, \ STARTMODULE, RUIJIE_CARDID, RUIJIE_PRODUCTNAME, RUIJIE_PART_NUMBER, \ RUIJIE_LABEL_REVISION, RUIJIE_MAC_SIZE, RUIJIE_MANUF_NAME, RUIJIE_MANUF_COUNTRY, \ RUIJIE_VENDOR_NAME, MAILBOX_DIR try: from eepromutil.fru import ipmifru except Exception or SystemExit: pass import logging.handlers import shutil import gzip import glob __all__ = ["MENUID", "MENUPARENT", "MENUVALUE", "CHILDID", "MENUITEMNAME", "MENUITEMDEAL", "GOBACK", "GOQUIT", "file_name", "CRITICAL", "FATAL", "ERROR", "WARNING", "WARN", "INFO", "DEBUG", "NOTSET", "levelNames", "TLV_INFO_ID_STRING", "TLV_INFO_VERSION", "TLV_INFO_LENGTH", "TLV_INFO_LENGTH_VALUE", "TLV_CODE_PRODUCT_NAME", "TLV_CODE_PART_NUMBER", "TLV_CODE_SERIAL_NUMBER", "TLV_CODE_MAC_BASE", "TLV_CODE_MANUF_DATE", "TLV_CODE_DEVICE_VERSION", "TLV_CODE_LABEL_REVISION", "TLV_CODE_PLATFORM_NAME", "TLV_CODE_ONIE_VERSION", "TLV_CODE_MAC_SIZE", "TLV_CODE_MANUF_NAME", "TLV_CODE_MANUF_COUNTRY", "TLV_CODE_VENDOR_NAME", "TLV_CODE_DIAG_VERSION", "TLV_CODE_SERVICE_TAG", "TLV_CODE_VENDOR_EXT", "TLV_CODE_CRC_32", "_TLV_DISPLAY_VENDOR_EXT", "TLV_CODE_RJ_CARID", "_TLV_INFO_HDR_LEN", "SYSLOG_IDENTIFIER", "log_info", "log_debug", "log_warning", "log_error", "CompressedRotatingFileHandler", "SETMACException", "checkinput", "checkinputproduct", "getInputSetmac", "fan_tlv", "AVSUTIL", "I2CUTIL", "BMC", "getSdkReg", "getfilevalue", "get_sysfs_value", "write_sysfs_value", "RJPRINTERR", "strtoint", "inttostr", "str_to_hex", "hex_to_str", "str_to_bin", "bin_to_str", "getMacTemp", "getMacTemp_sysfs", "restartDockerService", "waitForDhcp", "waitForSdk", "waitForDocker", "getTLV_BODY", "_crc32", "printvalue", "generate_value", "getsyseeprombyId", "fac_init_cardidcheck", "isValidMac", "util_setmac", "getInputCheck", "getrawch", "upper_input", "changeTypeValue", "astrcmp", "generate_ext", "rji2cget", "rji2cset", "rjpcird", "rjpciwr", "rjsysset", "rji2cgetWord", "rji2csetWord", "fan_setmac", "checkfansninput", "checkfanhwinput", "util_show_fanse2", "get_fane2_sysfs", "util_show_fane2", "getPid", "fac_fans_setmac_tlv", "fac_fan_setmac_fru", "fac_fans_setmac", "fac_fan_setmac", "writeToEEprom", "get_local_eth0_mac", "getonieversion", "createbmcMac", "fac_board_setmac", "ipmi_set_mac", "getInputValue", "bmc_setmac", "closeProtocol", "checkSdkMem", "getch", "get_raw_input", "getsysvalue", "get_pmc_register", "decoder", "decode_eeprom", "get_sys_eeprom", "getCardId", "getsysmeminfo", "getsysmeminfo_detail", "getDmiSysByType", "gethwsys", "getsysbios", "searchDirByName", "getUsbLocation", "getusbinfo", "get_cpu_info", "get_version_config_info", "io_rd", "io_wr"] MENUID = "menuid" MENUPARENT = "parentid" MENUVALUE = "value" CHILDID = "childid" MENUITEMNAME = "name" MENUITEMDEAL = "deal" GOBACK = "goBack" GOQUIT = "quit" file_name = "/etc/init.d/opennsl-modules-3.16.0-5-amd64" ########################################################################## # ERROR LOG LEVEL ########################################################################## CRITICAL = 50 FATAL = CRITICAL ERROR = 40 WARNING = 30 WARN = WARNING INFO = 20 DEBUG = 10 NOTSET = 0 levelNames = { CRITICAL: 'CRITICAL', ERROR: 'ERROR', WARNING: 'WARNING', INFO: 'INFO', DEBUG: 'DEBUG', NOTSET: 'NOTSET', 'CRITICAL': CRITICAL, 'ERROR': ERROR, 'WARN': WARNING, 'WARNING': WARNING, 'INFO': INFO, 'DEBUG': DEBUG, 'NOTSET': NOTSET, } TLV_INFO_ID_STRING = "TlvInfo\x00" TLV_INFO_VERSION = 0x01 TLV_INFO_LENGTH = 0x00 TLV_INFO_LENGTH_VALUE = 0xba ########################################################################## # eeprom info ########################################################################## TLV_CODE_PRODUCT_NAME = 0x21 TLV_CODE_PART_NUMBER = 0x22 TLV_CODE_SERIAL_NUMBER = 0x23 TLV_CODE_MAC_BASE = 0x24 TLV_CODE_MANUF_DATE = 0x25 TLV_CODE_DEVICE_VERSION = 0x26 TLV_CODE_LABEL_REVISION = 0x27 TLV_CODE_PLATFORM_NAME = 0x28 TLV_CODE_ONIE_VERSION = 0x29 TLV_CODE_MAC_SIZE = 0x2A TLV_CODE_MANUF_NAME = 0x2B TLV_CODE_MANUF_COUNTRY = 0x2C TLV_CODE_VENDOR_NAME = 0x2D TLV_CODE_DIAG_VERSION = 0x2E TLV_CODE_SERVICE_TAG = 0x2F TLV_CODE_VENDOR_EXT = 0xFD TLV_CODE_CRC_32 = 0xFE _TLV_DISPLAY_VENDOR_EXT = 1 TLV_CODE_RJ_CARID = 0x01 _TLV_INFO_HDR_LEN = 11 SYSLOG_IDENTIFIER = "UTILTOOL" # ========================== Syslog wrappers ========================== def log_info(msg, also_print_to_console=False): syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_INFO, msg) syslog.closelog() if also_print_to_console: click.echo(msg) def log_debug(msg, also_print_to_console=False): try: syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_DEBUG, msg) syslog.closelog() if also_print_to_console: click.echo(msg) except Exception as e: pass def log_warning(msg, also_print_to_console=False): syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_WARNING, msg) syslog.closelog() if also_print_to_console: click.echo(msg) def log_error(msg, also_print_to_console=False): syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_ERR, msg) syslog.closelog() if also_print_to_console: click.echo(msg) class CompressedRotatingFileHandler(logging.handlers.RotatingFileHandler): def doRollover(self): """ Do a rollover, as described in __init__(). """ if self.stream: self.stream.close() self.stream = None if self.backupCount > 0: for i in range(self.backupCount - 1, 0, -1): sfn = "%s.%d.gz" % (self.baseFilename, i) dfn = "%s.%d.gz" % (self.baseFilename, i + 1) if os.path.exists(sfn): if os.path.exists(dfn): os.remove(dfn) os.rename(sfn, dfn) dfn = self.baseFilename + ".1.gz" if os.path.exists(dfn): os.remove(dfn) # These two lines below are the only new lines. I commented out the os.rename(self.baseFilename, dfn) and # replaced it with these two lines. with open(self.baseFilename, 'rb') as f_in, gzip.open(dfn, 'wb') as f_out: shutil.copyfileobj(f_in, f_out) self.mode = 'w' self.stream = self._open() class SETMACException(Exception): def __init__(self, param='ERROR', errno="-1"): err = "Setmac fail[%s]: %s" % (errno, param) Exception.__init__(self, err) self.param = param self.errno = errno def checkinput(b): if b.isdigit() == False: raise Exception("Ivalid Number") if int(b) > 0xff or int(b) < 0: raise Exception("Out of area") def checkinputproduct(b): if b.isalnum() ==False: raise Exception("Invalid string") def getInputSetmac(val): bia = val.boardInfoArea pia = val.productInfoArea if bia != None: a = raw_input("[Board Card]Product Serial Number:") if len(a) != 13: raise Exception("Invalid Serial Number length") checkinputproduct(a) bia.boardSerialNumber = a b = raw_input("[Board Card]Product Version:(from 1-255)") checkinput(b) b = "%0x" % int(b) bia.boardextra1 = b.upper() if pia != None: a = raw_input("[Product Area]Product Serial Number:") if len(a) != 13: raise Exception("Invalid Serial Number") checkinputproduct(a) pia.productSerialNumber = a b = raw_input("[Product Area]Product Version:(from 1-255)") checkinput(b) b = "%0x" % int(b) pia.productVersion = b.upper() return val class fan_tlv(object): VERSION = 0x01 # E2PROM Version，start from 0x01 FLAG = 0x7E # New E2PROM version flag is 0x7E HW_VER = 0X01 # compose by master version and fixed version TYPE = 0xf1 # hw type defination TLV_LEN = 00 # data length (16bit) _FAN_TLV_HDR_LEN = 6 _FAN_TLV_CRC_LEN = 2 _FAN_TLV_TYPE_NAME = 0x02 _FAN_TLV_TYPE_SN = 0x03 _FAN_TLV_TYPE_HW_INFO = 0x05 _FAN_TLV_TYPE_DEV_TYPE = 0x06 _fandecodetime = 0 @property def dstatus(self): return self._dstatus @property def typename(self): return self._typename @property def typesn(self): return self._typesn @property def typehwinfo(self): return self._typehwinfo @property def typedevtype(self): return self._typedevtype @property def fanbus(self): return self._fanbus @property def fanloc(self): return self._fanloc @property def fandecodetime(self): return self._fandecodetime def __init__(self): self._typename = "" self._typesn = "" self._typehwinfo = "" self._typedevtype = "" self._dstatus = 0 def strtoarr(self, str): s = [] if str is not None: for index in range(len(str)): s.append(str[index]) return s def generate_fan_value(self): bin_buffer = [chr(0xff)] * 256 bin_buffer[0] = chr(self.VERSION) bin_buffer[1] = chr(self.FLAG) bin_buffer[2] = chr(self.HW_VER) bin_buffer[3] = chr(self.TYPE) temp_t = "%08x" % self.typedevtype # handle devtype first typedevtype_t = hex_to_str(temp_t) total_len = len(self.typename) + len(self.typesn) + \ len(self.typehwinfo) + len(typedevtype_t) + 8 bin_buffer[4] = chr(total_len >> 8) bin_buffer[5] = chr(total_len & 0x00FF) index_start = 6 bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_NAME) bin_buffer[index_start + 1] = chr(len(self.typename)) bin_buffer[index_start + 2: index_start + 2 + len(self.typename)] = self.strtoarr(self.typename) index_start = index_start + 2 + len(self.typename) bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_SN) bin_buffer[index_start + 1] = chr(len(self.typesn)) bin_buffer[index_start + 2:index_start + 2 + len(self.typesn)] = self.strtoarr(self.typesn) index_start = index_start + 2 + len(self.typesn) bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_HW_INFO) bin_buffer[index_start + 1] = chr(len(self.typehwinfo)) bin_buffer[index_start + 2:index_start + 2 + len(self.typehwinfo)] = self.strtoarr(self.typehwinfo) index_start = index_start + 2 + len(self.typehwinfo) bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_DEV_TYPE) bin_buffer[index_start + 1] = chr(len(typedevtype_t)) bin_buffer[index_start + 2:index_start + 2 + len(typedevtype_t)] = self.strtoarr(typedevtype_t) index_start = index_start + 2 + len(typedevtype_t) crcs = fan_tlv.fancrc(''.join(bin_buffer[0:index_start])) # check 2bytes bin_buffer[index_start] = chr(crcs >> 8) bin_buffer[index_start + 1] = chr(crcs & 0x00ff) return bin_buffer def decode(self, e2): ret = [] self.VERSION = ord(e2[0]) self.FLAG = ord(e2[1]) self.HW_VER = ord(e2[2]) self.TYPE = ord(e2[3]) self.TLV_LEN = (ord(e2[4]) << 8) | ord(e2[5]) tlv_index = self._FAN_TLV_HDR_LEN tlv_end = self._FAN_TLV_HDR_LEN + self.TLV_LEN # check checksum if len(e2) < self._FAN_TLV_HDR_LEN + self.TLV_LEN + 2: self._dstatus = -2 return ret sumcrc = fan_tlv.fancrc(e2[0:self._FAN_TLV_HDR_LEN + self.TLV_LEN]) readcrc = ord(e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN] ) << 8 | ord(e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN + 1]) if sumcrc != readcrc: self._dstatus = -1 return ret else: self._dstatus = 0 while (tlv_index + 2) < len(e2) and tlv_index < tlv_end: s = self.decoder( e2[tlv_index:tlv_index + 2 + ord(e2[tlv_index + 1])]) tlv_index += ord(e2[tlv_index + 1]) + 2 ret.append(s) return ret @staticmethod def fancrc(t): sum = 0 for index in range(len(t)): sum += ord(t[index]) return sum def decoder(self, t): try: name = "" value = "" if ord(t[0]) == self._FAN_TLV_TYPE_NAME: name = "Product Name" value = str(t[2:2 + ord(t[1])]) self._typename = value elif ord(t[0]) == self._FAN_TLV_TYPE_SN: name = "serial Number" value = str(t[2:2 + ord(t[1])]) self._typesn = value elif ord(t[0]) == self._FAN_TLV_TYPE_HW_INFO: name = "hardware info" value = str(t[2:2 + ord(t[1])]) self._typehwinfo = value elif ord(t[0]) == self._FAN_TLV_TYPE_DEV_TYPE: name = "dev type" value = str(t[2:2 + ord(t[1])]) value = str_to_hex(value) self._typedevtype = value value = "0x08%x" % value except Exception as e: print(e) return {"name": name, "code": ord(t[0]), "value": value} def __str__(self): formatstr = "VERSION : 0x%02x \n" \ " FLAG : 0x%02x \n" \ " HW_VER : 0x%02x \n" \ " TYPE : 0x%02x \n" \ "typename : %s \n" \ "typesn : %s \n" \ "typehwinfo : %s \n" return formatstr % (self.VERSION, self.FLAG, self.HW_VER, self.TYPE, self.typename, self.typesn, self.typehwinfo) class AVSUTIL(): @staticmethod def mac_avs_chip(bus, devno, loc, open, close, loop, protectaddr, level, loopaddr): # disable protection rji2cset(bus, devno, protectaddr, open) rji2cset(bus, devno, loopaddr, loop) rji2csetWord(bus, devno, loc, level) ret, value = rji2cgetWord(bus, devno, loc) if strtoint(value) == level: ret = 0 # enable protection rji2cset(bus, devno, protectaddr, close) if ret == 0: return True return False @staticmethod def macPressure_adj(macavs, avs_param, mac_def_param): # check whether it within range max_adj = max(avs_param.keys()) min_adj = min(avs_param.keys()) type = mac_def_param["type"] level = 0 if type == 0: if macavs not in range(min_adj, max_adj + 1): return False else: level = macavs else: if macavs not in range(min_adj, max_adj + 1): level = mac_def_param["default"] else: level = macavs ret = AVSUTIL.mac_avs_chip(mac_def_param["bus"], mac_def_param["devno"], mac_def_param["addr"], mac_def_param["open"], mac_def_param["close"], mac_def_param["loop"], mac_def_param["protectaddr"], avs_param[level], mac_def_param["loopaddr"]) return ret @staticmethod def mac_adj(): macavs = 0 name = MAC_DEFAULT_PARAM["sdkreg"] ret, status = getSdkReg(name) if ret == False: return False status = strtoint(status) # shift operation if MAC_DEFAULT_PARAM["sdktype"] != 0: status = ( status >> MAC_DEFAULT_PARAM["macregloc"]) & MAC_DEFAULT_PARAM["mask"] macavs = status ret = AVSUTIL.macPressure_adj(macavs, MAC_AVS_PARAM, MAC_DEFAULT_PARAM) return ret class I2CUTIL(): @staticmethod def getvaluefromdevice(name): ret = [] for item in DEVICE: if item["name"] == name: ret.append(item) return ret @staticmethod def openFanE2Protect(): rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"], FAN_PROTECT["addr"], FAN_PROTECT["open"]) @staticmethod def closeFanE2Protect(): rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"], FAN_PROTECT["addr"], FAN_PROTECT["close"]) @staticmethod def writeToFanE2(bus, loc, rst_arr): index = 0 for item in rst_arr: rji2cset(bus, loc, index, ord(item)) index += 1 @staticmethod def writeToE2(bus, loc, rst_arr): index = 0 for item in rst_arr: rji2cset(bus, loc, index, ord(item)) index += 1 @staticmethod def getE2File(bus, loc): return "/sys/bus/i2c/devices/%d-00%02x/eeprom" % (bus, loc) class BMC(): _instance_lock = threading.Lock() def __init__(self): pass def __new__(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = object.__new__(cls) return Singleton._instance # Internal interface def getSdkReg(reg): try: cmd = ["bcmcmd", "-t", "1", "getr"+str(reg)] ret, result = getstatusoutput_noshell(cmd) result_t = result.strip().replace("\r", "").replace("\n", "") if ret != 0 or "Error:" in result_t: return False, result patt = r"%s.(.*):(.*)>drivshell" % reg rt = re.findall(patt, result_t, re.S) test = re.findall("=(.*)", rt[0][0])[0] except Exception as e: return False, 'getsdk register error' return True, test def getfilevalue(location): try: with open(location, 'r') as fd: value = fd.read() return True, value.strip() except Exception as e: return False, "error" def get_sysfs_value(location): pos_t = str(location) name = get_pmc_register(pos_t) return name def write_sysfs_value(reg_name, value): fileLoc = MAILBOX_DIR + reg_name try: if not os.path.isfile(fileLoc): print(fileLoc, 'not found !') return False with open(fileLoc, 'w') as fd: fd.write(value) except Exception as error: log_error("Unable to open " + fileLoc + "file !") return False return True def RJPRINTERR(str): print("\033[0;31m%s\033[0m" % str) def strtoint(str): # convert Hex string to int such as "4040"/"0x4040"/"0X4040" = 16448 value = 0 rest_v = str.replace("0X", "").replace("0x", "") for index in range(len(rest_v)): print(rest_v[index]) value |= int(rest_v[index], 16) << ((len(rest_v) - index - 1) * 4) return value def inttostr(vl,len): # convert int to string such as 0x3030 = 00 if type(vl) != int: raise Exception(" type error") index = 0 ret_t = "" while index < len: ret = 0xff & (vl >> index * 8) ret_t += chr(ret) index += 1; return ret_t def str_to_hex(rest_v): value = 0 for index in range(len(rest_v)): value |= ord(rest_v[index]) << ((len(rest_v) - index - 1) * 8) return value def hex_to_str(s): len_t = len(s) if len_t % 2 != 0: return 0 ret = "" for t in range(0, int(len_t / 2)): ret += chr(int(s[2 * t:2 * t + 2], 16)) return ret def str_to_bin(s): return ' '.join([bin(ord(c)).replace('0b', '') for c in s]) def bin_to_str(s): return ''.join([chr(i) for i in [int(b, 2) for b in s.split(' ')]]) def getMacTemp(): result = {} #waitForDocker() # exec twice, get the second result getstatusoutput_noshell(["bcmcmd", "-t", "1", "show temp"]) ret, log = getstatusoutput_noshell(["bcmcmd", "-t", "1", "show temp"]) if ret: return False, result else: # decode obtained info logs = log.splitlines() for line in logs: if "average" in line: b = re.findall(r'\d+.\d+', line) result["average"] = b[0] elif "maximum" in line: b = re.findall(r'\d+.\d+', line) result["maximum"] = b[0] return True, result def getMacTemp_sysfs(mactempconf): try: temp = -1000000 temp_list = [] mac_temp_loc = mactempconf.get("loc", []) mac_temp_flag = mactempconf.get("flag",None) if mac_temp_flag is not None: # check mac temperature vaild flag gettype = mac_temp_flag.get('gettype') okbit = mac_temp_flag.get('okbit') okval = mac_temp_flag.get('okval') if gettype == "io": io_addr = mac_temp_flag.get('io_addr') val = io_rd(io_addr) if val is None: raise Exception("get mac_flag by io failed.") else: bus = mac_temp_flag.get('bus') loc = mac_temp_flag.get('loc') offset = mac_temp_flag.get('offset') ind, val = rji2cget(bus, loc, offset) if ind is not True: raise Exception("get mac_flag by i2c failed.") val_t = (int(val,16) & (1<< okbit)) >> okbit if val_t != okval: raise Exception("mac_flag invalid, val_t:%d." % val_t) for loc in mac_temp_loc: temp_s = get_sysfs_value(loc) if isinstance(temp_s, str) and temp_s.startswith("ERR"): raise Exception("get mac temp error. loc:%s" % loc) temp_t = int(temp_s) if temp_t == -1000000: raise Exception("mac temp invalid.loc:%s" % loc) temp_list.append(temp_t) temp_list.sort(reverse=True) temp = temp_list[0] except Exception as e: return False, temp return True, temp def restartDockerService(force=False): container_name = ["database","snmp","syncd","swss","dhcp_relay","radv","teamd","pmon"] ret, status = getstatusoutput_noshell(["docker", "ps"]) if ret == 0 : for tmpname in container_name: if (tmpname not in status): if (force == True): getstatusoutput_noshell(["docker", "restart", tmpname]) else: getstatusoutput_noshell(["systemctl", "restart", tmpname]) def waitForDhcp(timeout): time_cnt = 0 while True: try: ret, status = getstatusoutput_noshell(["systemctl", "status", "dhcp_relay.service"]) if (ret == 0 and "running" in status) or "SUCCESS" in status: break else: sys.stdout.write(".") sys.stdout.flush() time_cnt = time_cnt + 1 if time_cnt > timeout: raise Exception("waitForDhcp timeout") time.sleep(1) except Exception as e: return False return True def waitForSdk(sdk_fpath ,timeout): time_cnt = 0 while True: try: if os.path.exists(sdk_fpath): break else: sys.stdout.write(".") sys.stdout.flush() time_cnt = time_cnt + 1 if time_cnt > timeout: raise Exception("waitForSdk timeout") time.sleep(1) except Exception as e: return False return True def waitForDocker(need_restart=False,timeout=180): sdkcheck_params = STARTMODULE.get("sdkcheck",{}) if sdkcheck_params.get("checktype") == "file": # pass file check sdk_fpath = sdkcheck_params.get("sdk_fpath") return waitForSdk(sdk_fpath,timeout) return waitForDhcp(timeout) def getTLV_BODY(type, productname): x = [] temp_t = "" if type == TLV_CODE_MAC_BASE: arr = productname.split(':') for tt in arr: temp_t += chr(int(tt, 16)) elif type == TLV_CODE_DEVICE_VERSION: temp_t = chr(productname) elif type == TLV_CODE_MAC_SIZE: temp_t = chr(productname >> 8) + chr(productname & 0x00ff) else: temp_t = productname x.append(chr(type)) x.append(chr(len(temp_t))) for i in temp_t: x.append(i) return x def _crc32(v): return '0x%08x' % (binascii.crc32(v) & 0xffffffff) # get 8 bytes of crc32 %x return hex def printvalue(b): index = 0 for i in range(0, len(b)): if index % 16 == 0: print(" ") print("%02x " % ord(b[i])) index += 1 print("\n") def generate_value(_t): ret = [] for i in TLV_INFO_ID_STRING: ret.append(i) ret.append(chr(TLV_INFO_VERSION)) ret.append(chr(TLV_INFO_LENGTH)) ret.append(chr(TLV_INFO_LENGTH_VALUE)) total_len = 0 for key in _t: x = getTLV_BODY(key, _t[key]) ret += x total_len += len(x) ret[10] = chr(total_len + 6) ret.append(chr(0xFE)) ret.append(chr(0x04)) s = _crc32(''.join(ret)) for t in range(0, 4): ret.append(chr(int(s[2 * t + 2:2 * t + 4], 16))) totallen = len(ret) if (totallen < 256): for left_t in range(0, 256 - totallen): ret.append(chr(0x00)) return (ret, True) def getsyseeprombyId(id): ret = get_sys_eeprom() for item in ret: if item["code"] == id: return item return None def fac_init_cardidcheck(): rest = getsyseeprombyId(TLV_CODE_RJ_CARID) # check cardId same or not if rest is None: print("need to program write bin file") return False else: rest_v = rest['value'] value = strtoint(rest_v) if value == RUIJIE_CARDID: log_debug("check card ID pass") else: log_debug("check card ID error") return False return True def isValidMac(mac): if re.match(r"^\s*([0-9a-fA-F]{2,2}:){5,5}[0-9a-fA-F]{2,2}\s*$", mac): return True return False # Internet cardsetmac def util_setmac(eth, mac): rulefile = "/etc/udev/rules.d/70-persistent-net.rules" if isValidMac(mac) == False: return False, "MAC invaild" cmd1 = ["ethtool", "-e", eth] cmd2 = ["grep", "0x0010"] cmd3 = ["awk", '{print \"0x\"$13$12$15$14}'] ret, log = getstatusoutput_noshell_pipe(cmd1, cmd2, cmd3) log_debug(log) magic = "" if ret == 0 and len(log): magic = log macs = mac.upper().split(":") # chage ETH0 to value after setmac ifconfigcmd = ["ifconfig", "eth0", "hw", "ether", mac] log_debug(' '.join(ifconfigcmd)) ret, status = getstatusoutput_noshell(ifconfigcmd) if ret: raise SETMACException("software set Internet cardMAC error") index = 0 for item in macs: cmd = ["ethtool", "-E", eht, "magic", magic, "offset", str(index), "value", "0x"+item] log_debug(cmd) index += 1 ret, log = getstatusoutput_noshell(cmd) if ret != 0: raise SETMACException(" set hardware Internet card MAC error") # get value after setting cmd_t = ["ethtool", "-e", "eth0", "offset", "0", "length", "6"] ret, log = getstatusoutput_noshell(cmd_t) m = re.split(':', log)[-1].strip().upper() mac_result = m.upper().split(" ") for ind, s in enumerate(macs): if s != mac_result[ind]: RJPRINTERR("MAC comparison error") if os.path.exists(rulefile): os.remove(rulefile) print("MGMT MAC[%s]" % mac) return True def getInputCheck(tips): str = raw_input(tips) if astrcmp(str, "y") or astrcmp(str, "ye") or astrcmp(str, "yes") or astrcmp(str, ""): return True else: return False def getrawch(): fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch def upper_input(tips): sys.stdout.write(tips) sys.stdout.flush() passwd = [] while True: ch = getrawch().upper() if ch == "\r" or ch == "\n": return "".join(passwd) elif ch == '\b' or ord(ch) == 127: if passwd: del passwd[-1] sys.stdout.write('\b \b') else: sys.stdout.write(ch) passwd.append(ch) def changeTypeValue(_value, type1, tips, example): if type1 == TLV_CODE_PRODUCT_NAME: while True: print("please check (1)air from forward to backward/(2)air from backward to forward:") option = raw_input() if option == "1": _value[type1] = example + "-F-RJ" print("check Product is air from forward to backward device,Product Name:%s"%_value[type1]) break elif option == "2": _value[type1] = example + "-R-RJ" print("check Product is air from backward to forward device,Product Name:%s"%_value[type1]) break else: print("input incorrect, check please") return True print("Please input[%s]such as(%s):" % (tips, example)) name = upper_input("") if type1 == TLV_CODE_MAC_BASE: if len(name) != 12: raise SETMACException("MAC address length incorrect, check please") release_mac = "" for i in range(int(len(name) / 2)): if i == 0: release_mac += name[i * 2:i * 2 + 2] else: release_mac += ":" + name[i * 2:i * 2 + 2] if isValidMac(release_mac) == True: _value[type1] = release_mac else: raise SETMACException("MAC address invaild, check please") elif type1 == TLV_CODE_DEVICE_VERSION: if name.isdigit(): _value[type1] = int(name) else: raise SETMACException("Version is not number, check please") elif type1 == TLV_CODE_MAC_SIZE: if name.isdigit(): _value[type1] = int(name, 16) else: raise SETMACException("Version is not number, check please") elif type1 == TLV_CODE_SERIAL_NUMBER: if name.isalnum() == False: raise SETMACException("Serial Number invaild string, check please") elif len(name) != 13: raise SETMACException("Serial Number length incorrect, check please") else: _value[type1] = name elif type1 == TLV_CODE_VENDOR_EXT: _value[type1] = name else: _value[type1] = name return True def astrcmp(str1, str2): return str1.lower() == str2.lower() def generate_ext(cardid): s = "%08x" % cardid ret = "" for t in range(0, 4): ret += chr(int(s[2 * t:2 * t + 2], 16)) ret = chr(0x01) + chr(len(ret)) + ret return ret def rji2cget(bus, devno, address): command_line = ["i2cget", "-f", "-y", str(bus), "0x%02x"%str(devno), "0x%02x"%str(address)] retrytime = 6 ret_t = "" for i in range(retrytime): ret, ret_t = getstatusoutput_noshell(command_line) if ret == 0: return True, ret_t time.sleep(0.1) return False, ret_t def rji2cset(bus, devno, address, byte): command_line = ["i2cset", "-f", "-y", str(bus), "0x%02x"%str(devno), "0x%02x"%str(address), "0x%02x"%str(byte)] retrytime = 6 ret_t = "" for i in range(retrytime): ret, ret_t = getstatusoutput_noshell(command_line) if ret == 0: return True, ret_t return False, ret_t def rjpcird(pcibus , slot , fn, bar, offset): '''read pci register''' if offset % 4 != 0: return filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (int(pcibus), int(slot), int(fn), int(bar)) file = open(filename, "r+") size = os.path.getsize(filename) data = mmap.mmap(file.fileno(), size) result = data[offset: offset + 4] s = result[::-1] val = 0 for i in range(0, len(s)): val = val << 8 | ord(s[i]) return "0x%08x" % val def rjpciwr(pcibus , slot ,fn, bar, offset, data): '''write pci register''' ret = inttostr(data, 4) filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (int(pcibus), int(slot), int(fn), int(bar)) file = open(filename, "r+") size = os.path.getsize(filename) data = mmap.mmap(file.fileno(), size) data[offset: offset + 4] = ret result = data[offset: offset + 4] s = result[::-1] val = 0 for i in range(0, len(s)): val = val << 8 | ord(s[i]) data.close() def rjsysset(location, value): retrytime = 6 for i in range(retrytime): try: with open(location, 'w') as f: f.write('0x%02x\n'%value) except (IOError, FileNotFoundError) as e: return False, str(e) return True, '' def rji2cgetWord(bus, devno, address): command_line = ["i2cget", "-f", "-y", str(bus), "0x%02x"%str(devno), "0x%02x"%str(address), "w"] retrytime = 3 ret_t = "" for i in range(retrytime): ret, ret_t = getstatusoutput_noshell(command_line) if ret == 0: return True, ret_t return False, ret_t def rji2csetWord(bus, devno, address, byte): command_line = ["i2cset", "-f", "-y", str(bus), "0x%02x"%str(devno), "0x%02x"%str(address), "0x%x"%str(byte), "w"] getstatusoutput_noshell(command_line) def fan_setmac(): rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"], FAN_PROTECT["addr"], FAN_PROTECT["open"]) rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"], FAN_PROTECT["addr"], FAN_PROTECT["close"]) def checkfansninput(fan_sn, fansntemp): if fan_sn in fansntemp: RJPRINTERR("exist same Serial Number，please input again") return False if(len(fan_sn) != 13): RJPRINTERR("Serial Number length incorrect，please input again") return False return True # check 输入的hardware version def checkfanhwinput(hw): if len(hw) != 4: RJPRINTERR("hardware version length incorrect, please input again") return False if hw.find(".") != 1: RJPRINTERR("hardware version incorrect, please input again") return False return True def util_show_fanse2(fans): formatstr = "%-8s %-20s %-20s %-20s %-20s" print(formatstr % ("id", "Name", "hardware version", "Serial Number", "Time")) print(formatstr % ("------", "---------------", "---------------", "---------------", "----")) for fan in fans: # print fan.dstatus if fan.dstatus < 0: print("%-8s" % ("FAN%d" % (fans.index(fan) + 1))) RJPRINTERR(" decode e2 error") else: print(formatstr % ("FAN%d" % (fans.index(fan) + 1), fan.typename.replace(chr(0x00), ""), fan.typehwinfo.replace(chr(0x00), ""), fan.typesn.replace(chr(0x00), ""), fan.fandecodetime)) def get_fane2_sysfs(bus, loc): rg_fan_e2 = "%d-%04x/fan" % (bus, loc) eeprom = get_sysfs_value(rg_fan_e2) return eeprom def util_show_fane2(): ret = sorted(I2CUTIL.getvaluefromdevice("rg_fan")) if len(ret) <=0: return None fans = [] for index in range(len(ret)): t1 = (int(round(time.time() * 1000))) eeprom = get_fane2_sysfs(ret[index]["bus"], ret[index]["loc"]) t2 = (int(round(time.time() * 1000))) fane2 = fan_tlv() fane2.fandecodetime = t2 - t1 fane2.decode(eeprom) fans.append(fane2) util_show_fanse2(fans) def getPid(name): ret = [] for dirname in os.listdir('/proc'): if dirname == 'curproc': continue try: with open('/proc/{}/cmdline'.format(dirname), mode='rb') as fd: content = fd.read() except Exception: continue if name in content: ret.append(dirname) return ret def fac_fans_setmac_tlv(ret): if len(ret) <=0: return None fans = [] fansntemp = [] for index in range(len(ret)): item = ret[index] log_debug(item) eeprom = get_fane2_sysfs(item["bus"], item["loc"]) fane2 = fan_tlv() fane2.decode(eeprom) fane2.fanbus = item["bus"] fane2.fanloc = item["loc"] log_debug("decode eeprom success") print("Fan[%d]-[%s]setmac" % ((index + 1), FANS_DEF[fane2.typedevtype])) while True: print("Please input[%s]:" % "Serial Number") fan_sn = raw_input() if checkfansninput(fan_sn, fansntemp) == False: continue fansntemp.append(fan_sn) fan_sn = fan_sn + chr(0x00) fane2.typesn = fan_sn + chr(0x00) break while True: print("Please input[%s]:" % "hardware version") hwinfo = raw_input() if checkfanhwinput(hwinfo) == False: continue fan_hwinfo = hwinfo + chr(0x00) fane2.typehwinfo = fan_hwinfo + chr(0x00) break log_debug(fane2.typedevtype) fane2.typename = FANS_DEF[fane2.typedevtype] + chr(0x00) fans.append(fane2) print("\n") print("\n*******************************\n") util_show_fanse2(fans) if getInputCheck("check input correctly or not（Yes/No):") == True: for fan in fans: log_debug("ouput fan") fac_fan_setmac(fan) else: print("setmac quit") return False def fac_fan_setmac_fru(ret): fans = FRULISTS.get('fans') fanfrus = {} newfrus = {} #getmsg try: for fan in fans: print("===============%s ================getmessage" % fan.get('name')) eeprom = getsysvalue(I2CUTIL.getE2File(fan.get('bus'), fan.get('loc'))) fru = ipmifru() fru.decodeBin(eeprom) fanfrus[fan.get('name')] = fru except Exception as e: print(str(e)) return False #setmsg for fan in fans: print("===============%s ================setmac" % fan.get('name')) fruold = fanfrus.get(fan.get('name')) newfru = getInputSetmac(fruold) newfru.recalcute() newfrus[fan.get('name')] = newfru #writemsg for fan in fans: print("===============%s ================writeToE2" % fan.get('name')) ret_t = newfrus.get(fan.get('name')) I2CUTIL.openFanE2Protect() I2CUTIL.writeToFanE2(fan.get('bus'), fan.get('loc'), ret_t.bindata) I2CUTIL.closeFanE2Protect() #check try: for fan in fans: print("===============%s ================getmessage" % fan.get('name')) eeprom = getsysvalue(I2CUTIL.getE2File(fan.get('bus'), fan.get('loc'))) fru = ipmifru() fru.decodeBin(eeprom) except Exception as e: print(str(e)) return False return True def fac_fans_setmac(): ret = I2CUTIL.getvaluefromdevice("rg_fan") if ret is not None and len(ret) > 0: return fac_fans_setmac_tlv(ret) fans = FRULISTS.get('fans', None) if fans is not None and len(fans)>0: return fac_fan_setmac_fru(ret) return False def fac_fan_setmac(item): I2CUTIL.openFanE2Protect() I2CUTIL.writeToFanE2(item.fanbus, item.fanloc, item.generate_fan_value()) I2CUTIL.closeFanE2Protect() def writeToEEprom(rst_arr): dealtype = E2_PROTECT.get('gettype',None) if dealtype is None: rji2cset(E2_PROTECT["bus"], E2_PROTECT["devno"], E2_PROTECT["addr"], E2_PROTECT["open"]) elif dealtype == "io": io_wr(E2_PROTECT["io_addr"], E2_PROTECT["open"]) index = 0 for item in rst_arr: rji2cset(E2_LOC["bus"], E2_LOC["devno"], index, ord(item)) index += 1 if dealtype is None: rji2cset(E2_PROTECT["bus"], E2_PROTECT["devno"], E2_PROTECT["addr"], E2_PROTECT["close"]) elif dealtype == "io": io_wr(E2_PROTECT["io_addr"], E2_PROTECT["close"]) # deal last drivers getstatusoutput_noshell(["rmmod", "at24"]) getstatusoutput_noshell(["modprobe", "at24"]) getstatusoutput_noshell(["rm", "-f", "/var/cache/sonic/decode-syseeprom/syseeprom_cache"]) def get_local_eth0_mac(): cmd1 = ["ifconfig", "eth0"] cmd2 = ["grep", "HWaddr"] print(getstatusoutput_noshell_pipe(cmd1, cmd2)) def getonieversion(): if not os.path.isfile('/host/machine.conf'): return "" machine_vars = {} with open('/host/machine.conf') as machine_file: for line in machine_file: tokens = line.split('=') if len(tokens) < 2: continue machine_vars[tokens[0]] = tokens[1].strip() return machine_vars.get("onie_version") def createbmcMac(cpumac , num = 2): bcmvalue = strtoint(cpumac[cpumac.rindex(":")+ 1:len(cpumac)]) + num # bmcmac = t = cpumac.split(":") t[5] = "%02x" % bcmvalue bmcmac = ":".join(t) return bmcmac.upper() def fac_board_setmac(): _value = {} # default value _value[TLV_CODE_VENDOR_EXT] = generate_ext(RUIJIE_CARDID) # generate id _value[TLV_CODE_PRODUCT_NAME] = RUIJIE_PRODUCTNAME _value[TLV_CODE_PART_NUMBER] = RUIJIE_PART_NUMBER _value[TLV_CODE_LABEL_REVISION] = RUIJIE_LABEL_REVISION _value[TLV_CODE_PLATFORM_NAME] = platform _value[TLV_CODE_ONIE_VERSION] = getonieversion() _value[TLV_CODE_MAC_SIZE] = RUIJIE_MAC_SIZE _value[TLV_CODE_MANUF_NAME] = RUIJIE_MANUF_NAME _value[TLV_CODE_MANUF_COUNTRY] = RUIJIE_MANUF_COUNTRY _value[TLV_CODE_VENDOR_NAME] = RUIJIE_VENDOR_NAME _value[TLV_CODE_DIAG_VERSION] = RUIJIE_DIAG_VERSION _value[TLV_CODE_SERVICE_TAG] = RUIJIE_SERVICE_TAG try: if 0x00004052 == RUIJIE_CARDID: _value[TLV_CODE_PRODUCT_NAME] = RUIJIE_PRODUCTNAME + "-RJ" elif 0x00004051 == RUIJIE_CARDID or 0x00004050 == RUIJIE_CARDID: changeTypeValue(_value, TLV_CODE_PRODUCT_NAME, "Product name",RUIJIE_PRODUCTNAME) changeTypeValue(_value, TLV_CODE_SERIAL_NUMBER, "SN", "0000000000000") # add serial number changeTypeValue(_value, TLV_CODE_DEVICE_VERSION, "hardware version", "101") # hardware version changeTypeValue(_value, TLV_CODE_MAC_BASE, "MAC address", "58696cfb2108") # MAC address _value[TLV_CODE_MANUF_DATE] = time.strftime( '%m/%d/%Y %H:%M:%S', time.localtime()) # add setmac time rst, ret = generate_value(_value) if util_setmac("eth0", _value[TLV_CODE_MAC_BASE]) == True: # set Internet cardIP writeToEEprom(rst) # write to e2 # set BMC MAC if "bmcsetmac" in FACTESTMODULE and FACTESTMODULE['bmcsetmac'] == 1: bmcmac = createbmcMac(_value[TLV_CODE_MAC_BASE]) if ipmi_set_mac(bmcmac) == True: print("BMC MAC[%s]"%bmcmac) else: print("SET BMC MAC FAILED") return False else: return False except SETMACException as e: #print(e) RJPRINTERR("\n\n%s\n\n" % e) return False except ValueError as e: return False return True def ipmi_set_mac(mac): macs = mac.split(":") cmdinit = ["ipmitool", "raw", "0x0c", "0x01", "0x01", "0xc2", "0x00"] cmdset = ["ipmitool", "raw", "0x0c", "0x01", "0x01", "0x05"] for ind in range(len(macs)): cmdset.append("0x%02x" % int(macs[ind], 16)) getstatusoutput_noshell(cmdinit) ret, status = getstatusoutput_noshell(cmdset) if ret: RJPRINTERR("\n\n%s\n\n" % status) return False return True def getInputValue(title, tips): print("Please input[%s]such as(%s):" % (title, tips)) name = raw_input() return name def bmc_setmac(): tips = "BMC MAC" print("Please input value you want to change[%s]:" % tips) name = raw_input() if len(name) != 12: RJPRINTERR("\nMAC address invaild, try again\n") return False release_mac = "" for i in range(int(len(name) / 2)): if i == 0: release_mac += name[i * 2:i * 2 + 2] else: release_mac += ":" + name[i * 2:i * 2 + 2] if isValidMac(release_mac) == True: if ipmi_set_mac(release_mac) == True: return True else: RJPRINTERR("\nMAC address invaild, try again\n") return False def closeProtocol(): # disable LLDP log_info("disable LLDP") sys.stdout.write(".") sys.stdout.flush() getstatusoutput_noshell(["systemctl", "stop", "lldp.service"]) log_info("disable lldp service") sys.stdout.write(".") sys.stdout.flush() getstatusoutput_noshell(["systemctl", "stop", "bgp.service"]) log_info("disable bgp service") sys.stdout.write(".") sys.stdout.flush() #ret, status = rj_os_system('bcmcmd "port ce,xe stp=disable"') # check SDK memory must be 256M def checkSdkMem(): ind = 0 file_data = "" with open(file_name, "r") as f: for line in f: if "dmasize=16M" in line: line = line.replace("dmasize=16M", "dmasize=256M") ind = -1 file_data += line if ind == 0: return with open(file_name, "w") as f: f.write(file_data) print("change SDK memory to 256, reboot required") getstatusoutput_noshell(["sync"]) getstatusoutput_noshell(["reboot"]) ########################################################################## # receives a character setting ########################################################################## def getch(msg): ret = "" fd = sys.stdin.fileno() old_ttyinfo = termios.tcgetattr(fd) new_ttyinfo = old_ttyinfo[:] new_ttyinfo[3] &= ~termios.ICANON new_ttyinfo[3] &= ~termios.ECHO sys.stdout.write(msg) sys.stdout.flush() try: termios.tcsetattr(fd, termios.TCSANOW, new_ttyinfo) ret = os.read(fd, 1) finally: # print "try to setting" termios.tcsetattr(fd, termios.TCSANOW, old_ttyinfo) return ret def get_raw_input(): ret="" fd=sys.stdin.fileno() old_ttyinfo=termios.tcgetattr(fd) new_ttyinfo=old_ttyinfo[:] new_ttyinfo[3] &= ~termios.ICANON new_ttyinfo[3] &= ~termios.ECHO try: termios.tcsetattr(fd,termios.TCSANOW,new_ttyinfo) ret=raw_input("") except Exception as e: print(e) finally: termios.tcsetattr(fd,termios.TCSANOW,old_ttyinfo) return ret def getsysvalue(location): retval = None mb_reg_file = location if (not os.path.isfile(mb_reg_file)): print(mb_reg_file, 'not found !') return retval try: if (not os.path.isfile(mb_reg_file)): print(mb_reg_file, 'not found !') return retval with open(mb_reg_file, 'r') as fd: retval = fd.read() except Exception as error: log_error("Unable to open " + mb_reg_file + "file !") retval = retval.rstrip('\r\n') retval = retval.lstrip(" ") #log_debug(retval) return retval # get file value def get_pmc_register(reg_name): retval = 'ERR' mb_reg_file = MAILBOX_DIR + reg_name filepath = glob.glob(mb_reg_file) if(len(filepath) == 0): return "%s %s notfound"% (retval , mb_reg_file) mb_reg_file = filepath[0] if (not os.path.isfile(mb_reg_file)): return "%s %s notfound"% (retval , mb_reg_file) try: with open(mb_reg_file, 'r') as fd: retval = fd.read() except Exception as error: pass retval = retval.rstrip('\r\n') retval = retval.lstrip(" ") return retval # decode EEPROM def decoder(s, t): if ord(t[0]) == TLV_CODE_PRODUCT_NAME: name = "Product Name" value = str(t[2:2 + ord(t[1])]) elif ord(t[0]) == TLV_CODE_PART_NUMBER: name = "Part Number" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_SERIAL_NUMBER: name = "Serial Number" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_MAC_BASE: name = "Base MAC Address" value = ":".join([binascii.b2a_hex(T) for T in t[2:8]]).upper() elif ord(t[0]) == TLV_CODE_MANUF_DATE: name = "Manufacture Date" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_DEVICE_VERSION: name = "Device Version" value = str(ord(t[2])) elif ord(t[0]) == TLV_CODE_LABEL_REVISION: name = "Label Revision" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_PLATFORM_NAME: name = "Platform Name" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_ONIE_VERSION: name = "ONIE Version" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_MAC_SIZE: name = "MAC Addresses" value = str((ord(t[2]) << 8) | ord(t[3])) elif ord(t[0]) == TLV_CODE_MANUF_NAME: name = "Manufacturer" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_MANUF_COUNTRY: name = "Manufacture Country" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_VENDOR_NAME: name = "Vendor Name" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_DIAG_VERSION: name = "Diag Version" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_SERVICE_TAG: name = "Service Tag" value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_VENDOR_EXT: name = "Vendor Extension" value = "" if _TLV_DISPLAY_VENDOR_EXT: value = t[2:2 + ord(t[1])] elif ord(t[0]) == TLV_CODE_CRC_32 and len(t) == 6: name = "CRC-32" value = "0x%08X" % (((ord(t[2]) << 24) | ( ord(t[3]) << 16) | (ord(t[4]) << 8) | ord(t[5])),) elif ord(t[0]) == TLV_CODE_RJ_CARID: name = "rj_cardid" value = "" for c in t[2:2 + ord(t[1])]: value += "%02X" % (ord(c),) else: name = "Unknown" value = "" for c in t[2:2 + ord(t[1])]: value += "0x%02X " % (ord(c),) return {"name": name, "code": ord(t[0]), "value": value} def decode_eeprom(e): total_len = (ord(e[9]) << 8) | ord(e[10]) tlv_index = _TLV_INFO_HDR_LEN tlv_end = _TLV_INFO_HDR_LEN + total_len ret = [] while (tlv_index + 2) < len(e) and tlv_index < tlv_end: rt = decoder(None, e[tlv_index:tlv_index + 2 + ord(e[tlv_index + 1])]) ret.append(rt) if ord(e[tlv_index]) == TLV_CODE_CRC_32: break tlv_index += ord(e[tlv_index + 1]) + 2 for item in ret: if item['code'] == TLV_CODE_VENDOR_EXT: rt = decoder(None, item["value"] [0: 0 + 2 + ord(item["value"][0 + 1])]) ret.append(rt) return ret def get_sys_eeprom(): eeprom = get_sysfs_value(rg_eeprom) return decode_eeprom(eeprom) # get card ID def getCardId(): ret = get_sys_eeprom() for item in ret: if item['code'] == TLV_CODE_RJ_CARID: return item.get('value',None) return None ########################################### # get memory slot and number via DMI command ########################################### def getsysmeminfo(): ret, log = getstatusoutput_noshell(["which", "dmidecode"]) if ret != 0 or len(log) <= 0: error = "cmd find dmidecode" return False, error cmd1 = [log[0].rstrip('\n')] cmd2 = ["grep", "-P", "-A5", "Memory\s+Device"] cmd3 = ["grep", "Size"] cmd4 = ["grep", "-v", "Range"] # get total number first result = [] ret1, log1 = getstatusoutput_noshell_pipe(cmd1, cmd2, cmd3, cmd4) if ret1 == 0 and len(log1): log1 = log1.lstrip() arr = log1.split("\n") #total = len(arr) # total slot number for i in range(len(arr)): val = re.sub("\D", "", arr[i]) if val == "": val = arr[i].lstrip() val = re.sub('Size:', '', val).lstrip() # print val result.append({"slot": i + 1, "size": val}) return True, result return False, "error" ########################################### # get memory slot and number via DMI command # return various arrays ########################################### def getsysmeminfo_detail(): ret, log = getstatusoutput_noshell(["which", "dmidecode"]) if ret != 0 or len(log) <= 0: error = "cmd find dmidecode" return False, error cmd1 = [log[0].rstrip('\n')] + ["-t", "17"] cmd2 = ["grep", "-A21", "Memory Device"] # 17 # get total number ret1, log1 = getstatusoutput_noshell_pipe(cmd1, cmd2) if ret1 != 0 or len(log1) <= 0: return False, "command execution error[%s][%s]" % (cmd1, cmd2) result_t = log1.split("--") mem_rets = [] for item in result_t: its = item.replace("\t", "").strip().split("\n") ret = {} for it in its: if ":" in it: key = it.split(":")[0].lstrip() value = it.split(":")[1].lstrip() ret[key] = value mem_rets.append(ret) return True, mem_rets ########################################### # get BIOS info via DMI command ########################################### def getDmiSysByType(type_t): ret, log = getstatusoutput_noshell(["which", "dmidecode"]) if ret != 0 or len(log) <= 0: error = "cmd find dmidecode" return False, error cmd = [log[0].rstrip('\n')] + ["-t", str(type_t)] # get total number ret1, log1 = getstatusoutput_noshell(cmd) if ret1 != 0 or len(log1) <= 0: return False, "command execution error[%s]" % cmd its = log1.replace("\t", "").strip().split("\n") ret = {} for it in its: if ":" in it: key = it.split(":")[0].lstrip() value = it.split(":")[1].lstrip() ret[key] = value return True, ret def gethwsys(): return getDmiSysByType(1) ########################################### # get BIOS info via DMI command def getsysbios(): return getDmiSysByType(0) def searchDirByName(name, dir): result = [] try: files = os.listdir(dir) for file in files: if name in file: result.append(os.path.join(dir, file)) except Exception as e: pass return result def getUsbLocation(): dir = "/sys/block/" spect = "sd" usbpath = "" result = searchDirByName(spect, dir) if len(result) <= 0: return False for item in result: with open(os.path.join(item, "removable"), 'r') as fd: value = fd.read() if value.strip() == "1": # U-Disk found usbpath = item break if usbpath == "": # no U-Disk found log_debug("no usb found") return False, usbpath return True, usbpath # judge USB file def getusbinfo(): ret, path = getUsbLocation() if ret == False: return False, "not usb exists" str = os.path.join(path, "size") ret, value = getfilevalue(str) if ret == True: return True, {"id": os.path.basename(path), "size": float(value) * 512 / 1024 / 1024 / 1024} else: return False, "Err" def get_cpu_info(): cmd1 = ["cat", "/proc/cpuinfo"] cmd2 = ["grep", "processor", "-A18"] # 17 ret, log1 = getstatusoutput_noshell_pipe(cmd1, cmd2) if ret != 0 or len(log1) <= 0: return False, "command execution error[%s][%s]" % (cmd1, cmd2) result_t = log1.split("--") mem_rets = [] for item in result_t: its = item.replace("\t", "").strip().split("\n") ret = {} for it in its: if ":" in it: key = it.split(":")[0].lstrip() value = it.split(":")[1].lstrip() ret[key] = value mem_rets.append(ret) return True, mem_rets # read file def get_version_config_info(attr_key, file_name=None): if file_name is None: version_conf_filename = "/root/version.json" else: version_conf_filename = file_name if not os.path.isfile(version_conf_filename): return None with open(version_conf_filename) as rjconf_file: for line in rjconf_file: tokens = line.split('=') if len(tokens) < 2: continue if tokens[0] == attr_key: return tokens[1].strip() return None def io_rd(reg_addr, len =1): u'''io read''' try: regaddr = 0 if type(reg_addr) == int: regaddr = reg_addr else: regaddr = int(reg_addr, 16) devfile = "/dev/port" fd = os.open(devfile, os.O_RDWR|os.O_CREAT) os.lseek(fd, regaddr, os.SEEK_SET) str = os.read(fd, len) return "".join(["%02x"% ord(item) for item in str]) except ValueError: return None except Exception as e: print(e) return None finally: os.close(fd) def io_wr(reg_addr, reg_data): u'''io write''' try: regdata = 0 regaddr = 0 if type(reg_addr) == int: regaddr = reg_addr else: regaddr = int(reg_addr, 16) if type(reg_data) == int: regdata = reg_data else: regdata = int(reg_data, 16) devfile = "/dev/port" fd = os.open(devfile, os.O_RDWR|os.O_CREAT) os.lseek(fd, regaddr, os.SEEK_SET) os.write(fd, chr(regdata)) return True except ValueError as e: print(e) return False except Exception as e: print(e) return False finally: os.close(fd)