

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: pb2dict.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>import base64
import collections
import os
import quopri
import socket
from ipaddress import IPv4Address, IPv6Address, ip_address

from google.protobuf.descriptor import FieldDescriptor as FD

import opts_pb2

if &quot;encodebytes&quot; not in dir(base64):
    base64.encodebytes = base64.encodestring
    base64.decodebytes = base64.decodestring

# pb2dict and dict2pb are methods to convert pb to/from dict.
# Inspired by:
#   protobuf-to-dict - https://github.com/benhodgson/protobuf-to-dict
#   protobuf-json    - https://code.google.com/p/protobuf-json/
#   protobuf source  - https://code.google.com/p/protobuf/
# Both protobuf-to-dict/json do not fit here because of several reasons,
# here are some of them:
#   - both have a common bug in treating optional field with empty
#     repeated inside.
#   - protobuf-to-json is not available in pip or in any other python
#     repo, so it is hard to distribute and we can&#039;t rely on it.
#   - both do not treat enums in a way we would like to. They convert
#     protobuf enum to int, but we need a string here, because it is
#     much more informative. BTW, protobuf text_format converts pb
#     enums to string value too. (i.e. &quot;march : x86_64&quot; is better then
#     &quot;march : 1&quot;).

_basic_cast = {
    FD.TYPE_FIXED64: int,
    FD.TYPE_FIXED32: int,
    FD.TYPE_SFIXED64: int,
    FD.TYPE_SFIXED32: int,
    FD.TYPE_INT64: int,
    FD.TYPE_UINT64: int,
    FD.TYPE_SINT64: int,
    FD.TYPE_INT32: int,
    FD.TYPE_UINT32: int,
    FD.TYPE_SINT32: int,
    FD.TYPE_BOOL: bool,
    FD.TYPE_STRING: str
}


def _marked_as_hex(field):
    return field.GetOptions().Extensions[opts_pb2.criu].hex


def _marked_as_ip(field):
    return field.GetOptions().Extensions[opts_pb2.criu].ipadd


def _marked_as_flags(field):
    return field.GetOptions().Extensions[opts_pb2.criu].flags


def _marked_as_dev(field):
    return field.GetOptions().Extensions[opts_pb2.criu].dev


def _marked_as_odev(field):
    return field.GetOptions().Extensions[opts_pb2.criu].odev


def _marked_as_dict(field):
    return field.GetOptions().Extensions[opts_pb2.criu].dict


def _custom_conv(field):
    return field.GetOptions().Extensions[opts_pb2.criu].conv


mmap_prot_map = [
    (&#039;PROT_READ&#039;, 0x1),
    (&#039;PROT_WRITE&#039;, 0x2),
    (&#039;PROT_EXEC&#039;, 0x4),
]

mmap_flags_map = [
    (&#039;MAP_SHARED&#039;, 0x1),
    (&#039;MAP_PRIVATE&#039;, 0x2),
    (&#039;MAP_DROPPABLE&#039;, 0x08),
    (&#039;MAP_ANON&#039;, 0x20),
    (&#039;MAP_GROWSDOWN&#039;, 0x0100),
]

mmap_status_map = [
    (&#039;VMA_AREA_NONE&#039;, 0 &lt;&lt; 0),
    (&#039;VMA_AREA_REGULAR&#039;, 1 &lt;&lt; 0),
    (&#039;VMA_AREA_STACK&#039;, 1 &lt;&lt; 1),
    (&#039;VMA_AREA_VSYSCALL&#039;, 1 &lt;&lt; 2),
    (&#039;VMA_AREA_VDSO&#039;, 1 &lt;&lt; 3),
    (&#039;VMA_AREA_HEAP&#039;, 1 &lt;&lt; 5),
    (&#039;VMA_FILE_PRIVATE&#039;, 1 &lt;&lt; 6),
    (&#039;VMA_FILE_SHARED&#039;, 1 &lt;&lt; 7),
    (&#039;VMA_ANON_SHARED&#039;, 1 &lt;&lt; 8),
    (&#039;VMA_ANON_PRIVATE&#039;, 1 &lt;&lt; 9),
    (&#039;VMA_AREA_SYSVIPC&#039;, 1 &lt;&lt; 10),
    (&#039;VMA_AREA_SOCKET&#039;, 1 &lt;&lt; 11),
    (&#039;VMA_AREA_VVAR&#039;, 1 &lt;&lt; 12),
    (&#039;VMA_AREA_AIORING&#039;, 1 &lt;&lt; 13),
    (&#039;VMA_AREA_MEMFD&#039;, 1 &lt;&lt; 14),
    (&#039;VMA_AREA_SHSTK&#039;, 1 &lt;&lt; 15),
    (&#039;VMA_AREA_UPROBES&#039;, 1 &lt;&lt; 17),
    (&#039;VMA_UNSUPP&#039;, 1 &lt;&lt; 31),
]

rfile_flags_map = [
    (&#039;O_WRONLY&#039;, 0o00000001),
    (&#039;O_RDWR&#039;, 0o00000002),
    (&#039;O_CREAT&#039;, 0o00000100),
    (&#039;O_EXCL&#039;, 0o00000200),
    (&#039;O_NOCTTY&#039;, 0o00000400),
    (&#039;O_TRUNC&#039;, 0o00001000),
    (&#039;O_APPEND&#039;, 0o00002000),
    (&#039;O_NONBLOCK&#039;, 0o00004000),
    (&#039;O_DSYNC&#039;, 0o00010000),
    (&#039;FASYNC&#039;, 0o00020000),
    (&#039;O_DIRECT&#039;, 0o00040000),
    (&#039;O_LARGEFILE&#039;, 0o00100000),
    (&#039;O_DIRECTORY&#039;, 0o00200000),
    (&#039;O_NOFOLLOW&#039;, 0o00400000),
    (&#039;O_NOATIME&#039;, 0o01000000),
    (&#039;O_CLOEXEC&#039;, 0o02000000),
]

seals_flags_map = [
    (&#039;F_SEAL_SEAL&#039;, 0x0001),
    (&#039;F_SEAL_SHRINK&#039;, 0x0002),
    (&#039;F_SEAL_GROW&#039;, 0x0004),
    (&#039;F_SEAL_WRITE&#039;, 0x0008),
    (&#039;F_SEAL_FUTURE_WRITE&#039;, 0x0010),
]

pmap_flags_map = [
    (&#039;PE_PARENT&#039;, 1 &lt;&lt; 0),
    (&#039;PE_LAZY&#039;, 1 &lt;&lt; 1),
    (&#039;PE_PRESENT&#039;, 1 &lt;&lt; 2),
]

flags_maps = {
    &#039;mmap.prot&#039;: mmap_prot_map,
    &#039;mmap.flags&#039;: mmap_flags_map,
    &#039;mmap.status&#039;: mmap_status_map,
    &#039;rfile.flags&#039;: rfile_flags_map,
    &#039;pmap.flags&#039;: pmap_flags_map,
    &#039;seals.flags&#039;: seals_flags_map,
}

gen_maps = {
    &#039;task_state&#039;: {
        1: &#039;Alive&#039;,
        3: &#039;Zombie&#039;,
        6: &#039;Stopped&#039;
    },
}

sk_maps = {
    &#039;family&#039;: {
        1: &#039;UNIX&#039;,
        2: &#039;INET&#039;,
        10: &#039;INET6&#039;,
        16: &#039;NETLINK&#039;,
        17: &#039;PACKET&#039;
    },
    &#039;type&#039;: {
        1: &#039;STREAM&#039;,
        2: &#039;DGRAM&#039;,
        3: &#039;RAW&#039;,
        5: &#039;SEQPACKET&#039;,
        10: &#039;PACKET&#039;
    },
    &#039;state&#039;: {
        1: &#039;ESTABLISHED&#039;,
        2: &#039;SYN_SENT&#039;,
        3: &#039;SYN_RECV&#039;,
        4: &#039;FIN_WAIT1&#039;,
        5: &#039;FIN_WAIT2&#039;,
        6: &#039;TIME_WAIT&#039;,
        7: &#039;CLOSE&#039;,
        8: &#039;CLOSE_WAIT&#039;,
        9: &#039;LAST_ACK&#039;,
        10: &#039;LISTEN&#039;
    },
    &#039;proto&#039;: {
        0: &#039;IP&#039;,
        6: &#039;TCP&#039;,
        17: &#039;UDP&#039;,
        136: &#039;UDPLITE&#039;
    },
}

gen_rmaps = {
    k: {v2: k2
        for k2, v2 in list(v.items())}
    for k, v in list(gen_maps.items())
}
sk_rmaps = {
    k: {v2: k2
        for k2, v2 in list(v.items())}
    for k, v in list(sk_maps.items())
}

dict_maps = {
    &#039;gen&#039;: (gen_maps, gen_rmaps),
    &#039;sk&#039;: (sk_maps, sk_rmaps),
}


def map_flags(value, flags_map):
    bs = [x[0] for x in [x for x in flags_map if value &amp; x[1]]]
    value &amp;= ~sum([x[1] for x in flags_map])
    if value:
        bs.append(&quot;0x%x&quot; % value)
    return &quot; | &quot;.join(bs)


def unmap_flags(value, flags_map):
    if value == &#039;&#039;:
        return 0

    bd = dict(flags_map)
    return sum([
        int(str(bd.get(x, x)), 0)
        for x in [x.strip() for x in value.split(&#039;|&#039;)]
    ])


kern_minorbits = 20  # This is how kernel encodes dev_t in new format


def decode_dev(field, value):
    if _marked_as_odev(field):
        return &quot;%d:%d&quot; % (os.major(value), os.minor(value))
    else:
        return &quot;%d:%d&quot; % (value &gt;&gt; kern_minorbits,
                          value &amp; ((1 &lt;&lt; kern_minorbits) - 1))


def encode_dev(field, value):
    dev = [int(x) for x in value.split(&#039;:&#039;)]
    if _marked_as_odev(field):
        return os.makedev(dev[0], dev[1])
    else:
        return dev[0] &lt;&lt; kern_minorbits | dev[1]


def encode_base64(value):
    return base64.encodebytes(value).decode()


def decode_base64(value):
    return base64.decodebytes(str.encode(value))


def encode_unix(value):
    return quopri.encodestring(value)


def decode_unix(value):
    return quopri.decodestring(value)


encode = {&#039;unix_name&#039;: encode_unix}
decode = {&#039;unix_name&#039;: decode_unix}


def get_bytes_enc(field):
    c = _custom_conv(field)
    if c:
        return encode[c]
    else:
        return encode_base64


def get_bytes_dec(field):
    c = _custom_conv(field)
    if c:
        return decode[c]
    else:
        return decode_base64


def is_string(value):
    # Python 3 compatibility
    if &quot;basestring&quot; in __builtins__:
        string_types = basestring  # noqa: F821
    else:
        string_types = (str, bytes)
    return isinstance(value, string_types)


def _pb2dict_cast(field, value, pretty=False, is_hex=False):
    if not is_hex:
        is_hex = _marked_as_hex(field)

    if field.type == FD.TYPE_MESSAGE:
        return pb2dict(value, pretty, is_hex)
    elif field.type == FD.TYPE_BYTES:
        return get_bytes_enc(field)(value)
    elif field.type == FD.TYPE_ENUM:
        return field.enum_type.values_by_number.get(value, None).name
    elif field.type in _basic_cast:
        cast = _basic_cast[field.type]
        if pretty and cast is int:
            if is_hex:
                # Fields that have (criu).hex = true option set
                # should be stored in hex string format.
                return &quot;0x%x&quot; % value

            if _marked_as_dev(field):
                return decode_dev(field, value)

            flags = _marked_as_flags(field)
            if flags:
                try:
                    flags_map = flags_maps[flags]
                except Exception:
                    return &quot;0x%x&quot; % value  # flags are better seen as hex anyway
                else:
                    return map_flags(value, flags_map)

            dct = _marked_as_dict(field)
            if dct:
                return dict_maps[dct][0][field.name].get(value, cast(value))

        return cast(value)
    else:
        raise Exception(&quot;Field(%s) has unsupported type %d&quot; %
                        (field.name, field.type))


def pb2dict(pb, pretty=False, is_hex=False):
    &quot;&quot;&quot;
    Convert protobuf msg to dictionary.
    Takes a protobuf message and returns a dict.
    &quot;&quot;&quot;
    d = collections.OrderedDict() if pretty else {}
    for field, value in pb.ListFields():
        if field.label == FD.LABEL_REPEATED:
            d_val = []
            if pretty and _marked_as_ip(field):
                if len(value) == 1:
                    v = socket.ntohl(value[0])
                    addr = IPv4Address(v)
                else:
                    v = 0 + (socket.ntohl(value[0]) &lt;&lt; (32 * 3)) + \
                            (socket.ntohl(value[1]) &lt;&lt; (32 * 2)) + \
                            (socket.ntohl(value[2]) &lt;&lt; (32 * 1)) + \
                            (socket.ntohl(value[3]))
                    addr = IPv6Address(v)

                d_val.append(addr.compressed)
            else:
                for v in value:
                    d_val.append(_pb2dict_cast(field, v, pretty, is_hex))
        else:
            d_val = _pb2dict_cast(field, value, pretty, is_hex)

        try:
            d[field.name] = d_val.decode()
        except (UnicodeDecodeError, AttributeError):
            d[field.name] = d_val
    return d


def _dict2pb_cast(field, value):
    # Not considering TYPE_MESSAGE here, as repeated
    # and non-repeated messages need special treatment
    # in this case, and are handled separately.
    if field.type == FD.TYPE_BYTES:
        return get_bytes_dec(field)(value)
    elif field.type == FD.TYPE_ENUM:
        return field.enum_type.values_by_name.get(value, None).number
    elif field.type in _basic_cast:
        cast = _basic_cast[field.type]
        if cast is int and is_string(value):
            if _marked_as_dev(field):
                return encode_dev(field, value)

            flags = _marked_as_flags(field)
            if flags:
                try:
                    flags_map = flags_maps[flags]
                except Exception:
                    pass  # Try to use plain string cast
                else:
                    return unmap_flags(value, flags_map)

            dct = _marked_as_dict(field)
            if dct:
                ret = dict_maps[dct][1][field.name].get(value, None)
                if ret is None:
                    ret = cast(value, 0)
                return ret

            # Some int or long fields might be stored as hex
            # strings. See _pb2dict_cast.
            return cast(value, 0)
        else:
            return cast(value)
    else:
        raise Exception(&quot;Field(%s) has unsupported type %d&quot; %
                        (field.name, field.type))


def dict2pb(d, pb):
    &quot;&quot;&quot;
    Convert dictionary to protobuf msg.
    Takes dict and protobuf message to be merged into.
    &quot;&quot;&quot;
    for field in pb.DESCRIPTOR.fields:
        if field.name not in d:
            continue
        value = d[field.name]
        if field.label == FD.LABEL_REPEATED:
            pb_val = getattr(pb, field.name, None)
            if is_string(value[0]) and _marked_as_ip(field):
                val = ip_address(value[0])
                if val.version == 4:
                    pb_val.append(socket.htonl(int(val)))
                elif val.version == 6:
                    ival = int(val)
                    pb_val.append(socket.htonl((ival &gt;&gt; (32 * 3)) &amp; 0xFFFFFFFF))
                    pb_val.append(socket.htonl((ival &gt;&gt; (32 * 2)) &amp; 0xFFFFFFFF))
                    pb_val.append(socket.htonl((ival &gt;&gt; (32 * 1)) &amp; 0xFFFFFFFF))
                    pb_val.append(socket.htonl((ival &gt;&gt; (32 * 0)) &amp; 0xFFFFFFFF))
                else:
                    raise Exception(&quot;Unknown IP address version %d&quot; %
                                    val.version)
                continue

            for v in value:
                if field.type == FD.TYPE_MESSAGE:
                    dict2pb(v, pb_val.add())
                else:
                    pb_val.append(_dict2pb_cast(field, v))
        else:
            if field.type == FD.TYPE_MESSAGE:
                # SetInParent method acts just like has_* = true in C,
                # and helps to properly treat cases when we have optional
                # field with empty repeated inside.
                getattr(pb, field.name).SetInParent()

                dict2pb(value, getattr(pb, field.name, None))
            else:
                setattr(pb, field.name, _dict2pb_cast(field, value))
    return pb
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib/python3.6/site-packages/pycriu/images/pb2dict.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flib%2Fpython3.6%2Fsite-packages%2Fpycriu%2Fimages' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>