Python converter.scsi_ba_to_int函数代码示例

def main():
    dev = MockReadElementStatus()
    dev.opcodes = smc
    s = SCSI(dev)
    s.device.opcodes = smc
    # cdb for SMC: ReadElementStatus
    r = s.readelementstatus(300, 700, element_type=READELEMENTSTATUS.ELEMENT_TYPE.STORAGE, voltag=1, curdata=1, dvcid=1)
    cdb = r.cdb
    assert cdb[0] == s.device.opcodes.READ_ELEMENT_STATUS.value
    assert cdb[1] == 0x10 | READELEMENTSTATUS.ELEMENT_TYPE.STORAGE
    assert scsi_ba_to_int(cdb[2:4]) == 300
    assert scsi_ba_to_int(cdb[4:6]) == 700
    assert cdb[6] == 0x03
    assert scsi_ba_to_int(cdb[7:10]) == 16384
    cdb = r.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.READ_ELEMENT_STATUS.value
    assert cdb['voltag'] == 1
    assert cdb['element_type'] == READELEMENTSTATUS.ELEMENT_TYPE.STORAGE
    assert cdb['starting_element_address'] == 300
    assert cdb['num_elements'] == 700
    assert cdb['curdata'] == 1
    assert cdb['dvcid'] == 1
    assert cdb['alloc_len'] == 16384

    d = ReadElementStatus.unmarshall_cdb(ReadElementStatus.marshall_cdb(cdb))
    assert d == cdb

def main():
    with MockSCSI(MockDevice(spc)) as s:
        # cdb for standard page request
        i = s.inquiry(alloclen=128)
        cdb = i.cdb
        assert cdb[0] == s.device.opcodes.INQUIRY.value
        assert cdb[1:3] == bytearray(2)
        assert scsi_ba_to_int(cdb[3:5]) == 128
        assert cdb[5] == 0
        cdb = i.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.INQUIRY.value
        assert cdb['evpd'] == 0
        assert cdb['page_code'] == 0
        assert cdb['alloc_len'] == 128

        d = Inquiry.unmarshall_cdb(Inquiry.marshall_cdb(cdb))
        assert d == cdb

        # supported vpd pages
        i = s.inquiry(evpd=1, page_code=0x88, alloclen=300)
        cdb = i.cdb
        assert cdb[0] == s.device.opcodes.INQUIRY.value
        assert cdb[1] == 0x01
        assert cdb[2] == 0x88
        assert scsi_ba_to_int(cdb[3:5]) == 300
        assert cdb[5] == 0
        cdb = i.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.INQUIRY.value
        assert cdb['evpd'] == 1
        assert cdb['page_code'] == 0x88
        assert cdb['alloc_len'] == 300

        d = Inquiry.unmarshall_cdb(Inquiry.marshall_cdb(cdb))
        assert d == cdb

def main():
    dev = MockMoveMedium()
    dev.opcodes = smc
    s = SCSI(dev)
    s.device.opcodes = smc
    m = s.exchangemedium(15, 32, 64, 32, inv1=1)
    cdb = m.cdb
    assert cdb[0] == s.device.opcodes.EXCHANGE_MEDIUM.value
    assert cdb[1] == 0
    assert scsi_ba_to_int(cdb[2:4]) == 15
    assert scsi_ba_to_int(cdb[4:6]) == 32
    assert scsi_ba_to_int(cdb[6:8]) == 64
    assert scsi_ba_to_int(cdb[8:10]) == 32
    assert cdb[10] == 0x02
    cdb = m.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.EXCHANGE_MEDIUM.value
    assert cdb['medium_transport_address'] == 15
    assert cdb['source_address'] == 32
    assert cdb['first_destination_address'] == 64
    assert cdb['second_destination_address'] == 32
    assert cdb['inv1'] == 1
    assert cdb['inv2'] == 0

    d = ExchangeMedium.unmarshall_cdb(ExchangeMedium.marshall_cdb(cdb))
    assert d == cdb

    def unmarshall_designator(type, data):
        _d = {}
        if type == inquiry_enums.DESIGNATOR.VENDOR_SPECIFIC:
            _d['vendor_specific'] = data

        if type == inquiry_enums.DESIGNATOR.T10_VENDOR_ID:
            _d['t10_vendor_id'] = data[:8]
            _d['vendor_specific_id'] = data[8:]

        if type == inquiry_enums.DESIGNATOR.EUI_64:
            if len(data) == 8:
                _d['ieee_company_id'] = scsi_ba_to_int(data[:3])
                _d['vendor_specific_extension_id'] = data[3:8]
            if len(data) == 12:
                _d['ieee_company_id'] = scsi_ba_to_int(data[:3])
                _d['vendor_specific_extension_id'] = data[3:8]
                _d['directory_id'] = data[8:]
            if len(data) == 16:
                _d['identifier_extension'] = data[:8]
                _d['ieee_company_id'] = scsi_ba_to_int(data[8:11])
                _d['vendor_specific_extension_id'] = data[11:]

        if type == inquiry_enums.DESIGNATOR.NAA:
            decode_bits(data, Inquiry._naa_type_bits, _d)
            if _d['naa'] == inquiry_enums.NAA.IEEE_EXTENDED:
                decode_bits(data, Inquiry._naa_ieee_extended_bits, _d)
            if _d['naa'] == inquiry_enums.NAA.LOCALLY_ASSIGNED:
                decode_bits(data, Inquiry._naa_locally_assigned_bits, _d)
            if _d['naa'] == inquiry_enums.NAA.IEEE_REGISTERED:
                decode_bits(data, Inquiry._naa_ieee_registered_bits, _d)
            if _d['naa'] == inquiry_enums.NAA.IEEE_REGISTERED_EXTENDED:
                decode_bits(data, Inquiry._naa_ieee_registered_extended_bits, _d)

        if type == inquiry_enums.DESIGNATOR.RELATIVE_TARGET_PORT_IDENTIFIER:
            decode_bits(data, Inquiry._relative_port_bits, _d)

        if type == inquiry_enums.DESIGNATOR.TARGET_PORTAL_GROUP:
            decode_bits(data, Inquiry._target_portal_group_bits, _d)

        if type == inquiry_enums.DESIGNATOR.LOGICAL_UNIT_GROUP:
            decode_bits(data, Inquiry._logical_unit_group_bits, _d)

        if type == inquiry_enums.DESIGNATOR.MD5_LOGICAL_IDENTIFIER:
            _d['md5_logical_identifier'] = data[0:16]

        if type == inquiry_enums.DESIGNATOR.SCSI_NAME_STRING:
            _d['scsi_name_string'] = data

        if type == inquiry_enums.DESIGNATOR.PCI_EXPRESS_ROUTING_ID:
            decode_bits(data, Inquiry._pci_express_routing_id_bits, _d)

        return _d

    def unmarshall_datain(data):
        """
        """
        result = {}
        _esd = []
        decode_bits(data, ReadElementStatus._datain_bits, result)

        #
        # Loop over the remaining data until we have consumed all
        # element status pages
        #
        _bc = scsi_ba_to_int(data[5:8])
        data = data[8:8 + _bc]
        while len(data):
            _r = {}
            _bc = scsi_ba_to_int(data[5:8])
            _edl = scsi_ba_to_int(data[2:4])

            decode_bits(data, ReadElementStatus._element_status_page_bits, _r)
            _d = data[8:8 + _bc]
            _ed = []
            while len(_d):
                _rr = {}

                decode_bits(_d, ReadElementStatus._element_status_descriptor_bits, _rr)
                _dd = _d[12:]
                if _r['pvoltag']:
                    _rr.update({'primary_volume_tag': _dd[0:36]})
                    _dd = _dd[36:]
                if _r['avoltag']:
                    _rr.update({'alternate_volume_tag': _dd[0:36]})
                    _dd = _dd[36:]

                if _r['element_type'] == readelementstatus_enums.ELEMENT_TYPE.DATA_TRANSFER:
                    decode_bits(_d, ReadElementStatus._data_transfer_descriptor_bits, _rr)
                if _r['element_type'] == readelementstatus_enums.ELEMENT_TYPE.STORAGE:
                    decode_bits(_d, ReadElementStatus._storage_descriptor_bits, _rr)
                if _r['element_type'] == readelementstatus_enums.ELEMENT_TYPE.IMPORT_EXPORT:
                    decode_bits(_d, ReadElementStatus._import_export_descriptor_bits, _rr)

                _ed.append(_rr)
                _d = _d[_edl:]

            _r.update({'element_descriptors': _ed})
            _esd.append(_r)

            data = data[8 + _bc:]

        result.update({'element_status_pages': _esd})
        return result

    def unmarshall_datain(data):
        """
        Unmarshall the ReportLuns datain buffer.

        :param data: a byte array
        :return result: a dic
        """
        result = {}
        _data = data[8:scsi_ba_to_int(data[:4]) + 4]
        _luns = []
        _count = 0
        while len(_data):
            #  maybe we drop the whole "put a dict into the list for every lun" thing at all
            _r = {}
            decode_bits(_data[:8],
                        ReportLuns._datain_bits,
                        _r)
            key = 'lun%s' % _count
            _r[key] = _r.pop('lun')
            _luns.append(_r)
            _data = _data[8:]
            _count += 1

        result.update({'luns': _luns})
        return result

def main():
    dev = MockWrite12()
    dev.opcodes = sbc
    s = SCSI(dev)
    s.blocksize = 512

    data = bytearray(27 * 512)

    w = s.write12(1024, 27, data)
    cdb = w.cdb
    assert cdb[0] == s.device.opcodes.WRITE_12.value
    assert cdb[1] == 0
    assert scsi_ba_to_int(cdb[2:6]) == 1024
    assert scsi_ba_to_int(cdb[6:10]) == 27
    assert cdb[10] == 0
    assert cdb[11] == 0
    cdb = w.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.WRITE_12.value
    assert cdb['wrprotect'] == 0
    assert cdb['dpo'] == 0
    assert cdb['fua'] == 0
    assert cdb['lba'] == 1024
    assert cdb['group'] == 0
    assert cdb['tl'] == 27

    d = Write12.unmarshall_cdb(Write12.marshall_cdb(cdb))
    assert d == cdb

    w = s.write12(65536, 27, data, wrprotect=2, dpo=1, fua=1, group=19)
    cdb = w.cdb
    assert cdb[0] == s.device.opcodes.WRITE_12.value
    assert cdb[1] == 0x58
    assert scsi_ba_to_int(cdb[2:6]) == 65536
    assert scsi_ba_to_int(cdb[6:10]) == 27
    assert cdb[10] == 0x13
    assert cdb[11] == 0
    cdb = w.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.WRITE_12.value
    assert cdb['wrprotect'] == 2
    assert cdb['dpo'] == 1
    assert cdb['fua'] == 1
    assert cdb['lba'] == 65536
    assert cdb['group'] == 19
    assert cdb['tl'] == 27

    d = Write12.unmarshall_cdb(Write12.marshall_cdb(cdb))
    assert d == cdb

def main():
    dev = MockRead16()
    dev.opcodes = sbc
    s = SCSI(dev)
    s.blocksize = 512

    r = s.read16(1024, 27)
    cdb = r.cdb
    assert cdb[0] == s.device.opcodes.READ_16.value
    assert cdb[1] == 0
    assert scsi_ba_to_int(cdb[2:10]) == 1024
    assert scsi_ba_to_int(cdb[10:14]) == 27
    assert cdb[14] == 0
    assert cdb[15] == 0
    cdb = r.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.READ_16.value
    assert cdb['rdprotect'] == 0
    assert cdb['dpo'] == 0
    assert cdb['fua'] == 0
    assert cdb['rarc'] == 0
    assert cdb['lba'] == 1024
    assert cdb['group'] == 0
    assert cdb['tl'] == 27

    d = Read16.unmarshall_cdb(Read16.marshall_cdb(cdb))
    assert d == cdb

    r = s.read16(1024, 27, rdprotect=2, dpo=1, fua=1, rarc=1, group=19)
    cdb = r.cdb
    assert cdb[0] == s.device.opcodes.READ_16.value
    assert cdb[1] == 0x5c
    assert scsi_ba_to_int(cdb[2:10]) == 1024
    assert scsi_ba_to_int(cdb[10:14]) == 27
    assert cdb[14] == 0x13
    assert cdb[15] == 0
    cdb = r.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.READ_16.value
    assert cdb['rdprotect'] == 2
    assert cdb['dpo'] == 1
    assert cdb['fua'] == 1
    assert cdb['rarc'] == 1
    assert cdb['lba'] == 1024
    assert cdb['group'] == 19
    assert cdb['tl'] == 27

    d = Read16.unmarshall_cdb(Read16.marshall_cdb(cdb))
    assert d == cdb

def main():

    with MockSCSI(MockDevice(sbc)) as s:
        s.blocksize = 512

        data = bytearray(27 * 512)

        w = s.write10(1024, 27, data)
        cdb = w.cdb
        assert cdb[0] == s.device.opcodes.WRITE_10.value
        assert cdb[1] == 0
        assert scsi_ba_to_int(cdb[2:6]) == 1024
        assert cdb[6] == 0
        assert scsi_ba_to_int(cdb[7:9]) == 27
        assert cdb[9] == 0
        cdb = w.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.WRITE_10.value
        assert cdb['wrprotect'] == 0
        assert cdb['dpo'] == 0
        assert cdb['fua'] == 0
        assert cdb['lba'] == 1024
        assert cdb['group'] == 0
        assert cdb['tl'] == 27

        d = Write10.unmarshall_cdb(Write10.marshall_cdb(cdb))
        assert d == cdb

        w = s.write10(65536, 27, data, wrprotect=2, dpo=1, fua=1, group=19)
        cdb = w.cdb
        assert cdb[0] == s.device.opcodes.WRITE_10.value
        assert cdb[1] == 0x58
        assert scsi_ba_to_int(cdb[2:6]) == 65536
        assert cdb[6] == 0x13
        assert scsi_ba_to_int(cdb[7:9]) == 27
        assert cdb[9] == 0
        cdb = w.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.WRITE_10.value
        assert cdb['wrprotect'] == 2
        assert cdb['dpo'] == 1
        assert cdb['fua'] == 1
        assert cdb['lba'] == 65536
        assert cdb['group'] == 19
        assert cdb['tl'] == 27

        d = Write10.unmarshall_cdb(Write10.marshall_cdb(cdb))
        assert d == cdb

def main():
    with MockSCSI(MockDevice(smc)) as s:
        m = s.positiontoelement(15, 32, invert=1)
        cdb = m.cdb
        assert cdb[0] == s.device.opcodes.POSITION_TO_ELEMENT.value
        assert cdb[1] == 0
        assert scsi_ba_to_int(cdb[2:4]) == 15
        assert scsi_ba_to_int(cdb[4:6]) == 32
        assert cdb[8] == 0x01
        cdb = m.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.POSITION_TO_ELEMENT.value
        assert cdb['medium_transport_address'] == 15
        assert cdb['destination_address'] == 32
        assert cdb['invert'] == 1

        d = PositionToElement.unmarshall_cdb(PositionToElement.marshall_cdb(cdb))
        assert d == cdb

 def unmarshall_datain(data):
     """
     Unmarshall the ReportPriority datain.
     """
     result = {}
     #  get the data after the ppd_len
     _data = data[4:scsi_ba_to_int(data[:4])]
     _descriptors = []
     while len(_data):
         _r = {}
         _dict = dict(ReportPriority._datain_bits.copy)
         _dict.update({'transport_id': [hex(scsi_ba_to_int(_data[6:7])), 8], })
         decode_bits(_data[:8 + scsi_ba_to_int(_data[6:7])], _dict, _r)
         _descriptors.append(_r)
         _data = _data[scsi_ba_to_int(_r['adlen']) + 8:]
     result.update({'priority_descriptors': _descriptors, })
     return result

def main():

    with MockSCSI(MockDevice(sbc)) as s:
        s.blocksize = 512

        r = s.read12(1024, 27)
        cdb = r.cdb
        assert cdb[0] == s.device.opcodes.READ_12.value
        assert cdb[1] == 0
        assert scsi_ba_to_int(cdb[2:6]) == 1024
        assert scsi_ba_to_int(cdb[6:10]) == 27
        assert cdb[10] == 0
        assert cdb[11] == 0
        cdb = r.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.READ_12.value
        assert cdb['rdprotect'] == 0
        assert cdb['dpo'] == 0
        assert cdb['fua'] == 0
        assert cdb['rarc'] == 0
        assert cdb['lba'] == 1024
        assert cdb['group'] == 0
        assert cdb['tl'] == 27

        d = Read12.unmarshall_cdb(Read12.marshall_cdb(cdb))
        assert d == cdb

        r = s.read12(1024, 27, rdprotect=2, dpo=1, fua=1, rarc=1, group=19)
        cdb = r.cdb
        assert cdb[0] == s.device.opcodes.READ_12.value
        assert cdb[1] == 0x5c
        assert scsi_ba_to_int(cdb[2:6]) == 1024
        assert scsi_ba_to_int(cdb[6:10]) == 27
        assert cdb[10] == 0x13
        assert cdb[11] == 0
        cdb = r.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.READ_12.value
        assert cdb['rdprotect'] == 2
        assert cdb['dpo'] == 1
        assert cdb['fua'] == 1
        assert cdb['rarc'] == 1
        assert cdb['lba'] == 1024
        assert cdb['group'] == 19
        assert cdb['tl'] == 27

        d = Read12.unmarshall_cdb(Read12.marshall_cdb(cdb))
        assert d == cdb

def main():
    dev = MockRead10()
    dev.opcodes = sbc
    s = SCSI(dev)

    r = s.read10(1024, 27)
    cdb = r.cdb
    assert cdb[0] == s.device.opcodes.READ_10.value
    assert cdb[1] == 0
    assert scsi_ba_to_int(cdb[2:6]) == 1024
    assert cdb[6] == 0
    assert scsi_ba_to_int(cdb[7:9]) == 27
    assert cdb[9] == 0
    cdb = r.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.READ_10.value
    assert cdb['rdprotect'] == 0
    assert cdb['dpo'] == 0
    assert cdb['fua'] == 0
    assert cdb['rarc'] == 0
    assert cdb['lba'] == 1024
    assert cdb['group'] == 0
    assert cdb['tl'] == 27

    d = Read10.unmarshall_cdb(Read10.marshall_cdb(cdb))
    assert d == cdb

    r = s.read10(1024, 27, rdprotect=2, dpo=1, fua=1, rarc=1, group=19)
    cdb = r.cdb
    assert cdb[0] == s.device.opcodes.READ_10.value
    assert cdb[1] == 0x5c
    assert scsi_ba_to_int(cdb[2:6]) == 1024
    assert cdb[6] == 0x13
    assert scsi_ba_to_int(cdb[7:9]) == 27
    assert cdb[9] == 0
    cdb = r.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.READ_10.value
    assert cdb['rdprotect'] == 2
    assert cdb['dpo'] == 1
    assert cdb['fua'] == 1
    assert cdb['rarc'] == 1
    assert cdb['lba'] == 1024
    assert cdb['group'] == 19
    assert cdb['tl'] == 27

    d = Read10.unmarshall_cdb(Read10.marshall_cdb(cdb))
    assert d == cdb

def main():
    dev = MockModeSense10()
    dev.opcodes = smc
    s = SCSI(dev)

    # cdb for SMC: ElementAddressAssignment
    m = s.modesense10(page_code=MODESENSE10.PAGE_CODE.ELEMENT_ADDRESS_ASSIGNMENT)
    cdb = m.cdb
    assert cdb[0] == s.device.opcodes.MODE_SENSE_10.value
    assert cdb[1] == 0
    assert cdb[2] == MODESENSE10.PAGE_CODE.ELEMENT_ADDRESS_ASSIGNMENT
    assert cdb[3] == 0
    assert cdb[4:6] == bytearray(2)
    assert scsi_ba_to_int(cdb[7:9]) == 96
    assert cdb[9] == 0
    cdb = m.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.MODE_SENSE_10.value
    assert cdb['dbd'] == 0
    assert cdb['llbaa'] == 0
    assert cdb['page_code'] == MODESENSE10.PAGE_CODE.ELEMENT_ADDRESS_ASSIGNMENT
    assert cdb['pc'] == 0
    assert cdb['sub_page_code'] == 0
    assert cdb['alloc_len'] == 96

    d = ModeSense10.unmarshall_cdb(ModeSense10.marshall_cdb(cdb))
    assert d == cdb

    m = s.modesense10(page_code=0, sub_page_code=3, llbaa=1, dbd=1, pc=MODESENSE10.PC.DEFAULT, alloclen=90)
    cdb = m.cdb
    assert cdb[0] == s.device.opcodes.MODE_SENSE_10.value
    assert cdb[1] == 0x18
    assert cdb[2] == MODESENSE10.PC.DEFAULT << 6
    assert cdb[3] == 3
    assert scsi_ba_to_int(cdb[7:9]) == 90
    cdb = m.unmarshall_cdb(cdb)
    assert cdb['opcode'] == s.device.opcodes.MODE_SENSE_10.value
    assert cdb['dbd'] == 1
    assert cdb['pc'] == MODESENSE10.PC.DEFAULT
    assert cdb['page_code'] == 0
    assert cdb['sub_page_code'] == 3
    assert cdb['alloc_len'] == 90
    assert cdb['llbaa'] == 1

    d = ModeSense10.unmarshall_cdb(ModeSense10.marshall_cdb(cdb))
    assert d == cdb

def main():
    with MockSCSI(MockDevice(smc)) as s:
        r = s.initializeelementstatuswithrange(15, 3, rng=1, fast=1)
        cdb = r.cdb
        assert cdb[0] == s.device.opcodes.INITIALIZE_ELEMENT_STATUS_WITH_RANGE.value
        assert cdb[1] == 0x03
        assert scsi_ba_to_int(cdb[2:4]) == 15
        assert scsi_ba_to_int(cdb[6:8]) == 3

        cdb = r.unmarshall_cdb(cdb)
        assert cdb['opcode'] == s.device.opcodes.INITIALIZE_ELEMENT_STATUS_WITH_RANGE.value
        assert cdb['starting_element_address'] == 15
        assert cdb['number_of_elements'] == 3
        assert cdb['fast'] == 1
        assert cdb['range'] == 1

        d = InitializeElementStatusWithRange.unmarshall_cdb(InitializeElementStatusWithRange.marshall_cdb(cdb))
        assert d == cdb