← Back to branch summary

~cyphermox/ubuntu/natty/ofono/release-0.41

« back to all changes in this revision

Viewing changes to gisi/iter.c

  • Committer: Mathieu Trudel-Lapierre
  • Date: 2011-02-11 02:17:20 UTC
  • mfrom: (1.3.2 upstream)
  • Revision ID: mathieu-tl@ubuntu.com-20110211021720-cvxc3erw1keomunj
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gisi/iter.c
45
45
        mnc[3] = '\0';
46
46
}
47
47
 
48
 
void g_isi_sb_iter_init_full(GIsiSubBlockIter *iter, const void *restrict data,
49
 
                                size_t len, size_t used, gboolean longhdr,
 
48
void g_isi_sb_iter_init_full(GIsiSubBlockIter *iter, const GIsiMessage *msg,
 
49
                                size_t used, gboolean longhdr,
50
50
                                uint16_t sub_blocks)
51
51
{
52
 
        if (!data)
 
52
        const uint8_t *data = g_isi_msg_data(msg);
 
53
        size_t len = g_isi_msg_data_len(msg);
 
54
 
 
55
        if (data == NULL)
53
56
                len = used = 0;
54
57
 
55
58
        iter->start = (uint8_t *)data + used;
58
61
        iter->sub_blocks = len > used ? sub_blocks : 0;
59
62
}
60
63
 
61
 
void g_isi_sb_iter_init(GIsiSubBlockIter *iter, const void *restrict data,
62
 
                        size_t len, size_t used)
 
64
void g_isi_sb_iter_init(GIsiSubBlockIter *iter, const GIsiMessage *msg,
 
65
                        size_t used)
63
66
{
64
 
        if (!data)
 
67
        const uint8_t *data = g_isi_msg_data(msg);
 
68
        size_t len = g_isi_msg_data_len(msg);
 
69
 
 
70
        if (data == NULL)
65
71
                len = used = 0;
66
72
 
67
73
        iter->start = (uint8_t *)data + used;
70
76
        iter->sub_blocks = len > used ? iter->start[-1] : 0;
71
77
}
72
78
 
 
79
void g_isi_sb_subiter_init(GIsiSubBlockIter *outer, GIsiSubBlockIter *inner,
 
80
                                size_t used)
 
81
{
 
82
        size_t len = g_isi_sb_iter_get_len(outer);
 
83
 
 
84
        if (outer->start + len > outer->end ||
 
85
                        outer->start + used > outer->end)
 
86
                len = used = 0;
 
87
 
 
88
        inner->start = outer->start + used;
 
89
        inner->end = inner->start + len;
 
90
        inner->longhdr = FALSE;
 
91
        inner->sub_blocks = len > used ? inner->start[-1] : 0;
 
92
}
 
93
 
 
94
void g_isi_sb_subiter_init_full(GIsiSubBlockIter *outer,
 
95
                                GIsiSubBlockIter *inner, size_t used,
 
96
                                gboolean longhdr, uint16_t sub_blocks)
 
97
{
 
98
        size_t len = g_isi_sb_iter_get_len(outer);
 
99
 
 
100
        if (outer->start + len > outer->end ||
 
101
                        outer->start + used > outer->end)
 
102
                len = used = 0;
 
103
 
 
104
        inner->start = outer->start + used;
 
105
        inner->end = inner->start + len;
 
106
        inner->longhdr = longhdr;
 
107
        inner->sub_blocks = len > used ? sub_blocks : 0;
 
108
}
 
109
 
73
110
gboolean g_isi_sb_iter_is_valid(const GIsiSubBlockIter *iter)
74
111
{
75
 
        if (!iter)
 
112
        if (iter == NULL)
76
113
                return FALSE;
77
114
 
78
115
        if (iter->sub_blocks == 0)
90
127
int g_isi_sb_iter_get_id(const GIsiSubBlockIter *iter)
91
128
{
92
129
        if (iter->longhdr)
93
 
                return (iter->start[0] << 8) | (iter->start[1]);
 
130
                return (iter->start[0] << 8) | iter->start[1];
 
131
 
94
132
        return iter->start[0];
95
133
}
96
134
 
97
135
size_t g_isi_sb_iter_get_len(const GIsiSubBlockIter *iter)
98
136
{
99
137
        if (iter->longhdr)
100
 
                return (iter->start[2] << 8) | (iter->start[3]);
 
138
                return (iter->start[2] << 8) | iter->start[3];
 
139
 
101
140
        return iter->start[1];
102
141
}
103
142
 
105
144
                                void **data, unsigned pos)
106
145
{
107
146
        if ((size_t)pos > g_isi_sb_iter_get_len(iter)
108
 
                || iter->start + pos > iter->end)
 
147
                        || iter->start + pos > iter->end)
109
148
                return FALSE;
 
149
 
110
150
        *data = (void *)iter->start + pos;
111
151
        return TRUE;
112
152
}
115
155
                                uint8_t *byte, unsigned pos)
116
156
{
117
157
        if ((size_t)pos > g_isi_sb_iter_get_len(iter)
118
 
                || iter->start + pos > iter->end)
 
158
                        || iter->start + pos > iter->end)
119
159
                return FALSE;
 
160
 
120
161
        *byte = iter->start[pos];
121
162
        return TRUE;
122
163
}
165
206
        if (pos > g_isi_sb_iter_get_len(iter))
166
207
                return FALSE;
167
208
 
168
 
        if (!utf8 || len == 0 || pos + len > g_isi_sb_iter_get_len(iter))
 
209
        if (utf8 == NULL || len == 0 || pos + len > g_isi_sb_iter_get_len(iter))
169
210
                return FALSE;
170
211
 
171
212
        ucs2 = iter->start + pos;
 
213
 
172
214
        if (ucs2 + len > iter->end)
173
215
                return FALSE;
174
216
 
185
227
        if (pos > g_isi_sb_iter_get_len(iter))
186
228
                return FALSE;
187
229
 
188
 
        if (!latin || len == 0 || pos + len > g_isi_sb_iter_get_len(iter))
 
230
        if (latin == NULL || len == 0)
 
231
                return FALSE;
 
232
 
 
233
        if (pos + len > g_isi_sb_iter_get_len(iter))
189
234
                return FALSE;
190
235
 
191
236
        str = iter->start + pos;
 
237
 
192
238
        if (str + len > iter->end)
193
239
                return FALSE;
194
240
 
215
261
 
216
262
        return TRUE;
217
263
}
 
264
 
 
265
gboolean g_isi_sb_iter_get_struct(const GIsiSubBlockIter *restrict iter,
 
266
                                        void **type, size_t len, unsigned pos)
 
267
{
 
268
        if (iter->start + pos + len > iter->end)
 
269
                return FALSE;
 
270
 
 
271
        return g_isi_sb_iter_get_data(iter, type, pos);
 
272
}