155 |
/* decode offset */ |
/* decode offset */ |
156 |
/* length pair */ |
/* length pair */ |
157 |
walker <<= 1; |
walker <<= 1; |
158 |
if (--walker_len < 2) |
if (--walker_len < (ctype & RDP_MPPC_BIG ? 3 : 2)) |
159 |
{ |
{ |
160 |
if (i >= clen) |
if (i >= clen) |
161 |
return -1; |
return -1; |
162 |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
163 |
walker_len += 8; |
walker_len += 8; |
164 |
} |
} |
165 |
/* offset decoding where offset len is: |
|
166 |
-63: 1111 followed by the lower 6 bits of the value |
if (ctype & RDP_MPPC_BIG) |
|
64-319: 1110 followed by the lower 8 bits of the value ( value - 64 ) |
|
|
320-8191: 110 followed by the lower 13 bits of the value ( value - 320 ) |
|
|
*/ |
|
|
switch (((uint32) walker) >> ((uint32) 30)) |
|
167 |
{ |
{ |
168 |
case 3: /* - 63 */ |
/* offset decoding where offset len is: |
169 |
if (walker_len < 8) |
-63: 11111 followed by the lower 6 bits of the value |
170 |
{ |
64-319: 11110 followed by the lower 8 bits of the value ( value - 64 ) |
171 |
if (i >= clen) |
320-2367: 1110 followed by lower 11 bits of the value ( value - 320 ) |
172 |
return -1; |
2368-65535: 110 followed by lower 16 bits of the value ( value - 2368 ) |
173 |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
*/ |
174 |
walker_len += 8; |
switch (((uint32) walker) >> ((uint32) 29)) |
175 |
} |
{ |
176 |
walker <<= 2; |
case 7: /* - 63 */ |
177 |
match_off = ((uint32) walker) >> ((uint32) 26); |
for (; walker_len < 9; walker_len += 8) |
178 |
walker <<= 6; |
{ |
179 |
walker_len -= 8; |
if (i >= clen) |
180 |
break; |
return -1; |
181 |
|
walker |= (data[i++] & 0xff) << (24 - walker_len); |
182 |
|
} |
183 |
|
walker <<= 3; |
184 |
|
match_off = ((uint32) walker) >> ((uint32) 26); |
185 |
|
walker <<= 6; |
186 |
|
walker_len -= 9; |
187 |
|
break; |
188 |
|
|
189 |
case 2: /* 64 - 319 */ |
case 6: /* 64 - 319 */ |
190 |
for (; walker_len < 10; walker_len += 8) |
for (; walker_len < 11; walker_len += 8) |
191 |
{ |
{ |
192 |
if (i >= clen) |
if (i >= clen) |
193 |
return -1; |
return -1; |
194 |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
195 |
} |
} |
196 |
|
|
197 |
walker <<= 2; |
walker <<= 3; |
198 |
match_off = (((uint32) walker) >> ((uint32) 24)) + 64; |
match_off = (((uint32) walker) >> ((uint32) 24)) + 64; |
199 |
walker <<= 8; |
walker <<= 8; |
200 |
walker_len -= 10; |
walker_len -= 11; |
201 |
break; |
break; |
202 |
|
|
203 |
default: /* 320 - 8191 */ |
case 5: |
204 |
for (; walker_len < 14; walker_len += 8) |
case 4: /* 320 - 2367 */ |
205 |
{ |
for (; walker_len < 13; walker_len += 8) |
206 |
if (i >= clen) |
{ |
207 |
return -1; |
if (i >= clen) |
208 |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
return -1; |
209 |
} |
walker |= (data[i++] & 0xff) << (24 - walker_len); |
210 |
|
} |
211 |
|
|
212 |
match_off = (walker >> 18) + 320; |
walker <<= 2; |
213 |
walker <<= 14; |
match_off = (((uint32) walker) >> ((uint32) 21)) + 320; |
214 |
walker_len -= 14; |
walker <<= 11; |
215 |
break; |
walker_len -= 13; |
216 |
|
break; |
217 |
|
|
218 |
|
default: /* 2368 - 65535 */ |
219 |
|
for (; walker_len < 17; walker_len += 8) |
220 |
|
{ |
221 |
|
if (i >= clen) |
222 |
|
return -1; |
223 |
|
walker |= (data[i++] & 0xff) << (24 - walker_len); |
224 |
|
} |
225 |
|
|
226 |
|
walker <<= 1; |
227 |
|
match_off = (((uint32) walker) >> ((uint32) 16)) + 2368; |
228 |
|
walker <<= 16; |
229 |
|
walker_len -= 17; |
230 |
|
break; |
231 |
|
} |
232 |
|
} |
233 |
|
else |
234 |
|
{ |
235 |
|
/* offset decoding where offset len is: |
236 |
|
-63: 1111 followed by the lower 6 bits of the value |
237 |
|
64-319: 1110 followed by the lower 8 bits of the value ( value - 64 ) |
238 |
|
320-8191: 110 followed by the lower 13 bits of the value ( value - 320 ) |
239 |
|
*/ |
240 |
|
switch (((uint32) walker) >> ((uint32) 30)) |
241 |
|
{ |
242 |
|
case 3: /* - 63 */ |
243 |
|
if (walker_len < 8) |
244 |
|
{ |
245 |
|
if (i >= clen) |
246 |
|
return -1; |
247 |
|
walker |= (data[i++] & 0xff) << (24 - walker_len); |
248 |
|
walker_len += 8; |
249 |
|
} |
250 |
|
walker <<= 2; |
251 |
|
match_off = ((uint32) walker) >> ((uint32) 26); |
252 |
|
walker <<= 6; |
253 |
|
walker_len -= 8; |
254 |
|
break; |
255 |
|
|
256 |
|
case 2: /* 64 - 319 */ |
257 |
|
for (; walker_len < 10; walker_len += 8) |
258 |
|
{ |
259 |
|
if (i >= clen) |
260 |
|
return -1; |
261 |
|
walker |= (data[i++] & 0xff) << (24 - walker_len); |
262 |
|
} |
263 |
|
|
264 |
|
walker <<= 2; |
265 |
|
match_off = (((uint32) walker) >> ((uint32) 24)) + 64; |
266 |
|
walker <<= 8; |
267 |
|
walker_len -= 10; |
268 |
|
break; |
269 |
|
|
270 |
|
default: /* 320 - 8191 */ |
271 |
|
for (; walker_len < 14; walker_len += 8) |
272 |
|
{ |
273 |
|
if (i >= clen) |
274 |
|
return -1; |
275 |
|
walker |= (data[i++] & 0xff) << (24 - walker_len); |
276 |
|
} |
277 |
|
|
278 |
|
match_off = (walker >> 18) + 320; |
279 |
|
walker <<= 14; |
280 |
|
walker_len -= 14; |
281 |
|
break; |
282 |
|
} |
283 |
} |
} |
284 |
if (walker_len == 0) |
if (walker_len == 0) |
285 |
{ |
{ |
360 |
return -1; |
return -1; |
361 |
} |
} |
362 |
/* memory areas can overlap - meaning we can't use memXXX functions */ |
/* memory areas can overlap - meaning we can't use memXXX functions */ |
363 |
k = (next_offset - match_off) & (RDP_MPPC_DICT_SIZE - 1); |
k = (next_offset - match_off) & (ctype & RDP_MPPC_BIG ? 65535 : 8191); |
364 |
do |
do |
365 |
{ |
{ |
366 |
dict[next_offset++] = dict[k++]; |
dict[next_offset++] = dict[k++]; |