← Back to branch summary

~ubuntu-branches/ubuntu/wily/ryu/wily-proposed

« back to all changes in this revision

Viewing changes to .pc/fix-i386-test-failures.patch/ryu/ofproto/oxx_fields.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-09-30 15:19:31 UTC
  • Revision ID: package-import@ubuntu.com-20150930151931-xt0c5qliex2mz1r5
Tags: 3.24-1ubuntu2
d/p/fix-i386-test-failures.patch: Fixup misc i386 issues due to
differences in use of long and int depending on architecture in use.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix-i386-test-failures.patch/ryu/ofproto/oxx_fields.py
 
1
# Copyright (C) 2015 Nippon Telegraph and Telephone Corporation.
 
2
#
 
3
# Licensed under the Apache License, Version 2.0 (the "License");
 
4
# you may not use this file except in compliance with the License.
 
5
# You may obtain a copy of the License at
 
6
#
 
7
#    http://www.apache.org/licenses/LICENSE-2.0
 
8
#
 
9
# Unless required by applicable law or agreed to in writing, software
 
10
# distributed under the License is distributed on an "AS IS" BASIS,
 
11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 
12
# implied.
 
13
# See the License for the specific language governing permissions and
 
14
# limitations under the License.
 
15
 
 
16
# there are two representations of value and mask this module deal with.
 
17
#
 
18
# "user"
 
19
#   (value, mask) or value.  the latter means no mask.
 
20
#   value and mask are strings.
 
21
#
 
22
# "internal"
 
23
#   value and mask are on-wire bytes.
 
24
#   mask is None if no mask.
 
25
 
 
26
import itertools
 
27
import six
 
28
import struct
 
29
 
 
30
from ryu.ofproto import ofproto_common
 
31
from ryu.lib.pack_utils import msg_pack_into
 
32
from ryu.lib import type_desc
 
33
 
 
34
if six.PY3:
 
35
    _ord = int
 
36
else:
 
37
    _ord = ord
 
38
 
 
39
# 'OFPXXC_EXPERIMENTER' has not corresponding field in the specification.
 
40
# This is transparently value for Experimenter class ID for OXM/OXS.
 
41
OFPXXC_EXPERIMENTER = 0xffff
 
42
 
 
43
 
 
44
def _get_field_info_by_name(oxx, name_to_field, name):
 
45
    try:
 
46
        f = name_to_field[name]
 
47
        t = f.type
 
48
        num = f.num
 
49
    except KeyError:
 
50
        t = type_desc.UnknownType
 
51
        if name.startswith('field_'):
 
52
            num = int(name.split('_')[1])
 
53
        else:
 
54
            raise KeyError('unknown %s field: %s' % (oxx.upper(), name))
 
55
    return num, t
 
56
 
 
57
 
 
58
def _from_user_header(oxx, name_to_field, name):
 
59
    (num, t) = _get_field_info_by_name(oxx, name_to_field, name)
 
60
    return num
 
61
 
 
62
 
 
63
def _from_user(oxx, name_to_field, name, user_value):
 
64
    (num, t) = _get_field_info_by_name(oxx, name_to_field, name)
 
65
    # the 'list' case below is a bit hack; json.dumps silently maps
 
66
    # python tuples into json lists.
 
67
    if oxx == 'oxm' and isinstance(user_value, (tuple, list)):
 
68
        (value, mask) = user_value
 
69
    else:
 
70
        value = user_value
 
71
        mask = None
 
72
    if value is not None:
 
73
        value = t.from_user(value)
 
74
    if mask is not None:
 
75
        mask = t.from_user(mask)
 
76
    return num, value, mask
 
77
 
 
78
 
 
79
def _get_field_info_by_number(oxx, num_to_field, n):
 
80
    try:
 
81
        f = num_to_field[n]
 
82
        t = f.type
 
83
        name = f.name
 
84
    except KeyError:
 
85
        t = type_desc.UnknownType
 
86
        if isinstance(n, int):
 
87
            name = 'field_%d' % (n,)
 
88
        else:
 
89
            raise KeyError('unknown %s field number: %s' % (oxx.upper(), n))
 
90
    return name, t
 
91
 
 
92
 
 
93
def _to_user_header(oxx, num_to_field, n):
 
94
    (name, t) = _get_field_info_by_number(oxx, num_to_field, n)
 
95
    return name
 
96
 
 
97
 
 
98
def _to_user(oxx, num_to_field, n, v, m):
 
99
    (name, t) = _get_field_info_by_number(oxx, num_to_field, n)
 
100
    if v is not None:
 
101
        if isinstance(v, (tuple, list)):
 
102
            v_len = len(v) * len(v[0])
 
103
        else:
 
104
            v_len = len(v)
 
105
        if hasattr(t, 'size') and t.size != v_len:
 
106
            raise Exception(
 
107
                'Unexpected %s payload length %d for %s (expected %d)'
 
108
                % (oxx.upper(), v_len, name, t.size))
 
109
        value = t.to_user(v)
 
110
    else:
 
111
        value = None
 
112
    if m is None:
 
113
        user_value = value
 
114
    else:
 
115
        user_value = (value, t.to_user(m))
 
116
    return name, user_value
 
117
 
 
118
 
 
119
def _field_desc(num_to_field, n):
 
120
    return num_to_field[n]
 
121
 
 
122
 
 
123
def _normalize_user(oxx, mod, k, uv):
 
124
    try:
 
125
        from_user = getattr(mod, oxx + '_from_user')
 
126
        (n, v, m) = from_user(k, uv)
 
127
    except:
 
128
        return (k, uv)
 
129
    # apply mask
 
130
    if m is not None:
 
131
        v = b''.join(six.int2byte(_ord(x) & _ord(y)) for (x, y) in zip(v, m))
 
132
    try:
 
133
        to_user = getattr(mod, oxx + '_to_user')
 
134
        (k2, uv2) = to_user(n, v, m)
 
135
    except:
 
136
        return (k, uv)
 
137
    assert k2 == k
 
138
    return (k2, uv2)
 
139
 
 
140
 
 
141
def _parse_header_impl(mod, buf, offset):
 
142
    hdr_pack_str = '!I'
 
143
    (header, ) = struct.unpack_from(hdr_pack_str, buf, offset)
 
144
    hdr_len = struct.calcsize(hdr_pack_str)
 
145
    oxx_type = header >> 9  # class|field
 
146
    oxm_hasmask = mod.oxm_tlv_header_extract_hasmask(header)
 
147
    oxx_class = oxx_type >> 7
 
148
    oxx_length = header & 0xff
 
149
    if oxx_class == OFPXXC_EXPERIMENTER:
 
150
        # Experimenter OXMs/OXSs have 64-bit header.
 
151
        # (vs 32-bit for other OXMs/OXSs)
 
152
        exp_hdr_pack_str = '!I'  # experimenter_id
 
153
        (exp_id, ) = struct.unpack_from(exp_hdr_pack_str, buf,
 
154
                                        offset + hdr_len)
 
155
        exp_hdr_len = struct.calcsize(exp_hdr_pack_str)
 
156
        assert exp_hdr_len == 4
 
157
        oxx_field = oxx_type & 0x7f
 
158
        if exp_id == ofproto_common.ONF_EXPERIMENTER_ID and oxx_field == 0:
 
159
            # XXX
 
160
            # This block implements EXT-256 style experimenter OXM.
 
161
            onf_exp_type_pack_str = '!H'
 
162
            (exp_type, ) = struct.unpack_from(onf_exp_type_pack_str, buf,
 
163
                                              offset + hdr_len + exp_hdr_len)
 
164
            exp_hdr_len += struct.calcsize(onf_exp_type_pack_str)
 
165
            assert exp_hdr_len == 4 + 2
 
166
            num = (exp_id, exp_type)
 
167
        else:
 
168
            num = (exp_id, oxx_type)
 
169
    else:
 
170
        num = oxx_type
 
171
        exp_hdr_len = 0
 
172
    value_len = oxx_length - exp_hdr_len
 
173
    if oxm_hasmask:
 
174
        value_len //= 2
 
175
    assert value_len > 0
 
176
    field_len = hdr_len + oxx_length
 
177
    total_hdr_len = hdr_len + exp_hdr_len
 
178
    return num, total_hdr_len, oxm_hasmask, value_len, field_len
 
179
 
 
180
 
 
181
def _parse_header(mod, buf, offset):
 
182
    (oxx_type_num, total_hdr_len, hasmask, value_len,
 
183
     field_len) = _parse_header_impl(mod, buf, offset)
 
184
    return oxx_type_num, field_len - value_len
 
185
 
 
186
 
 
187
def _parse(mod, buf, offset):
 
188
    (oxx_type_num, total_hdr_len, hasmask, value_len,
 
189
     field_len) = _parse_header_impl(mod, buf, offset)
 
190
    # Note: OXM/OXS payload length (oxx_len) includes Experimenter ID
 
191
    # (exp_hdr_len) for experimenter OXMs/OXSs.
 
192
    value_offset = offset + total_hdr_len
 
193
    value_pack_str = '!%ds' % value_len
 
194
    assert struct.calcsize(value_pack_str) == value_len
 
195
    (value, ) = struct.unpack_from(value_pack_str, buf, value_offset)
 
196
    if hasmask:
 
197
        (mask, ) = struct.unpack_from(value_pack_str, buf,
 
198
                                      value_offset + value_len)
 
199
    else:
 
200
        mask = None
 
201
    return oxx_type_num, value, mask, field_len
 
202
 
 
203
 
 
204
def _make_exp_hdr(oxx, mod, n):
 
205
    exp_hdr = bytearray()
 
206
    try:
 
207
        get_desc = getattr(mod, '_' + oxx + '_field_desc')
 
208
        desc = get_desc(n)
 
209
    except KeyError:
 
210
        return n, exp_hdr
 
211
    if desc._class == OFPXXC_EXPERIMENTER:
 
212
        (exp_id, exp_type) = n
 
213
        assert desc.experimenter_id == exp_id
 
214
        oxx_type = getattr(desc, oxx + '_type')
 
215
        if desc.exp_type == 2560:
 
216
            # XXX
 
217
            # This block implements EXT-256 style experimenter OXM.
 
218
            exp_hdr_pack_str = '!IH'  # experimenter_id, exp_type
 
219
            msg_pack_into(exp_hdr_pack_str, exp_hdr, 0,
 
220
                          desc.experimenter_id, desc.exp_type)
 
221
        else:
 
222
            assert oxx_type == exp_type | (OFPXXC_EXPERIMENTER << 7)
 
223
            exp_hdr_pack_str = '!I'  # experimenter_id
 
224
            msg_pack_into(exp_hdr_pack_str, exp_hdr, 0,
 
225
                          desc.experimenter_id)
 
226
        assert len(exp_hdr) == struct.calcsize(exp_hdr_pack_str)
 
227
        n = oxx_type
 
228
        assert (n >> 7) == OFPXXC_EXPERIMENTER
 
229
    return n, exp_hdr
 
230
 
 
231
 
 
232
def _serialize_header(oxx, mod, n, buf, offset):
 
233
    try:
 
234
        get_desc = getattr(mod, '_' + oxx + '_field_desc')
 
235
        desc = get_desc(n)
 
236
        value_len = desc.type.size
 
237
    except KeyError:
 
238
        value_len = 0
 
239
    n, exp_hdr = _make_exp_hdr(oxx, mod, n)
 
240
    exp_hdr_len = len(exp_hdr)
 
241
    pack_str = "!I%ds" % (exp_hdr_len,)
 
242
    msg_pack_into(pack_str, buf, offset,
 
243
                  (n << 9) | (0 << 8) | (exp_hdr_len + value_len),
 
244
                  bytes(exp_hdr))
 
245
    return struct.calcsize(pack_str)
 
246
 
 
247
 
 
248
def _serialize(oxx, mod, n, value, mask, buf, offset):
 
249
    n, exp_hdr = _make_exp_hdr(oxx, mod, n)
 
250
    exp_hdr_len = len(exp_hdr)
 
251
    value_len = len(value)
 
252
    if mask:
 
253
        assert value_len == len(mask)
 
254
        pack_str = "!I%ds%ds%ds" % (exp_hdr_len, value_len, len(mask))
 
255
        msg_pack_into(pack_str, buf, offset,
 
256
                      (n << 9) | (1 << 8) | (exp_hdr_len + value_len * 2),
 
257
                      bytes(exp_hdr), value, mask)
 
258
    else:
 
259
        pack_str = "!I%ds%ds" % (exp_hdr_len, value_len,)
 
260
        msg_pack_into(pack_str, buf, offset,
 
261
                      (n << 9) | (0 << 8) | (exp_hdr_len + value_len),
 
262
                      bytes(exp_hdr), value)
 
263
    return struct.calcsize(pack_str)