1
2
3
4#line 20 "include/asm-generic/int-ll64.h"
5typedef unsigned char __u8;
6#line 23 "include/asm-generic/int-ll64.h"
7typedef unsigned short __u16;
8#line 26 "include/asm-generic/int-ll64.h"
9typedef unsigned int __u32;
10#line 30 "include/asm-generic/int-ll64.h"
11typedef unsigned long long __u64;
12#line 43 "include/asm-generic/int-ll64.h"
13typedef unsigned char u8;
14#line 45 "include/asm-generic/int-ll64.h"
15typedef short s16;
16#line 46 "include/asm-generic/int-ll64.h"
17typedef unsigned short u16;
18#line 49 "include/asm-generic/int-ll64.h"
19typedef unsigned int u32;
20#line 52 "include/asm-generic/int-ll64.h"
21typedef unsigned long long u64;
22#line 14 "include/asm-generic/posix_types.h"
23typedef long __kernel_long_t;
24#line 15 "include/asm-generic/posix_types.h"
25typedef unsigned long __kernel_ulong_t;
26#line 75 "include/asm-generic/posix_types.h"
27typedef __kernel_ulong_t __kernel_size_t;
28#line 76 "include/asm-generic/posix_types.h"
29typedef __kernel_long_t __kernel_ssize_t;
30#line 27 "include/linux/types.h"
31typedef unsigned short umode_t;
32#line 63 "include/linux/types.h"
33typedef __kernel_size_t size_t;
34#line 68 "include/linux/types.h"
35typedef __kernel_ssize_t ssize_t;
36#line 92 "include/linux/types.h"
37typedef unsigned char u_char;
38#line 155 "include/linux/types.h"
39typedef u64 dma_addr_t;
40#line 179 "include/linux/types.h"
41typedef __u16 __be16;
42#line 202 "include/linux/types.h"
43typedef unsigned int gfp_t;
44#line 219 "include/linux/types.h"
45struct __anonstruct_atomic_t_7 {
46 int counter ;
47};
48#line 219 "include/linux/types.h"
49typedef struct __anonstruct_atomic_t_7 atomic_t;
50#line 224 "include/linux/types.h"
51struct __anonstruct_atomic64_t_8 {
52 long counter ;
53};
54#line 224 "include/linux/types.h"
55typedef struct __anonstruct_atomic64_t_8 atomic64_t;
56#line 229 "include/linux/types.h"
57struct list_head {
58 struct list_head *next ;
59 struct list_head *prev ;
60};
61#line 56 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/alternative.h"
62struct module;
63#line 56
64struct module;
65#line 146 "include/linux/init.h"
66typedef void (*ctor_fn_t)(void);
67#line 18 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/page.h"
68struct page;
69#line 18
70struct page;
71#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/thread_info.h"
72struct task_struct;
73#line 20
74struct task_struct;
75#line 7 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
76struct task_struct;
77#line 46 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt_types.h"
78struct page;
79#line 52
80struct task_struct;
81#line 329
82struct arch_spinlock;
83#line 329
84struct arch_spinlock;
85#line 139 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/ptrace.h"
86struct task_struct;
87#line 8 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/current.h"
88struct task_struct;
89#line 10 "include/asm-generic/bug.h"
90struct bug_entry {
91 int bug_addr_disp ;
92 int file_disp ;
93 unsigned short line ;
94 unsigned short flags ;
95};
96#line 234 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt.h"
97struct static_key;
98#line 234
99struct static_key;
100#line 433 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
101struct kmem_cache;
102#line 23 "include/asm-generic/atomic-long.h"
103typedef atomic64_t atomic_long_t;
104#line 14 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
105typedef u16 __ticket_t;
106#line 15 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
107typedef u32 __ticketpair_t;
108#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
109struct __raw_tickets {
110 __ticket_t head ;
111 __ticket_t tail ;
112};
113#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
114union __anonunion____missing_field_name_36 {
115 __ticketpair_t head_tail ;
116 struct __raw_tickets tickets ;
117};
118#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
119struct arch_spinlock {
120 union __anonunion____missing_field_name_36 __annonCompField17 ;
121};
122#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
123typedef struct arch_spinlock arch_spinlock_t;
124#line 12 "include/linux/lockdep.h"
125struct task_struct;
126#line 20 "include/linux/spinlock_types.h"
127struct raw_spinlock {
128 arch_spinlock_t raw_lock ;
129 unsigned int magic ;
130 unsigned int owner_cpu ;
131 void *owner ;
132};
133#line 64 "include/linux/spinlock_types.h"
134union __anonunion____missing_field_name_39 {
135 struct raw_spinlock rlock ;
136};
137#line 64 "include/linux/spinlock_types.h"
138struct spinlock {
139 union __anonunion____missing_field_name_39 __annonCompField19 ;
140};
141#line 64 "include/linux/spinlock_types.h"
142typedef struct spinlock spinlock_t;
143#line 55 "include/linux/wait.h"
144struct task_struct;
145#line 60 "include/linux/pageblock-flags.h"
146struct page;
147#line 48 "include/linux/mutex.h"
148struct mutex {
149 atomic_t count ;
150 spinlock_t wait_lock ;
151 struct list_head wait_list ;
152 struct task_struct *owner ;
153 char const *name ;
154 void *magic ;
155};
156#line 9 "include/linux/memory_hotplug.h"
157struct page;
158#line 994 "include/linux/mmzone.h"
159struct page;
160#line 270 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/elf.h"
161struct task_struct;
162#line 18 "include/linux/elf.h"
163typedef __u64 Elf64_Addr;
164#line 19 "include/linux/elf.h"
165typedef __u16 Elf64_Half;
166#line 23 "include/linux/elf.h"
167typedef __u32 Elf64_Word;
168#line 24 "include/linux/elf.h"
169typedef __u64 Elf64_Xword;
170#line 194 "include/linux/elf.h"
171struct elf64_sym {
172 Elf64_Word st_name ;
173 unsigned char st_info ;
174 unsigned char st_other ;
175 Elf64_Half st_shndx ;
176 Elf64_Addr st_value ;
177 Elf64_Xword st_size ;
178};
179#line 194 "include/linux/elf.h"
180typedef struct elf64_sym Elf64_Sym;
181#line 20 "include/linux/kobject_ns.h"
182struct sock;
183#line 20
184struct sock;
185#line 21
186struct kobject;
187#line 21
188struct kobject;
189#line 27
190enum kobj_ns_type {
191 KOBJ_NS_TYPE_NONE = 0,
192 KOBJ_NS_TYPE_NET = 1,
193 KOBJ_NS_TYPES = 2
194} ;
195#line 40 "include/linux/kobject_ns.h"
196struct kobj_ns_type_operations {
197 enum kobj_ns_type type ;
198 void *(*grab_current_ns)(void) ;
199 void const *(*netlink_ns)(struct sock *sk ) ;
200 void const *(*initial_ns)(void) ;
201 void (*drop_ns)(void * ) ;
202};
203#line 22 "include/linux/sysfs.h"
204struct kobject;
205#line 23
206struct module;
207#line 24
208enum kobj_ns_type;
209#line 26 "include/linux/sysfs.h"
210struct attribute {
211 char const *name ;
212 umode_t mode ;
213};
214#line 112 "include/linux/sysfs.h"
215struct sysfs_ops {
216 ssize_t (*show)(struct kobject * , struct attribute * , char * ) ;
217 ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ;
218 void const *(*namespace)(struct kobject * , struct attribute const * ) ;
219};
220#line 118
221struct sysfs_dirent;
222#line 118
223struct sysfs_dirent;
224#line 22 "include/linux/kref.h"
225struct kref {
226 atomic_t refcount ;
227};
228#line 60 "include/linux/kobject.h"
229struct kset;
230#line 60
231struct kobj_type;
232#line 60 "include/linux/kobject.h"
233struct kobject {
234 char const *name ;
235 struct list_head entry ;
236 struct kobject *parent ;
237 struct kset *kset ;
238 struct kobj_type *ktype ;
239 struct sysfs_dirent *sd ;
240 struct kref kref ;
241 unsigned int state_initialized : 1 ;
242 unsigned int state_in_sysfs : 1 ;
243 unsigned int state_add_uevent_sent : 1 ;
244 unsigned int state_remove_uevent_sent : 1 ;
245 unsigned int uevent_suppress : 1 ;
246};
247#line 108 "include/linux/kobject.h"
248struct kobj_type {
249 void (*release)(struct kobject *kobj ) ;
250 struct sysfs_ops const *sysfs_ops ;
251 struct attribute **default_attrs ;
252 struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject *kobj ) ;
253 void const *(*namespace)(struct kobject *kobj ) ;
254};
255#line 116 "include/linux/kobject.h"
256struct kobj_uevent_env {
257 char *envp[32] ;
258 int envp_idx ;
259 char buf[2048] ;
260 int buflen ;
261};
262#line 123 "include/linux/kobject.h"
263struct kset_uevent_ops {
264 int (* const filter)(struct kset *kset , struct kobject *kobj ) ;
265 char const *(* const name)(struct kset *kset , struct kobject *kobj ) ;
266 int (* const uevent)(struct kset *kset , struct kobject *kobj , struct kobj_uevent_env *env ) ;
267};
268#line 140
269struct sock;
270#line 159 "include/linux/kobject.h"
271struct kset {
272 struct list_head list ;
273 spinlock_t list_lock ;
274 struct kobject kobj ;
275 struct kset_uevent_ops const *uevent_ops ;
276};
277#line 39 "include/linux/moduleparam.h"
278struct kernel_param;
279#line 39
280struct kernel_param;
281#line 41 "include/linux/moduleparam.h"
282struct kernel_param_ops {
283 int (*set)(char const *val , struct kernel_param const *kp ) ;
284 int (*get)(char *buffer , struct kernel_param const *kp ) ;
285 void (*free)(void *arg ) ;
286};
287#line 50
288struct kparam_string;
289#line 50
290struct kparam_array;
291#line 50 "include/linux/moduleparam.h"
292union __anonunion____missing_field_name_199 {
293 void *arg ;
294 struct kparam_string const *str ;
295 struct kparam_array const *arr ;
296};
297#line 50 "include/linux/moduleparam.h"
298struct kernel_param {
299 char const *name ;
300 struct kernel_param_ops const *ops ;
301 u16 perm ;
302 s16 level ;
303 union __anonunion____missing_field_name_199 __annonCompField32 ;
304};
305#line 63 "include/linux/moduleparam.h"
306struct kparam_string {
307 unsigned int maxlen ;
308 char *string ;
309};
310#line 69 "include/linux/moduleparam.h"
311struct kparam_array {
312 unsigned int max ;
313 unsigned int elemsize ;
314 unsigned int *num ;
315 struct kernel_param_ops const *ops ;
316 void *elem ;
317};
318#line 445
319struct module;
320#line 80 "include/linux/jump_label.h"
321struct module;
322#line 143 "include/linux/jump_label.h"
323struct static_key {
324 atomic_t enabled ;
325};
326#line 22 "include/linux/tracepoint.h"
327struct module;
328#line 23
329struct tracepoint;
330#line 23
331struct tracepoint;
332#line 25 "include/linux/tracepoint.h"
333struct tracepoint_func {
334 void *func ;
335 void *data ;
336};
337#line 30 "include/linux/tracepoint.h"
338struct tracepoint {
339 char const *name ;
340 struct static_key key ;
341 void (*regfunc)(void) ;
342 void (*unregfunc)(void) ;
343 struct tracepoint_func *funcs ;
344};
345#line 19 "include/linux/export.h"
346struct kernel_symbol {
347 unsigned long value ;
348 char const *name ;
349};
350#line 8 "include/asm-generic/module.h"
351struct mod_arch_specific {
352
353};
354#line 35 "include/linux/module.h"
355struct module;
356#line 37
357struct module_param_attrs;
358#line 37 "include/linux/module.h"
359struct module_kobject {
360 struct kobject kobj ;
361 struct module *mod ;
362 struct kobject *drivers_dir ;
363 struct module_param_attrs *mp ;
364};
365#line 44 "include/linux/module.h"
366struct module_attribute {
367 struct attribute attr ;
368 ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ;
369 ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * ,
370 size_t count ) ;
371 void (*setup)(struct module * , char const * ) ;
372 int (*test)(struct module * ) ;
373 void (*free)(struct module * ) ;
374};
375#line 71
376struct exception_table_entry;
377#line 71
378struct exception_table_entry;
379#line 199
380enum module_state {
381 MODULE_STATE_LIVE = 0,
382 MODULE_STATE_COMING = 1,
383 MODULE_STATE_GOING = 2
384} ;
385#line 215 "include/linux/module.h"
386struct module_ref {
387 unsigned long incs ;
388 unsigned long decs ;
389} __attribute__((__aligned__((2) * (sizeof(unsigned long )) ))) ;
390#line 220
391struct module_sect_attrs;
392#line 220
393struct module_notes_attrs;
394#line 220
395struct ftrace_event_call;
396#line 220 "include/linux/module.h"
397struct module {
398 enum module_state state ;
399 struct list_head list ;
400 char name[64UL - sizeof(unsigned long )] ;
401 struct module_kobject mkobj ;
402 struct module_attribute *modinfo_attrs ;
403 char const *version ;
404 char const *srcversion ;
405 struct kobject *holders_dir ;
406 struct kernel_symbol const *syms ;
407 unsigned long const *crcs ;
408 unsigned int num_syms ;
409 struct kernel_param *kp ;
410 unsigned int num_kp ;
411 unsigned int num_gpl_syms ;
412 struct kernel_symbol const *gpl_syms ;
413 unsigned long const *gpl_crcs ;
414 struct kernel_symbol const *unused_syms ;
415 unsigned long const *unused_crcs ;
416 unsigned int num_unused_syms ;
417 unsigned int num_unused_gpl_syms ;
418 struct kernel_symbol const *unused_gpl_syms ;
419 unsigned long const *unused_gpl_crcs ;
420 struct kernel_symbol const *gpl_future_syms ;
421 unsigned long const *gpl_future_crcs ;
422 unsigned int num_gpl_future_syms ;
423 unsigned int num_exentries ;
424 struct exception_table_entry *extable ;
425 int (*init)(void) ;
426 void *module_init ;
427 void *module_core ;
428 unsigned int init_size ;
429 unsigned int core_size ;
430 unsigned int init_text_size ;
431 unsigned int core_text_size ;
432 unsigned int init_ro_size ;
433 unsigned int core_ro_size ;
434 struct mod_arch_specific arch ;
435 unsigned int taints ;
436 unsigned int num_bugs ;
437 struct list_head bug_list ;
438 struct bug_entry *bug_table ;
439 Elf64_Sym *symtab ;
440 Elf64_Sym *core_symtab ;
441 unsigned int num_symtab ;
442 unsigned int core_num_syms ;
443 char *strtab ;
444 char *core_strtab ;
445 struct module_sect_attrs *sect_attrs ;
446 struct module_notes_attrs *notes_attrs ;
447 char *args ;
448 void *percpu ;
449 unsigned int percpu_size ;
450 unsigned int num_tracepoints ;
451 struct tracepoint * const *tracepoints_ptrs ;
452 unsigned int num_trace_bprintk_fmt ;
453 char const **trace_bprintk_fmt_start ;
454 struct ftrace_event_call **trace_events ;
455 unsigned int num_trace_events ;
456 struct list_head source_list ;
457 struct list_head target_list ;
458 struct task_struct *waiter ;
459 void (*exit)(void) ;
460 struct module_ref *refptr ;
461 ctor_fn_t *ctors ;
462 unsigned int num_ctors ;
463};
464#line 46 "include/linux/slub_def.h"
465struct kmem_cache_cpu {
466 void **freelist ;
467 unsigned long tid ;
468 struct page *page ;
469 struct page *partial ;
470 int node ;
471 unsigned int stat[26] ;
472};
473#line 57 "include/linux/slub_def.h"
474struct kmem_cache_node {
475 spinlock_t list_lock ;
476 unsigned long nr_partial ;
477 struct list_head partial ;
478 atomic_long_t nr_slabs ;
479 atomic_long_t total_objects ;
480 struct list_head full ;
481};
482#line 73 "include/linux/slub_def.h"
483struct kmem_cache_order_objects {
484 unsigned long x ;
485};
486#line 80 "include/linux/slub_def.h"
487struct kmem_cache {
488 struct kmem_cache_cpu *cpu_slab ;
489 unsigned long flags ;
490 unsigned long min_partial ;
491 int size ;
492 int objsize ;
493 int offset ;
494 int cpu_partial ;
495 struct kmem_cache_order_objects oo ;
496 struct kmem_cache_order_objects max ;
497 struct kmem_cache_order_objects min ;
498 gfp_t allocflags ;
499 int refcount ;
500 void (*ctor)(void * ) ;
501 int inuse ;
502 int align ;
503 int reserved ;
504 char const *name ;
505 struct list_head list ;
506 struct kobject kobj ;
507 int remote_node_defrag_ratio ;
508 struct kmem_cache_node *node[1 << 10] ;
509};
510#line 94 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/uaccess.h"
511struct exception_table_entry {
512 unsigned long insn ;
513 unsigned long fixup ;
514};
515#line 116 "include/linux/crypto.h"
516struct scatterlist;
517#line 116
518struct scatterlist;
519#line 117
520struct crypto_ablkcipher;
521#line 117
522struct crypto_ablkcipher;
523#line 118
524struct crypto_async_request;
525#line 118
526struct crypto_async_request;
527#line 119
528struct crypto_aead;
529#line 119
530struct crypto_aead;
531#line 120
532struct crypto_blkcipher;
533#line 120
534struct crypto_blkcipher;
535#line 121
536struct crypto_hash;
537#line 121
538struct crypto_hash;
539#line 122
540struct crypto_rng;
541#line 122
542struct crypto_rng;
543#line 123
544struct crypto_tfm;
545#line 123
546struct crypto_tfm;
547#line 124
548struct crypto_type;
549#line 124
550struct crypto_type;
551#line 125
552struct aead_givcrypt_request;
553#line 125
554struct aead_givcrypt_request;
555#line 126
556struct skcipher_givcrypt_request;
557#line 126
558struct skcipher_givcrypt_request;
559#line 130 "include/linux/crypto.h"
560struct crypto_async_request {
561 struct list_head list ;
562 void (*complete)(struct crypto_async_request *req , int err ) ;
563 void *data ;
564 struct crypto_tfm *tfm ;
565 u32 flags ;
566};
567#line 139 "include/linux/crypto.h"
568struct ablkcipher_request {
569 struct crypto_async_request base ;
570 unsigned int nbytes ;
571 void *info ;
572 struct scatterlist *src ;
573 struct scatterlist *dst ;
574 void *__ctx[] __attribute__((__aligned__(__alignof__(unsigned long long )))) ;
575};
576#line 163 "include/linux/crypto.h"
577struct aead_request {
578 struct crypto_async_request base ;
579 unsigned int assoclen ;
580 unsigned int cryptlen ;
581 u8 *iv ;
582 struct scatterlist *assoc ;
583 struct scatterlist *src ;
584 struct scatterlist *dst ;
585 void *__ctx[] __attribute__((__aligned__(__alignof__(unsigned long long )))) ;
586};
587#line 178 "include/linux/crypto.h"
588struct blkcipher_desc {
589 struct crypto_blkcipher *tfm ;
590 void *info ;
591 u32 flags ;
592};
593#line 192 "include/linux/crypto.h"
594struct hash_desc {
595 struct crypto_hash *tfm ;
596 u32 flags ;
597};
598#line 201 "include/linux/crypto.h"
599struct ablkcipher_alg {
600 int (*setkey)(struct crypto_ablkcipher *tfm , u8 const *key , unsigned int keylen ) ;
601 int (*encrypt)(struct ablkcipher_request *req ) ;
602 int (*decrypt)(struct ablkcipher_request *req ) ;
603 int (*givencrypt)(struct skcipher_givcrypt_request *req ) ;
604 int (*givdecrypt)(struct skcipher_givcrypt_request *req ) ;
605 char const *geniv ;
606 unsigned int min_keysize ;
607 unsigned int max_keysize ;
608 unsigned int ivsize ;
609};
610#line 216 "include/linux/crypto.h"
611struct aead_alg {
612 int (*setkey)(struct crypto_aead *tfm , u8 const *key , unsigned int keylen ) ;
613 int (*setauthsize)(struct crypto_aead *tfm , unsigned int authsize ) ;
614 int (*encrypt)(struct aead_request *req ) ;
615 int (*decrypt)(struct aead_request *req ) ;
616 int (*givencrypt)(struct aead_givcrypt_request *req ) ;
617 int (*givdecrypt)(struct aead_givcrypt_request *req ) ;
618 char const *geniv ;
619 unsigned int ivsize ;
620 unsigned int maxauthsize ;
621};
622#line 231 "include/linux/crypto.h"
623struct blkcipher_alg {
624 int (*setkey)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ) ;
625 int (*encrypt)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
626 unsigned int nbytes ) ;
627 int (*decrypt)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
628 unsigned int nbytes ) ;
629 char const *geniv ;
630 unsigned int min_keysize ;
631 unsigned int max_keysize ;
632 unsigned int ivsize ;
633};
634#line 248 "include/linux/crypto.h"
635struct cipher_alg {
636 unsigned int cia_min_keysize ;
637 unsigned int cia_max_keysize ;
638 int (*cia_setkey)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ) ;
639 void (*cia_encrypt)(struct crypto_tfm *tfm , u8 *dst , u8 const *src ) ;
640 void (*cia_decrypt)(struct crypto_tfm *tfm , u8 *dst , u8 const *src ) ;
641};
642#line 257 "include/linux/crypto.h"
643struct compress_alg {
644 int (*coa_compress)(struct crypto_tfm *tfm , u8 const *src , unsigned int slen ,
645 u8 *dst , unsigned int *dlen ) ;
646 int (*coa_decompress)(struct crypto_tfm *tfm , u8 const *src , unsigned int slen ,
647 u8 *dst , unsigned int *dlen ) ;
648};
649#line 264 "include/linux/crypto.h"
650struct rng_alg {
651 int (*rng_make_random)(struct crypto_rng *tfm , u8 *rdata , unsigned int dlen ) ;
652 int (*rng_reset)(struct crypto_rng *tfm , u8 *seed , unsigned int slen ) ;
653 unsigned int seedsize ;
654};
655#line 280 "include/linux/crypto.h"
656union __anonunion_cra_u_201 {
657 struct ablkcipher_alg ablkcipher ;
658 struct aead_alg aead ;
659 struct blkcipher_alg blkcipher ;
660 struct cipher_alg cipher ;
661 struct compress_alg compress ;
662 struct rng_alg rng ;
663};
664#line 280 "include/linux/crypto.h"
665struct crypto_alg {
666 struct list_head cra_list ;
667 struct list_head cra_users ;
668 u32 cra_flags ;
669 unsigned int cra_blocksize ;
670 unsigned int cra_ctxsize ;
671 unsigned int cra_alignmask ;
672 int cra_priority ;
673 atomic_t cra_refcnt ;
674 char cra_name[64] ;
675 char cra_driver_name[64] ;
676 struct crypto_type const *cra_type ;
677 union __anonunion_cra_u_201 cra_u ;
678 int (*cra_init)(struct crypto_tfm *tfm ) ;
679 void (*cra_exit)(struct crypto_tfm *tfm ) ;
680 void (*cra_destroy)(struct crypto_alg *alg ) ;
681 struct module *cra_module ;
682};
683#line 332 "include/linux/crypto.h"
684struct ablkcipher_tfm {
685 int (*setkey)(struct crypto_ablkcipher *tfm , u8 const *key , unsigned int keylen ) ;
686 int (*encrypt)(struct ablkcipher_request *req ) ;
687 int (*decrypt)(struct ablkcipher_request *req ) ;
688 int (*givencrypt)(struct skcipher_givcrypt_request *req ) ;
689 int (*givdecrypt)(struct skcipher_givcrypt_request *req ) ;
690 struct crypto_ablkcipher *base ;
691 unsigned int ivsize ;
692 unsigned int reqsize ;
693};
694#line 346 "include/linux/crypto.h"
695struct aead_tfm {
696 int (*setkey)(struct crypto_aead *tfm , u8 const *key , unsigned int keylen ) ;
697 int (*encrypt)(struct aead_request *req ) ;
698 int (*decrypt)(struct aead_request *req ) ;
699 int (*givencrypt)(struct aead_givcrypt_request *req ) ;
700 int (*givdecrypt)(struct aead_givcrypt_request *req ) ;
701 struct crypto_aead *base ;
702 unsigned int ivsize ;
703 unsigned int authsize ;
704 unsigned int reqsize ;
705};
706#line 361 "include/linux/crypto.h"
707struct blkcipher_tfm {
708 void *iv ;
709 int (*setkey)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ) ;
710 int (*encrypt)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
711 unsigned int nbytes ) ;
712 int (*decrypt)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
713 unsigned int nbytes ) ;
714};
715#line 371 "include/linux/crypto.h"
716struct cipher_tfm {
717 int (*cit_setkey)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ) ;
718 void (*cit_encrypt_one)(struct crypto_tfm *tfm , u8 *dst , u8 const *src ) ;
719 void (*cit_decrypt_one)(struct crypto_tfm *tfm , u8 *dst , u8 const *src ) ;
720};
721#line 378 "include/linux/crypto.h"
722struct hash_tfm {
723 int (*init)(struct hash_desc *desc ) ;
724 int (*update)(struct hash_desc *desc , struct scatterlist *sg , unsigned int nsg ) ;
725 int (*final)(struct hash_desc *desc , u8 *out ) ;
726 int (*digest)(struct hash_desc *desc , struct scatterlist *sg , unsigned int nsg ,
727 u8 *out ) ;
728 int (*setkey)(struct crypto_hash *tfm , u8 const *key , unsigned int keylen ) ;
729 unsigned int digestsize ;
730};
731#line 390 "include/linux/crypto.h"
732struct compress_tfm {
733 int (*cot_compress)(struct crypto_tfm *tfm , u8 const *src , unsigned int slen ,
734 u8 *dst , unsigned int *dlen ) ;
735 int (*cot_decompress)(struct crypto_tfm *tfm , u8 const *src , unsigned int slen ,
736 u8 *dst , unsigned int *dlen ) ;
737};
738#line 399 "include/linux/crypto.h"
739struct rng_tfm {
740 int (*rng_gen_random)(struct crypto_rng *tfm , u8 *rdata , unsigned int dlen ) ;
741 int (*rng_reset)(struct crypto_rng *tfm , u8 *seed , unsigned int slen ) ;
742};
743#line 413 "include/linux/crypto.h"
744union __anonunion_crt_u_202 {
745 struct ablkcipher_tfm ablkcipher ;
746 struct aead_tfm aead ;
747 struct blkcipher_tfm blkcipher ;
748 struct cipher_tfm cipher ;
749 struct hash_tfm hash ;
750 struct compress_tfm compress ;
751 struct rng_tfm rng ;
752};
753#line 413 "include/linux/crypto.h"
754struct crypto_tfm {
755 u32 crt_flags ;
756 union __anonunion_crt_u_202 crt_u ;
757 void (*exit)(struct crypto_tfm *tfm ) ;
758 struct crypto_alg *__crt_alg ;
759 void *__crt_ctx[] __attribute__((__aligned__(__alignof__(unsigned long long )))) ;
760};
761#line 434 "include/linux/crypto.h"
762struct crypto_ablkcipher {
763 struct crypto_tfm base ;
764};
765#line 438 "include/linux/crypto.h"
766struct crypto_aead {
767 struct crypto_tfm base ;
768};
769#line 442 "include/linux/crypto.h"
770struct crypto_blkcipher {
771 struct crypto_tfm base ;
772};
773#line 454 "include/linux/crypto.h"
774struct crypto_hash {
775 struct crypto_tfm base ;
776};
777#line 458 "include/linux/crypto.h"
778struct crypto_rng {
779 struct crypto_tfm base ;
780};
781#line 8 "include/linux/debug_locks.h"
782struct task_struct;
783#line 48
784struct task_struct;
785#line 23 "include/linux/mm_types.h"
786struct address_space;
787#line 23
788struct address_space;
789#line 40 "include/linux/mm_types.h"
790union __anonunion____missing_field_name_205 {
791 unsigned long index ;
792 void *freelist ;
793};
794#line 40 "include/linux/mm_types.h"
795struct __anonstruct____missing_field_name_209 {
796 unsigned int inuse : 16 ;
797 unsigned int objects : 15 ;
798 unsigned int frozen : 1 ;
799};
800#line 40 "include/linux/mm_types.h"
801union __anonunion____missing_field_name_208 {
802 atomic_t _mapcount ;
803 struct __anonstruct____missing_field_name_209 __annonCompField34 ;
804};
805#line 40 "include/linux/mm_types.h"
806struct __anonstruct____missing_field_name_207 {
807 union __anonunion____missing_field_name_208 __annonCompField35 ;
808 atomic_t _count ;
809};
810#line 40 "include/linux/mm_types.h"
811union __anonunion____missing_field_name_206 {
812 unsigned long counters ;
813 struct __anonstruct____missing_field_name_207 __annonCompField36 ;
814};
815#line 40 "include/linux/mm_types.h"
816struct __anonstruct____missing_field_name_204 {
817 union __anonunion____missing_field_name_205 __annonCompField33 ;
818 union __anonunion____missing_field_name_206 __annonCompField37 ;
819};
820#line 40 "include/linux/mm_types.h"
821struct __anonstruct____missing_field_name_211 {
822 struct page *next ;
823 int pages ;
824 int pobjects ;
825};
826#line 40 "include/linux/mm_types.h"
827union __anonunion____missing_field_name_210 {
828 struct list_head lru ;
829 struct __anonstruct____missing_field_name_211 __annonCompField39 ;
830};
831#line 40 "include/linux/mm_types.h"
832union __anonunion____missing_field_name_212 {
833 unsigned long private ;
834 struct kmem_cache *slab ;
835 struct page *first_page ;
836};
837#line 40 "include/linux/mm_types.h"
838struct page {
839 unsigned long flags ;
840 struct address_space *mapping ;
841 struct __anonstruct____missing_field_name_204 __annonCompField38 ;
842 union __anonunion____missing_field_name_210 __annonCompField40 ;
843 union __anonunion____missing_field_name_212 __annonCompField41 ;
844 unsigned long debug_flags ;
845} __attribute__((__aligned__((2) * (sizeof(unsigned long )) ))) ;
846#line 195 "include/linux/page-flags.h"
847struct page;
848#line 120 "include/linux/ppp_defs.h"
849struct compstat {
850 __u32 unc_bytes ;
851 __u32 unc_packets ;
852 __u32 comp_bytes ;
853 __u32 comp_packets ;
854 __u32 inc_bytes ;
855 __u32 inc_packets ;
856 __u32 in_count ;
857 __u32 bytes_out ;
858 double ratio ;
859};
860#line 13 "include/linux/ppp-comp.h"
861struct module;
862#line 33 "include/linux/ppp-comp.h"
863struct compressor {
864 int compress_proto ;
865 void *(*comp_alloc)(unsigned char *options , int opt_len ) ;
866 void (*comp_free)(void *state ) ;
867 int (*comp_init)(void *state , unsigned char *options , int opt_len , int unit ,
868 int opthdr , int debug ) ;
869 void (*comp_reset)(void *state ) ;
870 int (*compress)(void *state , unsigned char *rptr , unsigned char *obuf , int isize ,
871 int osize ) ;
872 void (*comp_stat)(void *state , struct compstat *stats ) ;
873 void *(*decomp_alloc)(unsigned char *options , int opt_len ) ;
874 void (*decomp_free)(void *state ) ;
875 int (*decomp_init)(void *state , unsigned char *options , int opt_len , int unit ,
876 int opthdr , int mru , int debug ) ;
877 void (*decomp_reset)(void *state ) ;
878 int (*decompress)(void *state , unsigned char *ibuf , int isize , unsigned char *obuf ,
879 int osize ) ;
880 void (*incomp)(void *state , unsigned char *ibuf , int icnt ) ;
881 void (*decomp_stat)(void *state , struct compstat *stats ) ;
882 struct module *owner ;
883 unsigned int comp_extra ;
884};
885#line 6 "include/asm-generic/scatterlist.h"
886struct scatterlist {
887 unsigned long sg_magic ;
888 unsigned long page_link ;
889 unsigned int offset ;
890 unsigned int length ;
891 dma_addr_t dma_address ;
892 unsigned int dma_length ;
893};
894#line 83 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
895struct sha_pad {
896 unsigned char sha_pad1[40] ;
897 unsigned char sha_pad2[40] ;
898};
899#line 98 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
900struct ppp_mppe_state {
901 struct crypto_blkcipher *arc4 ;
902 struct crypto_hash *sha1 ;
903 unsigned char *sha1_digest ;
904 unsigned char master_key[16] ;
905 unsigned char session_key[16] ;
906 unsigned int keylen ;
907 unsigned char bits ;
908 unsigned int ccount ;
909 unsigned int stateful ;
910 int discard ;
911 int sanity_errors ;
912 int unit ;
913 int debug ;
914 struct compstat stats ;
915};
916#line 1 "<compiler builtins>"
917
918#line 1
919long __builtin_expect(long val , long res ) ;
920#line 32 "include/linux/err.h"
921__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr ) __attribute__((__no_instrument_function__)) ;
922#line 32 "include/linux/err.h"
923__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr )
924{ long tmp ;
925 unsigned long __cil_tmp3 ;
926 int __cil_tmp4 ;
927 int __cil_tmp5 ;
928 int __cil_tmp6 ;
929 long __cil_tmp7 ;
930
931 {
932 {
933#line 34
934 __cil_tmp3 = (unsigned long )ptr;
935#line 34
936 __cil_tmp4 = __cil_tmp3 >= 0xfffffffffffff001UL;
937#line 34
938 __cil_tmp5 = ! __cil_tmp4;
939#line 34
940 __cil_tmp6 = ! __cil_tmp5;
941#line 34
942 __cil_tmp7 = (long )__cil_tmp6;
943#line 34
944 tmp = __builtin_expect(__cil_tmp7, 0L);
945 }
946#line 34
947 return (tmp);
948}
949}
950#line 46 "include/linux/swab.h"
951__inline static __u16 __fswab16(__u16 val ) __attribute__((__no_instrument_function__,
952__const__)) ;
953#line 46 "include/linux/swab.h"
954__inline static __u16 __fswab16(__u16 val )
955{ int __cil_tmp2 ;
956 int __cil_tmp3 ;
957 int __cil_tmp4 ;
958 int __cil_tmp5 ;
959 int __cil_tmp6 ;
960 int __cil_tmp7 ;
961 int __cil_tmp8 ;
962
963 {
964 {
965#line 51
966 __cil_tmp2 = (int )val;
967#line 51
968 __cil_tmp3 = __cil_tmp2 & 65280;
969#line 51
970 __cil_tmp4 = __cil_tmp3 >> 8;
971#line 51
972 __cil_tmp5 = (int )val;
973#line 51
974 __cil_tmp6 = __cil_tmp5 & 255;
975#line 51
976 __cil_tmp7 = __cil_tmp6 << 8;
977#line 51
978 __cil_tmp8 = __cil_tmp7 | __cil_tmp4;
979#line 51
980 return ((__u16 )__cil_tmp8);
981 }
982}
983}
984#line 100 "include/linux/printk.h"
985extern int ( printk)(char const *fmt , ...) ;
986#line 320 "include/linux/kernel.h"
987extern int ( sprintf)(char *buf , char const *fmt , ...) ;
988#line 61 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/page_64_types.h"
989extern unsigned long __phys_addr(unsigned long ) ;
990#line 34 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/string_64.h"
991extern void *__memcpy(void *to , void const *from , size_t len ) ;
992#line 55
993extern void *memset(void *s , int c , size_t n ) ;
994#line 152 "include/linux/mutex.h"
995void mutex_lock(struct mutex *lock ) ;
996#line 153
997int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock ) ;
998#line 154
999int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock ) ;
1000#line 168
1001int mutex_trylock(struct mutex *lock ) ;
1002#line 169
1003void mutex_unlock(struct mutex *lock ) ;
1004#line 170
1005int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) ;
1006#line 26 "include/linux/export.h"
1007extern struct module __this_module ;
1008#line 67 "include/linux/module.h"
1009int init_module(void) ;
1010#line 68
1011void cleanup_module(void) ;
1012#line 161 "include/linux/slab.h"
1013extern void kfree(void const * ) ;
1014#line 221 "include/linux/slub_def.h"
1015extern void *__kmalloc(size_t size , gfp_t flags ) ;
1016#line 268
1017__inline static void *( __attribute__((__always_inline__)) kmalloc)(size_t size ,
1018 gfp_t flags ) __attribute__((__no_instrument_function__)) ;
1019#line 268 "include/linux/slub_def.h"
1020__inline static void *( __attribute__((__always_inline__)) kmalloc)(size_t size ,
1021 gfp_t flags )
1022{ void *tmp___2 ;
1023
1024 {
1025 {
1026#line 283
1027 tmp___2 = __kmalloc(size, flags);
1028 }
1029#line 283
1030 return (tmp___2);
1031}
1032}
1033#line 349 "include/linux/slab.h"
1034__inline static void *kzalloc(size_t size , gfp_t flags ) __attribute__((__no_instrument_function__)) ;
1035#line 349 "include/linux/slab.h"
1036__inline static void *kzalloc(size_t size , gfp_t flags )
1037{ void *tmp ;
1038 unsigned int __cil_tmp4 ;
1039
1040 {
1041 {
1042#line 351
1043 __cil_tmp4 = flags | 32768U;
1044#line 351
1045 tmp = kmalloc(size, __cil_tmp4);
1046 }
1047#line 351
1048 return (tmp);
1049}
1050}
1051#line 324 "include/linux/crypto.h"
1052extern int crypto_has_alg(char const *name , u32 type , u32 mask ) ;
1053#line 492
1054extern struct crypto_tfm *crypto_alloc_base(char const *alg_name , u32 type , u32 mask ) ;
1055#line 493
1056extern void crypto_destroy_tfm(void *mem , struct crypto_tfm *tfm ) ;
1057#line 495
1058__inline static void crypto_free_tfm(struct crypto_tfm *tfm ) __attribute__((__no_instrument_function__)) ;
1059#line 495 "include/linux/crypto.h"
1060__inline static void crypto_free_tfm(struct crypto_tfm *tfm )
1061{ void *__cil_tmp2 ;
1062
1063 {
1064 {
1065#line 497
1066 __cil_tmp2 = (void *)tfm;
1067#line 497
1068 crypto_destroy_tfm(__cil_tmp2, tfm);
1069 }
1070#line 497
1071 return;
1072}
1073}
1074#line 871
1075__inline static struct crypto_blkcipher *__crypto_blkcipher_cast(struct crypto_tfm *tfm ) __attribute__((__no_instrument_function__)) ;
1076#line 871 "include/linux/crypto.h"
1077__inline static struct crypto_blkcipher *__crypto_blkcipher_cast(struct crypto_tfm *tfm )
1078{
1079
1080 {
1081#line 874
1082 return ((struct crypto_blkcipher *)tfm);
1083}
1084}
1085#line 884
1086__inline static struct crypto_blkcipher *crypto_alloc_blkcipher(char const *alg_name ,
1087 u32 type , u32 mask ) __attribute__((__no_instrument_function__)) ;
1088#line 884 "include/linux/crypto.h"
1089__inline static struct crypto_blkcipher *crypto_alloc_blkcipher(char const *alg_name ,
1090 u32 type , u32 mask )
1091{ struct crypto_tfm *tmp ;
1092 struct crypto_blkcipher *tmp___0 ;
1093
1094 {
1095 {
1096#line 887
1097 type = type & 4294967280U;
1098#line 888
1099 type = type | 4U;
1100#line 889
1101 mask = mask | 15U;
1102#line 891
1103 tmp = crypto_alloc_base(alg_name, type, mask);
1104#line 891
1105 tmp___0 = __crypto_blkcipher_cast(tmp);
1106 }
1107#line 891
1108 return (tmp___0);
1109}
1110}
1111#line 894
1112__inline static struct crypto_tfm *crypto_blkcipher_tfm(struct crypto_blkcipher *tfm ) __attribute__((__no_instrument_function__)) ;
1113#line 894 "include/linux/crypto.h"
1114__inline static struct crypto_tfm *crypto_blkcipher_tfm(struct crypto_blkcipher *tfm )
1115{
1116
1117 {
1118#line 897
1119 return ((struct crypto_tfm *)tfm);
1120}
1121}
1122#line 900
1123__inline static void crypto_free_blkcipher(struct crypto_blkcipher *tfm ) __attribute__((__no_instrument_function__)) ;
1124#line 900 "include/linux/crypto.h"
1125__inline static void crypto_free_blkcipher(struct crypto_blkcipher *tfm )
1126{ struct crypto_tfm *tmp ;
1127
1128 {
1129 {
1130#line 902
1131 tmp = crypto_blkcipher_tfm(tfm);
1132#line 902
1133 crypto_free_tfm(tmp);
1134 }
1135#line 903
1136 return;
1137}
1138}
1139#line 905
1140__inline static int crypto_has_blkcipher(char const *alg_name , u32 type , u32 mask ) __attribute__((__no_instrument_function__)) ;
1141#line 905 "include/linux/crypto.h"
1142__inline static int crypto_has_blkcipher(char const *alg_name , u32 type , u32 mask )
1143{ int tmp ;
1144
1145 {
1146 {
1147#line 907
1148 type = type & 4294967280U;
1149#line 908
1150 type = type | 4U;
1151#line 909
1152 mask = mask | 15U;
1153#line 911
1154 tmp = crypto_has_alg(alg_name, type, mask);
1155 }
1156#line 911
1157 return (tmp);
1158}
1159}
1160#line 919
1161__inline static struct blkcipher_tfm *crypto_blkcipher_crt(struct crypto_blkcipher *tfm ) __attribute__((__no_instrument_function__)) ;
1162#line 919 "include/linux/crypto.h"
1163__inline static struct blkcipher_tfm *crypto_blkcipher_crt(struct crypto_blkcipher *tfm )
1164{ struct crypto_tfm *tmp ;
1165 unsigned long __cil_tmp3 ;
1166 unsigned long __cil_tmp4 ;
1167
1168 {
1169 {
1170#line 922
1171 tmp = crypto_blkcipher_tfm(tfm);
1172 }
1173 {
1174#line 922
1175 __cil_tmp3 = (unsigned long )tmp;
1176#line 922
1177 __cil_tmp4 = __cil_tmp3 + 8;
1178#line 922
1179 return ((struct blkcipher_tfm *)__cil_tmp4);
1180 }
1181}
1182}
1183#line 965
1184__inline static int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm , u8 const *key ,
1185 unsigned int keylen ) __attribute__((__no_instrument_function__)) ;
1186#line 965 "include/linux/crypto.h"
1187__inline static int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm , u8 const *key ,
1188 unsigned int keylen )
1189{ struct blkcipher_tfm *tmp ;
1190 struct crypto_tfm *tmp___0 ;
1191 int tmp___1 ;
1192 unsigned long __cil_tmp7 ;
1193 unsigned long __cil_tmp8 ;
1194 int (*__cil_tmp9)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ) ;
1195
1196 {
1197 {
1198#line 968
1199 tmp = crypto_blkcipher_crt(tfm);
1200#line 968
1201 tmp___0 = crypto_blkcipher_tfm(tfm);
1202#line 968
1203 __cil_tmp7 = (unsigned long )tmp;
1204#line 968
1205 __cil_tmp8 = __cil_tmp7 + 8;
1206#line 968
1207 __cil_tmp9 = *((int (**)(struct crypto_tfm *tfm , u8 const *key , unsigned int keylen ))__cil_tmp8);
1208#line 968
1209 tmp___1 = (*__cil_tmp9)(tmp___0, key, keylen);
1210 }
1211#line 968
1212 return (tmp___1);
1213}
1214}
1215#line 972
1216__inline static int crypto_blkcipher_encrypt(struct blkcipher_desc *desc , struct scatterlist *dst ,
1217 struct scatterlist *src , unsigned int nbytes ) __attribute__((__no_instrument_function__)) ;
1218#line 972 "include/linux/crypto.h"
1219__inline static int crypto_blkcipher_encrypt(struct blkcipher_desc *desc , struct scatterlist *dst ,
1220 struct scatterlist *src , unsigned int nbytes )
1221{ struct blkcipher_tfm *tmp ;
1222 struct blkcipher_tfm *tmp___0 ;
1223 int tmp___1 ;
1224 struct crypto_blkcipher *__cil_tmp8 ;
1225 unsigned long __cil_tmp9 ;
1226 unsigned long __cil_tmp10 ;
1227 struct crypto_blkcipher *__cil_tmp11 ;
1228 unsigned long __cil_tmp12 ;
1229 unsigned long __cil_tmp13 ;
1230 int (*__cil_tmp14)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
1231 unsigned int nbytes ) ;
1232
1233 {
1234 {
1235#line 977
1236 __cil_tmp8 = *((struct crypto_blkcipher **)desc);
1237#line 977
1238 tmp = crypto_blkcipher_crt(__cil_tmp8);
1239#line 977
1240 __cil_tmp9 = (unsigned long )desc;
1241#line 977
1242 __cil_tmp10 = __cil_tmp9 + 8;
1243#line 977
1244 *((void **)__cil_tmp10) = *((void **)tmp);
1245#line 978
1246 __cil_tmp11 = *((struct crypto_blkcipher **)desc);
1247#line 978
1248 tmp___0 = crypto_blkcipher_crt(__cil_tmp11);
1249#line 978
1250 __cil_tmp12 = (unsigned long )tmp___0;
1251#line 978
1252 __cil_tmp13 = __cil_tmp12 + 16;
1253#line 978
1254 __cil_tmp14 = *((int (**)(struct blkcipher_desc *desc , struct scatterlist *dst ,
1255 struct scatterlist *src , unsigned int nbytes ))__cil_tmp13);
1256#line 978
1257 tmp___1 = (*__cil_tmp14)(desc, dst, src, nbytes);
1258 }
1259#line 978
1260 return (tmp___1);
1261}
1262}
1263#line 989
1264__inline static int crypto_blkcipher_decrypt(struct blkcipher_desc *desc , struct scatterlist *dst ,
1265 struct scatterlist *src , unsigned int nbytes ) __attribute__((__no_instrument_function__)) ;
1266#line 989 "include/linux/crypto.h"
1267__inline static int crypto_blkcipher_decrypt(struct blkcipher_desc *desc , struct scatterlist *dst ,
1268 struct scatterlist *src , unsigned int nbytes )
1269{ struct blkcipher_tfm *tmp ;
1270 struct blkcipher_tfm *tmp___0 ;
1271 int tmp___1 ;
1272 struct crypto_blkcipher *__cil_tmp8 ;
1273 unsigned long __cil_tmp9 ;
1274 unsigned long __cil_tmp10 ;
1275 struct crypto_blkcipher *__cil_tmp11 ;
1276 unsigned long __cil_tmp12 ;
1277 unsigned long __cil_tmp13 ;
1278 int (*__cil_tmp14)(struct blkcipher_desc *desc , struct scatterlist *dst , struct scatterlist *src ,
1279 unsigned int nbytes ) ;
1280
1281 {
1282 {
1283#line 994
1284 __cil_tmp8 = *((struct crypto_blkcipher **)desc);
1285#line 994
1286 tmp = crypto_blkcipher_crt(__cil_tmp8);
1287#line 994
1288 __cil_tmp9 = (unsigned long )desc;
1289#line 994
1290 __cil_tmp10 = __cil_tmp9 + 8;
1291#line 994
1292 *((void **)__cil_tmp10) = *((void **)tmp);
1293#line 995
1294 __cil_tmp11 = *((struct crypto_blkcipher **)desc);
1295#line 995
1296 tmp___0 = crypto_blkcipher_crt(__cil_tmp11);
1297#line 995
1298 __cil_tmp12 = (unsigned long )tmp___0;
1299#line 995
1300 __cil_tmp13 = __cil_tmp12 + 24;
1301#line 995
1302 __cil_tmp14 = *((int (**)(struct blkcipher_desc *desc , struct scatterlist *dst ,
1303 struct scatterlist *src , unsigned int nbytes ))__cil_tmp13);
1304#line 995
1305 tmp___1 = (*__cil_tmp14)(desc, dst, src, nbytes);
1306 }
1307#line 995
1308 return (tmp___1);
1309}
1310}
1311#line 1111
1312__inline static struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm ) __attribute__((__no_instrument_function__)) ;
1313#line 1111 "include/linux/crypto.h"
1314__inline static struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm )
1315{
1316
1317 {
1318#line 1113
1319 return ((struct crypto_hash *)tfm);
1320}
1321}
1322#line 1123
1323__inline static struct crypto_hash *crypto_alloc_hash(char const *alg_name , u32 type ,
1324 u32 mask ) __attribute__((__no_instrument_function__)) ;
1325#line 1123 "include/linux/crypto.h"
1326__inline static struct crypto_hash *crypto_alloc_hash(char const *alg_name , u32 type ,
1327 u32 mask )
1328{ struct crypto_tfm *tmp ;
1329 struct crypto_hash *tmp___0 ;
1330
1331 {
1332 {
1333#line 1126
1334 type = type & 4294967280U;
1335#line 1127
1336 mask = mask & 4294967280U;
1337#line 1128
1338 type = type | 8U;
1339#line 1129
1340 mask = mask | 14U;
1341#line 1131
1342 tmp = crypto_alloc_base(alg_name, type, mask);
1343#line 1131
1344 tmp___0 = __crypto_hash_cast(tmp);
1345 }
1346#line 1131
1347 return (tmp___0);
1348}
1349}
1350#line 1134
1351__inline static struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm ) __attribute__((__no_instrument_function__)) ;
1352#line 1134 "include/linux/crypto.h"
1353__inline static struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm )
1354{
1355
1356 {
1357#line 1136
1358 return ((struct crypto_tfm *)tfm);
1359}
1360}
1361#line 1139
1362__inline static void crypto_free_hash(struct crypto_hash *tfm ) __attribute__((__no_instrument_function__)) ;
1363#line 1139 "include/linux/crypto.h"
1364__inline static void crypto_free_hash(struct crypto_hash *tfm )
1365{ struct crypto_tfm *tmp ;
1366
1367 {
1368 {
1369#line 1141
1370 tmp = crypto_hash_tfm(tfm);
1371#line 1141
1372 crypto_free_tfm(tmp);
1373 }
1374#line 1142
1375 return;
1376}
1377}
1378#line 1144
1379__inline static int crypto_has_hash(char const *alg_name , u32 type , u32 mask ) __attribute__((__no_instrument_function__)) ;
1380#line 1144 "include/linux/crypto.h"
1381__inline static int crypto_has_hash(char const *alg_name , u32 type , u32 mask )
1382{ int tmp ;
1383
1384 {
1385 {
1386#line 1146
1387 type = type & 4294967280U;
1388#line 1147
1389 mask = mask & 4294967280U;
1390#line 1148
1391 type = type | 8U;
1392#line 1149
1393 mask = mask | 14U;
1394#line 1151
1395 tmp = crypto_has_alg(alg_name, type, mask);
1396 }
1397#line 1151
1398 return (tmp);
1399}
1400}
1401#line 1154
1402__inline static struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm ) __attribute__((__no_instrument_function__)) ;
1403#line 1154 "include/linux/crypto.h"
1404__inline static struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm )
1405{ struct crypto_tfm *tmp ;
1406 unsigned long __cil_tmp3 ;
1407 unsigned long __cil_tmp4 ;
1408
1409 {
1410 {
1411#line 1156
1412 tmp = crypto_hash_tfm(tfm);
1413 }
1414 {
1415#line 1156
1416 __cil_tmp3 = (unsigned long )tmp;
1417#line 1156
1418 __cil_tmp4 = __cil_tmp3 + 8;
1419#line 1156
1420 return ((struct hash_tfm *)__cil_tmp4);
1421 }
1422}
1423}
1424#line 1169
1425__inline static unsigned int crypto_hash_digestsize(struct crypto_hash *tfm ) __attribute__((__no_instrument_function__)) ;
1426#line 1169 "include/linux/crypto.h"
1427__inline static unsigned int crypto_hash_digestsize(struct crypto_hash *tfm )
1428{ struct hash_tfm *tmp ;
1429 unsigned long __cil_tmp3 ;
1430 unsigned long __cil_tmp4 ;
1431
1432 {
1433 {
1434#line 1171
1435 tmp = crypto_hash_crt(tfm);
1436 }
1437 {
1438#line 1171
1439 __cil_tmp3 = (unsigned long )tmp;
1440#line 1171
1441 __cil_tmp4 = __cil_tmp3 + 40;
1442#line 1171
1443 return (*((unsigned int *)__cil_tmp4));
1444 }
1445}
1446}
1447#line 1206
1448__inline static int crypto_hash_digest(struct hash_desc *desc , struct scatterlist *sg ,
1449 unsigned int nbytes , u8 *out ) __attribute__((__no_instrument_function__)) ;
1450#line 1206 "include/linux/crypto.h"
1451__inline static int crypto_hash_digest(struct hash_desc *desc , struct scatterlist *sg ,
1452 unsigned int nbytes , u8 *out )
1453{ struct hash_tfm *tmp ;
1454 int tmp___0 ;
1455 struct crypto_hash *__cil_tmp7 ;
1456 unsigned long __cil_tmp8 ;
1457 unsigned long __cil_tmp9 ;
1458 int (*__cil_tmp10)(struct hash_desc *desc , struct scatterlist *sg , unsigned int nsg ,
1459 u8 *out ) ;
1460
1461 {
1462 {
1463#line 1210
1464 __cil_tmp7 = *((struct crypto_hash **)desc);
1465#line 1210
1466 tmp = crypto_hash_crt(__cil_tmp7);
1467#line 1210
1468 __cil_tmp8 = (unsigned long )tmp;
1469#line 1210
1470 __cil_tmp9 = __cil_tmp8 + 24;
1471#line 1210
1472 __cil_tmp10 = *((int (**)(struct hash_desc *desc , struct scatterlist *sg , unsigned int nsg ,
1473 u8 *out ))__cil_tmp9);
1474#line 1210
1475 tmp___0 = (*__cil_tmp10)(desc, sg, nbytes, out);
1476 }
1477#line 1210
1478 return (tmp___0);
1479}
1480}
1481#line 180 "include/linux/ppp-comp.h"
1482extern int ppp_register_compressor(struct compressor * ) ;
1483#line 181
1484extern void ppp_unregister_compressor(struct compressor * ) ;
1485#line 57 "include/linux/scatterlist.h"
1486__inline static void sg_assign_page(struct scatterlist *sg , struct page *page ) __attribute__((__no_instrument_function__)) ;
1487#line 57 "include/linux/scatterlist.h"
1488__inline static void sg_assign_page(struct scatterlist *sg , struct page *page )
1489{ unsigned long page_link ;
1490 long tmp ;
1491 long tmp___0 ;
1492 long tmp___1 ;
1493 unsigned long __cil_tmp7 ;
1494 unsigned long __cil_tmp8 ;
1495 unsigned long __cil_tmp9 ;
1496 unsigned long __cil_tmp10 ;
1497 unsigned long __cil_tmp11 ;
1498 int __cil_tmp12 ;
1499 int __cil_tmp13 ;
1500 long __cil_tmp14 ;
1501 unsigned long __cil_tmp15 ;
1502 int __cil_tmp16 ;
1503 int __cil_tmp17 ;
1504 int __cil_tmp18 ;
1505 long __cil_tmp19 ;
1506 unsigned long __cil_tmp20 ;
1507 unsigned long __cil_tmp21 ;
1508 unsigned long __cil_tmp22 ;
1509 unsigned long __cil_tmp23 ;
1510 int __cil_tmp24 ;
1511 int __cil_tmp25 ;
1512 long __cil_tmp26 ;
1513 unsigned long __cil_tmp27 ;
1514 unsigned long __cil_tmp28 ;
1515 unsigned long __cil_tmp29 ;
1516
1517 {
1518#line 59
1519 __cil_tmp7 = (unsigned long )sg;
1520#line 59
1521 __cil_tmp8 = __cil_tmp7 + 8;
1522#line 59
1523 __cil_tmp9 = *((unsigned long *)__cil_tmp8);
1524#line 59
1525 page_link = __cil_tmp9 & 3UL;
1526 {
1527#line 65
1528 while (1) {
1529 while_continue: ;
1530 {
1531#line 65
1532 __cil_tmp10 = (unsigned long )page;
1533#line 65
1534 __cil_tmp11 = __cil_tmp10 & 3UL;
1535#line 65
1536 __cil_tmp12 = ! __cil_tmp11;
1537#line 65
1538 __cil_tmp13 = ! __cil_tmp12;
1539#line 65
1540 __cil_tmp14 = (long )__cil_tmp13;
1541#line 65
1542 tmp = __builtin_expect(__cil_tmp14, 0L);
1543 }
1544#line 65
1545 if (tmp) {
1546 {
1547#line 65
1548 while (1) {
1549 while_continue___0: ;
1550#line 65
1551 __asm__ volatile ("1:\tud2\n"
1552 ".pushsection __bug_table,\"a\"\n"
1553 "2:\t.long 1b - 2b, %c0 - 2b\n"
1554 "\t.word %c1, 0\n"
1555 "\t.org 2b+%c2\n"
1556 ".popsection": : "i" ("include/linux/scatterlist.h"),
1557 "i" (65), "i" (12UL));
1558 {
1559#line 65
1560 while (1) {
1561 while_continue___1: ;
1562 }
1563 while_break___1: ;
1564 }
1565#line 65
1566 goto while_break___0;
1567 }
1568 while_break___0: ;
1569 }
1570 } else {
1571
1572 }
1573#line 65
1574 goto while_break;
1575 }
1576 while_break: ;
1577 }
1578 {
1579#line 67
1580 while (1) {
1581 while_continue___2: ;
1582 {
1583#line 67
1584 __cil_tmp15 = *((unsigned long *)sg);
1585#line 67
1586 __cil_tmp16 = __cil_tmp15 != 2271560481UL;
1587#line 67
1588 __cil_tmp17 = ! __cil_tmp16;
1589#line 67
1590 __cil_tmp18 = ! __cil_tmp17;
1591#line 67
1592 __cil_tmp19 = (long )__cil_tmp18;
1593#line 67
1594 tmp___0 = __builtin_expect(__cil_tmp19, 0L);
1595 }
1596#line 67
1597 if (tmp___0) {
1598 {
1599#line 67
1600 while (1) {
1601 while_continue___3: ;
1602#line 67
1603 __asm__ volatile ("1:\tud2\n"
1604 ".pushsection __bug_table,\"a\"\n"
1605 "2:\t.long 1b - 2b, %c0 - 2b\n"
1606 "\t.word %c1, 0\n"
1607 "\t.org 2b+%c2\n"
1608 ".popsection": : "i" ("include/linux/scatterlist.h"),
1609 "i" (67), "i" (12UL));
1610 {
1611#line 67
1612 while (1) {
1613 while_continue___4: ;
1614 }
1615 while_break___4: ;
1616 }
1617#line 67
1618 goto while_break___3;
1619 }
1620 while_break___3: ;
1621 }
1622 } else {
1623
1624 }
1625#line 67
1626 goto while_break___2;
1627 }
1628 while_break___2: ;
1629 }
1630 {
1631#line 68
1632 while (1) {
1633 while_continue___5: ;
1634 {
1635#line 68
1636 __cil_tmp20 = (unsigned long )sg;
1637#line 68
1638 __cil_tmp21 = __cil_tmp20 + 8;
1639#line 68
1640 __cil_tmp22 = *((unsigned long *)__cil_tmp21);
1641#line 68
1642 __cil_tmp23 = __cil_tmp22 & 1UL;
1643#line 68
1644 __cil_tmp24 = ! __cil_tmp23;
1645#line 68
1646 __cil_tmp25 = ! __cil_tmp24;
1647#line 68
1648 __cil_tmp26 = (long )__cil_tmp25;
1649#line 68
1650 tmp___1 = __builtin_expect(__cil_tmp26, 0L);
1651 }
1652#line 68
1653 if (tmp___1) {
1654 {
1655#line 68
1656 while (1) {
1657 while_continue___6: ;
1658#line 68
1659 __asm__ volatile ("1:\tud2\n"
1660 ".pushsection __bug_table,\"a\"\n"
1661 "2:\t.long 1b - 2b, %c0 - 2b\n"
1662 "\t.word %c1, 0\n"
1663 "\t.org 2b+%c2\n"
1664 ".popsection": : "i" ("include/linux/scatterlist.h"),
1665 "i" (68), "i" (12UL));
1666 {
1667#line 68
1668 while (1) {
1669 while_continue___7: ;
1670 }
1671 while_break___7: ;
1672 }
1673#line 68
1674 goto while_break___6;
1675 }
1676 while_break___6: ;
1677 }
1678 } else {
1679
1680 }
1681#line 68
1682 goto while_break___5;
1683 }
1684 while_break___5: ;
1685 }
1686#line 70
1687 __cil_tmp27 = (unsigned long )sg;
1688#line 70
1689 __cil_tmp28 = __cil_tmp27 + 8;
1690#line 70
1691 __cil_tmp29 = (unsigned long )page;
1692#line 70
1693 *((unsigned long *)__cil_tmp28) = page_link | __cil_tmp29;
1694#line 71
1695 return;
1696}
1697}
1698#line 87
1699__inline static void sg_set_page(struct scatterlist *sg , struct page *page , unsigned int len ,
1700 unsigned int offset ) __attribute__((__no_instrument_function__)) ;
1701#line 87 "include/linux/scatterlist.h"
1702__inline static void sg_set_page(struct scatterlist *sg , struct page *page , unsigned int len ,
1703 unsigned int offset )
1704{ unsigned long __cil_tmp5 ;
1705 unsigned long __cil_tmp6 ;
1706 unsigned long __cil_tmp7 ;
1707 unsigned long __cil_tmp8 ;
1708
1709 {
1710 {
1711#line 90
1712 sg_assign_page(sg, page);
1713#line 91
1714 __cil_tmp5 = (unsigned long )sg;
1715#line 91
1716 __cil_tmp6 = __cil_tmp5 + 16;
1717#line 91
1718 *((unsigned int *)__cil_tmp6) = offset;
1719#line 92
1720 __cil_tmp7 = (unsigned long )sg;
1721#line 92
1722 __cil_tmp8 = __cil_tmp7 + 20;
1723#line 92
1724 *((unsigned int *)__cil_tmp8) = len;
1725 }
1726#line 93
1727 return;
1728}
1729}
1730#line 111
1731__inline static void sg_set_buf(struct scatterlist *sg , void const *buf , unsigned int buflen ) __attribute__((__no_instrument_function__)) ;
1732#line 111 "include/linux/scatterlist.h"
1733__inline static void sg_set_buf(struct scatterlist *sg , void const *buf , unsigned int buflen )
1734{ unsigned long tmp ;
1735 unsigned long __cil_tmp5 ;
1736 unsigned long __cil_tmp6 ;
1737 struct page *__cil_tmp7 ;
1738 struct page *__cil_tmp8 ;
1739 unsigned long __cil_tmp9 ;
1740 unsigned long __cil_tmp10 ;
1741 unsigned long __cil_tmp11 ;
1742 unsigned long __cil_tmp12 ;
1743 unsigned long __cil_tmp13 ;
1744 unsigned long __cil_tmp14 ;
1745 unsigned int __cil_tmp15 ;
1746
1747 {
1748 {
1749#line 114
1750 __cil_tmp5 = (unsigned long )buf;
1751#line 114
1752 tmp = __phys_addr(__cil_tmp5);
1753#line 114
1754 __cil_tmp6 = tmp >> 12;
1755#line 114
1756 __cil_tmp7 = (struct page *)0xffffea0000000000UL;
1757#line 114
1758 __cil_tmp8 = __cil_tmp7 + __cil_tmp6;
1759#line 114
1760 __cil_tmp9 = 1UL << 12;
1761#line 114
1762 __cil_tmp10 = __cil_tmp9 - 1UL;
1763#line 114
1764 __cil_tmp11 = ~ __cil_tmp10;
1765#line 114
1766 __cil_tmp12 = ~ __cil_tmp11;
1767#line 114
1768 __cil_tmp13 = (unsigned long )buf;
1769#line 114
1770 __cil_tmp14 = __cil_tmp13 & __cil_tmp12;
1771#line 114
1772 __cil_tmp15 = (unsigned int )__cil_tmp14;
1773#line 114
1774 sg_set_page(sg, __cil_tmp8, buflen, __cil_tmp15);
1775 }
1776#line 115
1777 return;
1778}
1779}
1780#line 206
1781extern void sg_init_table(struct scatterlist * , unsigned int ) ;
1782#line 52 "include/linux/unaligned/access_ok.h"
1783__inline static void put_unaligned_be16(u16 val , void *p ) __attribute__((__no_instrument_function__)) ;
1784#line 52 "include/linux/unaligned/access_ok.h"
1785__inline static void put_unaligned_be16(u16 val , void *p )
1786{ __u16 tmp ;
1787 __be16 *__cil_tmp4 ;
1788 int __cil_tmp5 ;
1789
1790 {
1791 {
1792#line 54
1793 tmp = __fswab16(val);
1794#line 54
1795 __cil_tmp4 = (__be16 *)p;
1796#line 54
1797 __cil_tmp5 = (int )tmp;
1798#line 54
1799 *__cil_tmp4 = (__be16 )__cil_tmp5;
1800 }
1801#line 55
1802 return;
1803}
1804}
1805#line 63 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1806static char const __mod_author63[42] __attribute__((__used__, __unused__, __section__(".modinfo"),
1807__aligned__(1))) =
1808#line 63 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1809 { (char const )'a', (char const )'u', (char const )'t', (char const )'h',
1810 (char const )'o', (char const )'r', (char const )'=', (char const )'F',
1811 (char const )'r', (char const )'a', (char const )'n', (char const )'k',
1812 (char const )' ', (char const )'C', (char const )'u', (char const )'s',
1813 (char const )'a', (char const )'c', (char const )'k', (char const )' ',
1814 (char const )'<', (char const )'f', (char const )'c', (char const )'u',
1815 (char const )'s', (char const )'a', (char const )'c', (char const )'k',
1816 (char const )'@', (char const )'f', (char const )'c', (char const )'u',
1817 (char const )'s', (char const )'a', (char const )'c', (char const )'k',
1818 (char const )'.', (char const )'c', (char const )'o', (char const )'m',
1819 (char const )'>', (char const )'\000'};
1820#line 64 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1821static char const __mod_description64[80] __attribute__((__used__, __unused__,
1822__section__(".modinfo"), __aligned__(1))) =
1823#line 64
1824 { (char const )'d', (char const )'e', (char const )'s', (char const )'c',
1825 (char const )'r', (char const )'i', (char const )'p', (char const )'t',
1826 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
1827 (char const )'P', (char const )'o', (char const )'i', (char const )'n',
1828 (char const )'t', (char const )'-', (char const )'t', (char const )'o',
1829 (char const )'-', (char const )'P', (char const )'o', (char const )'i',
1830 (char const )'n', (char const )'t', (char const )' ', (char const )'P',
1831 (char const )'r', (char const )'o', (char const )'t', (char const )'o',
1832 (char const )'c', (char const )'o', (char const )'l', (char const )' ',
1833 (char const )'M', (char const )'i', (char const )'c', (char const )'r',
1834 (char const )'o', (char const )'s', (char const )'o', (char const )'f',
1835 (char const )'t', (char const )' ', (char const )'P', (char const )'o',
1836 (char const )'i', (char const )'n', (char const )'t', (char const )'-',
1837 (char const )'t', (char const )'o', (char const )'-', (char const )'P',
1838 (char const )'o', (char const )'i', (char const )'n', (char const )'t',
1839 (char const )' ', (char const )'E', (char const )'n', (char const )'c',
1840 (char const )'r', (char const )'y', (char const )'p', (char const )'t',
1841 (char const )'i', (char const )'o', (char const )'n', (char const )' ',
1842 (char const )'s', (char const )'u', (char const )'p', (char const )'p',
1843 (char const )'o', (char const )'r', (char const )'t', (char const )'\000'};
1844#line 65 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1845static char const __mod_license65[21] __attribute__((__used__, __unused__, __section__(".modinfo"),
1846__aligned__(1))) =
1847#line 65
1848 { (char const )'l', (char const )'i', (char const )'c', (char const )'e',
1849 (char const )'n', (char const )'s', (char const )'e', (char const )'=',
1850 (char const )'D', (char const )'u', (char const )'a', (char const )'l',
1851 (char const )' ', (char const )'B', (char const )'S', (char const )'D',
1852 (char const )'/', (char const )'G', (char const )'P', (char const )'L',
1853 (char const )'\000'};
1854#line 66 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1855static char const __mod_alias66[22] __attribute__((__used__, __unused__, __section__(".modinfo"),
1856__aligned__(1))) =
1857#line 66
1858 { (char const )'a', (char const )'l', (char const )'i', (char const )'a',
1859 (char const )'s', (char const )'=', (char const )'p', (char const )'p',
1860 (char const )'p', (char const )'-', (char const )'c', (char const )'o',
1861 (char const )'m', (char const )'p', (char const )'r', (char const )'e',
1862 (char const )'s', (char const )'s', (char const )'-', (char const )'1',
1863 (char const )'8', (char const )'\000'};
1864#line 67 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1865static char const __mod_version67[14] __attribute__((__used__, __unused__, __section__(".modinfo"),
1866__aligned__(1))) =
1867#line 67
1868 { (char const )'v', (char const )'e', (char const )'r', (char const )'s',
1869 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
1870 (char const )'1', (char const )'.', (char const )'0', (char const )'.',
1871 (char const )'2', (char const )'\000'};
1872#line 69 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1873static unsigned int setup_sg(struct scatterlist *sg , void const *address , unsigned int length )
1874{
1875
1876 {
1877 {
1878#line 72
1879 sg_set_buf(sg, address, length);
1880 }
1881#line 73
1882 return (length);
1883}
1884}
1885#line 87 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1886static struct sha_pad *sha_pad ;
1887#line 89
1888__inline static void sha_pad_init(struct sha_pad *shapad ) __attribute__((__no_instrument_function__)) ;
1889#line 89 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1890__inline static void sha_pad_init(struct sha_pad *shapad )
1891{ unsigned long __cil_tmp2 ;
1892 unsigned long __cil_tmp3 ;
1893 unsigned long __cil_tmp4 ;
1894 unsigned long __cil_tmp5 ;
1895 unsigned char *__cil_tmp6 ;
1896 void *__cil_tmp7 ;
1897 unsigned long __cil_tmp8 ;
1898 unsigned long __cil_tmp9 ;
1899 unsigned long __cil_tmp10 ;
1900 unsigned long __cil_tmp11 ;
1901 unsigned char *__cil_tmp12 ;
1902 void *__cil_tmp13 ;
1903
1904 {
1905 {
1906#line 91
1907 __cil_tmp2 = 0 * 1UL;
1908#line 91
1909 __cil_tmp3 = 0 + __cil_tmp2;
1910#line 91
1911 __cil_tmp4 = (unsigned long )shapad;
1912#line 91
1913 __cil_tmp5 = __cil_tmp4 + __cil_tmp3;
1914#line 91
1915 __cil_tmp6 = (unsigned char *)__cil_tmp5;
1916#line 91
1917 __cil_tmp7 = (void *)__cil_tmp6;
1918#line 91
1919 memset(__cil_tmp7, 0, 40UL);
1920#line 92
1921 __cil_tmp8 = 0 * 1UL;
1922#line 92
1923 __cil_tmp9 = 40 + __cil_tmp8;
1924#line 92
1925 __cil_tmp10 = (unsigned long )shapad;
1926#line 92
1927 __cil_tmp11 = __cil_tmp10 + __cil_tmp9;
1928#line 92
1929 __cil_tmp12 = (unsigned char *)__cil_tmp11;
1930#line 92
1931 __cil_tmp13 = (void *)__cil_tmp12;
1932#line 92
1933 memset(__cil_tmp13, 242, 40UL);
1934 }
1935#line 93
1936 return;
1937}
1938}
1939#line 138 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
1940static void get_new_key_from_sha(struct ppp_mppe_state *state )
1941{ struct hash_desc desc ;
1942 struct scatterlist sg[4] ;
1943 unsigned int nbytes ;
1944 unsigned int tmp ;
1945 unsigned int tmp___0 ;
1946 unsigned int tmp___1 ;
1947 unsigned long __cil_tmp8 ;
1948 unsigned long __cil_tmp9 ;
1949 struct scatterlist *__cil_tmp10 ;
1950 unsigned long __cil_tmp11 ;
1951 unsigned long __cil_tmp12 ;
1952 struct scatterlist *__cil_tmp13 ;
1953 unsigned long __cil_tmp14 ;
1954 unsigned long __cil_tmp15 ;
1955 unsigned long __cil_tmp16 ;
1956 unsigned long __cil_tmp17 ;
1957 unsigned char *__cil_tmp18 ;
1958 void const *__cil_tmp19 ;
1959 unsigned long __cil_tmp20 ;
1960 unsigned long __cil_tmp21 ;
1961 unsigned int __cil_tmp22 ;
1962 unsigned long __cil_tmp23 ;
1963 unsigned long __cil_tmp24 ;
1964 struct scatterlist *__cil_tmp25 ;
1965 unsigned long __cil_tmp26 ;
1966 unsigned long __cil_tmp27 ;
1967 unsigned long __cil_tmp28 ;
1968 unsigned long __cil_tmp29 ;
1969 unsigned char *__cil_tmp30 ;
1970 void const *__cil_tmp31 ;
1971 unsigned int __cil_tmp32 ;
1972 unsigned long __cil_tmp33 ;
1973 unsigned long __cil_tmp34 ;
1974 struct scatterlist *__cil_tmp35 ;
1975 unsigned long __cil_tmp36 ;
1976 unsigned long __cil_tmp37 ;
1977 unsigned long __cil_tmp38 ;
1978 unsigned long __cil_tmp39 ;
1979 unsigned char *__cil_tmp40 ;
1980 void const *__cil_tmp41 ;
1981 unsigned long __cil_tmp42 ;
1982 unsigned long __cil_tmp43 ;
1983 unsigned int __cil_tmp44 ;
1984 unsigned long __cil_tmp45 ;
1985 unsigned long __cil_tmp46 ;
1986 struct scatterlist *__cil_tmp47 ;
1987 unsigned long __cil_tmp48 ;
1988 unsigned long __cil_tmp49 ;
1989 unsigned long __cil_tmp50 ;
1990 unsigned long __cil_tmp51 ;
1991 unsigned char *__cil_tmp52 ;
1992 void const *__cil_tmp53 ;
1993 unsigned int __cil_tmp54 ;
1994 struct hash_desc *__cil_tmp55 ;
1995 unsigned long __cil_tmp56 ;
1996 unsigned long __cil_tmp57 ;
1997 unsigned long __cil_tmp58 ;
1998 unsigned long __cil_tmp59 ;
1999 unsigned long __cil_tmp60 ;
2000 struct scatterlist *__cil_tmp61 ;
2001 unsigned long __cil_tmp62 ;
2002 unsigned long __cil_tmp63 ;
2003 unsigned char *__cil_tmp64 ;
2004
2005 {
2006 {
2007#line 144
2008 __cil_tmp8 = 0 * 40UL;
2009#line 144
2010 __cil_tmp9 = (unsigned long )(sg) + __cil_tmp8;
2011#line 144
2012 __cil_tmp10 = (struct scatterlist *)__cil_tmp9;
2013#line 144
2014 sg_init_table(__cil_tmp10, 4U);
2015#line 146
2016 __cil_tmp11 = 0 * 40UL;
2017#line 146
2018 __cil_tmp12 = (unsigned long )(sg) + __cil_tmp11;
2019#line 146
2020 __cil_tmp13 = (struct scatterlist *)__cil_tmp12;
2021#line 146
2022 __cil_tmp14 = 0 * 1UL;
2023#line 146
2024 __cil_tmp15 = 24 + __cil_tmp14;
2025#line 146
2026 __cil_tmp16 = (unsigned long )state;
2027#line 146
2028 __cil_tmp17 = __cil_tmp16 + __cil_tmp15;
2029#line 146
2030 __cil_tmp18 = (unsigned char *)__cil_tmp17;
2031#line 146
2032 __cil_tmp19 = (void const *)__cil_tmp18;
2033#line 146
2034 __cil_tmp20 = (unsigned long )state;
2035#line 146
2036 __cil_tmp21 = __cil_tmp20 + 56;
2037#line 146
2038 __cil_tmp22 = *((unsigned int *)__cil_tmp21);
2039#line 146
2040 nbytes = setup_sg(__cil_tmp13, __cil_tmp19, __cil_tmp22);
2041#line 147
2042 __cil_tmp23 = 1 * 40UL;
2043#line 147
2044 __cil_tmp24 = (unsigned long )(sg) + __cil_tmp23;
2045#line 147
2046 __cil_tmp25 = (struct scatterlist *)__cil_tmp24;
2047#line 147
2048 __cil_tmp26 = 0 * 1UL;
2049#line 147
2050 __cil_tmp27 = 0 + __cil_tmp26;
2051#line 147
2052 __cil_tmp28 = (unsigned long )sha_pad;
2053#line 147
2054 __cil_tmp29 = __cil_tmp28 + __cil_tmp27;
2055#line 147
2056 __cil_tmp30 = (unsigned char *)__cil_tmp29;
2057#line 147
2058 __cil_tmp31 = (void const *)__cil_tmp30;
2059#line 147
2060 __cil_tmp32 = (unsigned int )40UL;
2061#line 147
2062 tmp = setup_sg(__cil_tmp25, __cil_tmp31, __cil_tmp32);
2063#line 147
2064 nbytes = nbytes + tmp;
2065#line 149
2066 __cil_tmp33 = 2 * 40UL;
2067#line 149
2068 __cil_tmp34 = (unsigned long )(sg) + __cil_tmp33;
2069#line 149
2070 __cil_tmp35 = (struct scatterlist *)__cil_tmp34;
2071#line 149
2072 __cil_tmp36 = 0 * 1UL;
2073#line 149
2074 __cil_tmp37 = 40 + __cil_tmp36;
2075#line 149
2076 __cil_tmp38 = (unsigned long )state;
2077#line 149
2078 __cil_tmp39 = __cil_tmp38 + __cil_tmp37;
2079#line 149
2080 __cil_tmp40 = (unsigned char *)__cil_tmp39;
2081#line 149
2082 __cil_tmp41 = (void const *)__cil_tmp40;
2083#line 149
2084 __cil_tmp42 = (unsigned long )state;
2085#line 149
2086 __cil_tmp43 = __cil_tmp42 + 56;
2087#line 149
2088 __cil_tmp44 = *((unsigned int *)__cil_tmp43);
2089#line 149
2090 tmp___0 = setup_sg(__cil_tmp35, __cil_tmp41, __cil_tmp44);
2091#line 149
2092 nbytes = nbytes + tmp___0;
2093#line 150
2094 __cil_tmp45 = 3 * 40UL;
2095#line 150
2096 __cil_tmp46 = (unsigned long )(sg) + __cil_tmp45;
2097#line 150
2098 __cil_tmp47 = (struct scatterlist *)__cil_tmp46;
2099#line 150
2100 __cil_tmp48 = 0 * 1UL;
2101#line 150
2102 __cil_tmp49 = 40 + __cil_tmp48;
2103#line 150
2104 __cil_tmp50 = (unsigned long )sha_pad;
2105#line 150
2106 __cil_tmp51 = __cil_tmp50 + __cil_tmp49;
2107#line 150
2108 __cil_tmp52 = (unsigned char *)__cil_tmp51;
2109#line 150
2110 __cil_tmp53 = (void const *)__cil_tmp52;
2111#line 150
2112 __cil_tmp54 = (unsigned int )40UL;
2113#line 150
2114 tmp___1 = setup_sg(__cil_tmp47, __cil_tmp53, __cil_tmp54);
2115#line 150
2116 nbytes = nbytes + tmp___1;
2117#line 153
2118 __cil_tmp55 = & desc;
2119#line 153
2120 __cil_tmp56 = (unsigned long )state;
2121#line 153
2122 __cil_tmp57 = __cil_tmp56 + 8;
2123#line 153
2124 *((struct crypto_hash **)__cil_tmp55) = *((struct crypto_hash **)__cil_tmp57);
2125#line 154
2126 __cil_tmp58 = (unsigned long )(& desc) + 8;
2127#line 154
2128 *((u32 *)__cil_tmp58) = (u32 )0;
2129#line 156
2130 __cil_tmp59 = 0 * 40UL;
2131#line 156
2132 __cil_tmp60 = (unsigned long )(sg) + __cil_tmp59;
2133#line 156
2134 __cil_tmp61 = (struct scatterlist *)__cil_tmp60;
2135#line 156
2136 __cil_tmp62 = (unsigned long )state;
2137#line 156
2138 __cil_tmp63 = __cil_tmp62 + 16;
2139#line 156
2140 __cil_tmp64 = *((unsigned char **)__cil_tmp63);
2141#line 156
2142 crypto_hash_digest(& desc, __cil_tmp61, nbytes, __cil_tmp64);
2143 }
2144#line 157
2145 return;
2146}
2147}
2148#line 163 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
2149static void mppe_rekey(struct ppp_mppe_state *state , int initial_key )
2150{ struct scatterlist sg_in[1] ;
2151 struct scatterlist sg_out[1] ;
2152 struct blkcipher_desc desc ;
2153 int tmp ;
2154 size_t __len ;
2155 void *__ret ;
2156 struct blkcipher_desc *__cil_tmp9 ;
2157 unsigned long __cil_tmp10 ;
2158 unsigned long __cil_tmp11 ;
2159 struct crypto_blkcipher *__cil_tmp12 ;
2160 unsigned long __cil_tmp13 ;
2161 unsigned long __cil_tmp14 ;
2162 unsigned char *__cil_tmp15 ;
2163 u8 const *__cil_tmp16 ;
2164 unsigned long __cil_tmp17 ;
2165 unsigned long __cil_tmp18 ;
2166 unsigned int __cil_tmp19 ;
2167 unsigned long __cil_tmp20 ;
2168 unsigned long __cil_tmp21 ;
2169 struct scatterlist *__cil_tmp22 ;
2170 unsigned long __cil_tmp23 ;
2171 unsigned long __cil_tmp24 ;
2172 struct scatterlist *__cil_tmp25 ;
2173 unsigned long __cil_tmp26 ;
2174 unsigned long __cil_tmp27 ;
2175 struct scatterlist *__cil_tmp28 ;
2176 unsigned long __cil_tmp29 ;
2177 unsigned long __cil_tmp30 ;
2178 unsigned char *__cil_tmp31 ;
2179 void const *__cil_tmp32 ;
2180 unsigned long __cil_tmp33 ;
2181 unsigned long __cil_tmp34 ;
2182 unsigned int __cil_tmp35 ;
2183 unsigned long __cil_tmp36 ;
2184 unsigned long __cil_tmp37 ;
2185 struct scatterlist *__cil_tmp38 ;
2186 unsigned long __cil_tmp39 ;
2187 unsigned long __cil_tmp40 ;
2188 unsigned long __cil_tmp41 ;
2189 unsigned long __cil_tmp42 ;
2190 unsigned char *__cil_tmp43 ;
2191 void const *__cil_tmp44 ;
2192 unsigned long __cil_tmp45 ;
2193 unsigned long __cil_tmp46 ;
2194 unsigned int __cil_tmp47 ;
2195 unsigned long __cil_tmp48 ;
2196 unsigned long __cil_tmp49 ;
2197 struct scatterlist *__cil_tmp50 ;
2198 unsigned long __cil_tmp51 ;
2199 unsigned long __cil_tmp52 ;
2200 struct scatterlist *__cil_tmp53 ;
2201 unsigned long __cil_tmp54 ;
2202 unsigned long __cil_tmp55 ;
2203 unsigned int __cil_tmp56 ;
2204 unsigned long __cil_tmp57 ;
2205 unsigned long __cil_tmp58 ;
2206 unsigned int __cil_tmp59 ;
2207 unsigned long __cil_tmp60 ;
2208 unsigned long __cil_tmp61 ;
2209 unsigned long __cil_tmp62 ;
2210 unsigned long __cil_tmp63 ;
2211 unsigned char *__cil_tmp64 ;
2212 void *__cil_tmp65 ;
2213 unsigned long __cil_tmp66 ;
2214 unsigned long __cil_tmp67 ;
2215 unsigned char *__cil_tmp68 ;
2216 void const *__cil_tmp69 ;
2217 unsigned long __cil_tmp70 ;
2218 unsigned long __cil_tmp71 ;
2219 unsigned int __cil_tmp72 ;
2220 unsigned long __cil_tmp73 ;
2221 unsigned long __cil_tmp74 ;
2222 unsigned long __cil_tmp75 ;
2223 unsigned long __cil_tmp76 ;
2224 unsigned long __cil_tmp77 ;
2225 unsigned long __cil_tmp78 ;
2226 unsigned long __cil_tmp79 ;
2227 unsigned long __cil_tmp80 ;
2228 unsigned long __cil_tmp81 ;
2229 unsigned long __cil_tmp82 ;
2230 unsigned long __cil_tmp83 ;
2231 unsigned long __cil_tmp84 ;
2232 struct crypto_blkcipher *__cil_tmp85 ;
2233 unsigned long __cil_tmp86 ;
2234 unsigned long __cil_tmp87 ;
2235 unsigned long __cil_tmp88 ;
2236 unsigned long __cil_tmp89 ;
2237 unsigned char *__cil_tmp90 ;
2238 u8 const *__cil_tmp91 ;
2239 unsigned long __cil_tmp92 ;
2240 unsigned long __cil_tmp93 ;
2241 unsigned int __cil_tmp94 ;
2242
2243 {
2244 {
2245#line 166
2246 __cil_tmp9 = & desc;
2247#line 166
2248 *((struct crypto_blkcipher **)__cil_tmp9) = *((struct crypto_blkcipher **)state);
2249#line 166
2250 __cil_tmp10 = (unsigned long )(& desc) + 8;
2251#line 166
2252 *((void **)__cil_tmp10) = (void *)0;
2253#line 166
2254 __cil_tmp11 = (unsigned long )(& desc) + 16;
2255#line 166
2256 *((u32 *)__cil_tmp11) = 0U;
2257#line 168
2258 get_new_key_from_sha(state);
2259 }
2260#line 169
2261 if (! initial_key) {
2262 {
2263#line 170
2264 __cil_tmp12 = *((struct crypto_blkcipher **)state);
2265#line 170
2266 __cil_tmp13 = (unsigned long )state;
2267#line 170
2268 __cil_tmp14 = __cil_tmp13 + 16;
2269#line 170
2270 __cil_tmp15 = *((unsigned char **)__cil_tmp14);
2271#line 170
2272 __cil_tmp16 = (u8 const *)__cil_tmp15;
2273#line 170
2274 __cil_tmp17 = (unsigned long )state;
2275#line 170
2276 __cil_tmp18 = __cil_tmp17 + 56;
2277#line 170
2278 __cil_tmp19 = *((unsigned int *)__cil_tmp18);
2279#line 170
2280 crypto_blkcipher_setkey(__cil_tmp12, __cil_tmp16, __cil_tmp19);
2281#line 172
2282 __cil_tmp20 = 0 * 40UL;
2283#line 172
2284 __cil_tmp21 = (unsigned long )(sg_in) + __cil_tmp20;
2285#line 172
2286 __cil_tmp22 = (struct scatterlist *)__cil_tmp21;
2287#line 172
2288 sg_init_table(__cil_tmp22, 1U);
2289#line 173
2290 __cil_tmp23 = 0 * 40UL;
2291#line 173
2292 __cil_tmp24 = (unsigned long )(sg_out) + __cil_tmp23;
2293#line 173
2294 __cil_tmp25 = (struct scatterlist *)__cil_tmp24;
2295#line 173
2296 sg_init_table(__cil_tmp25, 1U);
2297#line 174
2298 __cil_tmp26 = 0 * 40UL;
2299#line 174
2300 __cil_tmp27 = (unsigned long )(sg_in) + __cil_tmp26;
2301#line 174
2302 __cil_tmp28 = (struct scatterlist *)__cil_tmp27;
2303#line 174
2304 __cil_tmp29 = (unsigned long )state;
2305#line 174
2306 __cil_tmp30 = __cil_tmp29 + 16;
2307#line 174
2308 __cil_tmp31 = *((unsigned char **)__cil_tmp30);
2309#line 174
2310 __cil_tmp32 = (void const *)__cil_tmp31;
2311#line 174
2312 __cil_tmp33 = (unsigned long )state;
2313#line 174
2314 __cil_tmp34 = __cil_tmp33 + 56;
2315#line 174
2316 __cil_tmp35 = *((unsigned int *)__cil_tmp34);
2317#line 174
2318 setup_sg(__cil_tmp28, __cil_tmp32, __cil_tmp35);
2319#line 175
2320 __cil_tmp36 = 0 * 40UL;
2321#line 175
2322 __cil_tmp37 = (unsigned long )(sg_out) + __cil_tmp36;
2323#line 175
2324 __cil_tmp38 = (struct scatterlist *)__cil_tmp37;
2325#line 175
2326 __cil_tmp39 = 0 * 1UL;
2327#line 175
2328 __cil_tmp40 = 40 + __cil_tmp39;
2329#line 175
2330 __cil_tmp41 = (unsigned long )state;
2331#line 175
2332 __cil_tmp42 = __cil_tmp41 + __cil_tmp40;
2333#line 175
2334 __cil_tmp43 = (unsigned char *)__cil_tmp42;
2335#line 175
2336 __cil_tmp44 = (void const *)__cil_tmp43;
2337#line 175
2338 __cil_tmp45 = (unsigned long )state;
2339#line 175
2340 __cil_tmp46 = __cil_tmp45 + 56;
2341#line 175
2342 __cil_tmp47 = *((unsigned int *)__cil_tmp46);
2343#line 175
2344 setup_sg(__cil_tmp38, __cil_tmp44, __cil_tmp47);
2345#line 176
2346 __cil_tmp48 = 0 * 40UL;
2347#line 176
2348 __cil_tmp49 = (unsigned long )(sg_out) + __cil_tmp48;
2349#line 176
2350 __cil_tmp50 = (struct scatterlist *)__cil_tmp49;
2351#line 176
2352 __cil_tmp51 = 0 * 40UL;
2353#line 176
2354 __cil_tmp52 = (unsigned long )(sg_in) + __cil_tmp51;
2355#line 176
2356 __cil_tmp53 = (struct scatterlist *)__cil_tmp52;
2357#line 176
2358 __cil_tmp54 = (unsigned long )state;
2359#line 176
2360 __cil_tmp55 = __cil_tmp54 + 56;
2361#line 176
2362 __cil_tmp56 = *((unsigned int *)__cil_tmp55);
2363#line 176
2364 tmp = crypto_blkcipher_encrypt(& desc, __cil_tmp50, __cil_tmp53, __cil_tmp56);
2365 }
2366#line 176
2367 if (tmp != 0) {
2368 {
2369#line 178
2370 printk("<4>mppe_rekey: cipher_encrypt failed\n");
2371 }
2372 } else {
2373
2374 }
2375 } else {
2376 {
2377#line 181
2378 __cil_tmp57 = (unsigned long )state;
2379#line 181
2380 __cil_tmp58 = __cil_tmp57 + 56;
2381#line 181
2382 __cil_tmp59 = *((unsigned int *)__cil_tmp58);
2383#line 181
2384 __len = (size_t )__cil_tmp59;
2385#line 181
2386 __cil_tmp60 = 0 * 1UL;
2387#line 181
2388 __cil_tmp61 = 40 + __cil_tmp60;
2389#line 181
2390 __cil_tmp62 = (unsigned long )state;
2391#line 181
2392 __cil_tmp63 = __cil_tmp62 + __cil_tmp61;
2393#line 181
2394 __cil_tmp64 = (unsigned char *)__cil_tmp63;
2395#line 181
2396 __cil_tmp65 = (void *)__cil_tmp64;
2397#line 181
2398 __cil_tmp66 = (unsigned long )state;
2399#line 181
2400 __cil_tmp67 = __cil_tmp66 + 16;
2401#line 181
2402 __cil_tmp68 = *((unsigned char **)__cil_tmp67);
2403#line 181
2404 __cil_tmp69 = (void const *)__cil_tmp68;
2405#line 181
2406 __ret = __builtin_memcpy(__cil_tmp65, __cil_tmp69, __len);
2407 }
2408 }
2409 {
2410#line 183
2411 __cil_tmp70 = (unsigned long )state;
2412#line 183
2413 __cil_tmp71 = __cil_tmp70 + 56;
2414#line 183
2415 __cil_tmp72 = *((unsigned int *)__cil_tmp71);
2416#line 183
2417 if (__cil_tmp72 == 8U) {
2418#line 185
2419 __cil_tmp73 = 0 * 1UL;
2420#line 185
2421 __cil_tmp74 = 40 + __cil_tmp73;
2422#line 185
2423 __cil_tmp75 = (unsigned long )state;
2424#line 185
2425 __cil_tmp76 = __cil_tmp75 + __cil_tmp74;
2426#line 185
2427 *((unsigned char *)__cil_tmp76) = (unsigned char)209;
2428#line 186
2429 __cil_tmp77 = 1 * 1UL;
2430#line 186
2431 __cil_tmp78 = 40 + __cil_tmp77;
2432#line 186
2433 __cil_tmp79 = (unsigned long )state;
2434#line 186
2435 __cil_tmp80 = __cil_tmp79 + __cil_tmp78;
2436#line 186
2437 *((unsigned char *)__cil_tmp80) = (unsigned char)38;
2438#line 187
2439 __cil_tmp81 = 2 * 1UL;
2440#line 187
2441 __cil_tmp82 = 40 + __cil_tmp81;
2442#line 187
2443 __cil_tmp83 = (unsigned long )state;
2444#line 187
2445 __cil_tmp84 = __cil_tmp83 + __cil_tmp82;
2446#line 187
2447 *((unsigned char *)__cil_tmp84) = (unsigned char)158;
2448 } else {
2449
2450 }
2451 }
2452 {
2453#line 189
2454 __cil_tmp85 = *((struct crypto_blkcipher **)state);
2455#line 189
2456 __cil_tmp86 = 0 * 1UL;
2457#line 189
2458 __cil_tmp87 = 40 + __cil_tmp86;
2459#line 189
2460 __cil_tmp88 = (unsigned long )state;
2461#line 189
2462 __cil_tmp89 = __cil_tmp88 + __cil_tmp87;
2463#line 189
2464 __cil_tmp90 = (unsigned char *)__cil_tmp89;
2465#line 189
2466 __cil_tmp91 = (u8 const *)__cil_tmp90;
2467#line 189
2468 __cil_tmp92 = (unsigned long )state;
2469#line 189
2470 __cil_tmp93 = __cil_tmp92 + 56;
2471#line 189
2472 __cil_tmp94 = *((unsigned int *)__cil_tmp93);
2473#line 189
2474 crypto_blkcipher_setkey(__cil_tmp85, __cil_tmp91, __cil_tmp94);
2475 }
2476#line 190
2477 return;
2478}
2479}
2480#line 195 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
2481static void *mppe_alloc(unsigned char *options , int optlen )
2482{ struct ppp_mppe_state *state ;
2483 unsigned int digestsize ;
2484 void *tmp ;
2485 long tmp___0 ;
2486 long tmp___1 ;
2487 void *tmp___2 ;
2488 size_t __len ;
2489 void *__ret ;
2490 size_t __len___0 ;
2491 void *__ret___0 ;
2492 unsigned long __cil_tmp13 ;
2493 unsigned long __cil_tmp14 ;
2494 unsigned char *__cil_tmp15 ;
2495 unsigned char __cil_tmp16 ;
2496 int __cil_tmp17 ;
2497 unsigned char *__cil_tmp18 ;
2498 unsigned char __cil_tmp19 ;
2499 int __cil_tmp20 ;
2500 void *__cil_tmp21 ;
2501 unsigned long __cil_tmp22 ;
2502 unsigned long __cil_tmp23 ;
2503 u32 __cil_tmp24 ;
2504 u32 __cil_tmp25 ;
2505 struct crypto_blkcipher *__cil_tmp26 ;
2506 void const *__cil_tmp27 ;
2507 void *__cil_tmp28 ;
2508 unsigned long __cil_tmp29 ;
2509 unsigned long __cil_tmp30 ;
2510 u32 __cil_tmp31 ;
2511 u32 __cil_tmp32 ;
2512 unsigned long __cil_tmp33 ;
2513 unsigned long __cil_tmp34 ;
2514 struct crypto_hash *__cil_tmp35 ;
2515 void const *__cil_tmp36 ;
2516 unsigned long __cil_tmp37 ;
2517 unsigned long __cil_tmp38 ;
2518 void *__cil_tmp39 ;
2519 unsigned long __cil_tmp40 ;
2520 unsigned long __cil_tmp41 ;
2521 struct crypto_hash *__cil_tmp42 ;
2522 size_t __cil_tmp43 ;
2523 unsigned long __cil_tmp44 ;
2524 unsigned long __cil_tmp45 ;
2525 unsigned long __cil_tmp46 ;
2526 unsigned long __cil_tmp47 ;
2527 unsigned char *__cil_tmp48 ;
2528 unsigned long __cil_tmp49 ;
2529 unsigned long __cil_tmp50 ;
2530 unsigned long __cil_tmp51 ;
2531 unsigned long __cil_tmp52 ;
2532 unsigned char *__cil_tmp53 ;
2533 void *__cil_tmp54 ;
2534 unsigned char *__cil_tmp55 ;
2535 void const *__cil_tmp56 ;
2536 unsigned long __cil_tmp57 ;
2537 unsigned long __cil_tmp58 ;
2538 unsigned long __cil_tmp59 ;
2539 unsigned long __cil_tmp60 ;
2540 unsigned char *__cil_tmp61 ;
2541 void *__cil_tmp62 ;
2542 unsigned char *__cil_tmp63 ;
2543 void const *__cil_tmp64 ;
2544 unsigned long __cil_tmp65 ;
2545 unsigned long __cil_tmp66 ;
2546 unsigned long __cil_tmp67 ;
2547 unsigned long __cil_tmp68 ;
2548 unsigned char *__cil_tmp69 ;
2549 void *__cil_tmp70 ;
2550 unsigned long __cil_tmp71 ;
2551 unsigned long __cil_tmp72 ;
2552 unsigned long __cil_tmp73 ;
2553 unsigned long __cil_tmp74 ;
2554 unsigned char *__cil_tmp75 ;
2555 void const *__cil_tmp76 ;
2556 unsigned long __cil_tmp77 ;
2557 unsigned long __cil_tmp78 ;
2558 unsigned long __cil_tmp79 ;
2559 unsigned long __cil_tmp80 ;
2560 unsigned char *__cil_tmp81 ;
2561 void *__cil_tmp82 ;
2562 unsigned long __cil_tmp83 ;
2563 unsigned long __cil_tmp84 ;
2564 unsigned long __cil_tmp85 ;
2565 unsigned long __cil_tmp86 ;
2566 unsigned char *__cil_tmp87 ;
2567 void const *__cil_tmp88 ;
2568 unsigned long __cil_tmp89 ;
2569 unsigned long __cil_tmp90 ;
2570 unsigned long __cil_tmp91 ;
2571 unsigned long __cil_tmp92 ;
2572 unsigned char *__cil_tmp93 ;
2573 void const *__cil_tmp94 ;
2574 unsigned long __cil_tmp95 ;
2575 unsigned long __cil_tmp96 ;
2576 unsigned long __cil_tmp97 ;
2577 unsigned long __cil_tmp98 ;
2578 struct crypto_hash *__cil_tmp99 ;
2579 struct crypto_blkcipher *__cil_tmp100 ;
2580 void const *__cil_tmp101 ;
2581
2582 {
2583 {
2584#line 200
2585 __cil_tmp13 = 6UL + 16UL;
2586#line 200
2587 __cil_tmp14 = (unsigned long )optlen;
2588#line 200
2589 if (__cil_tmp14 != __cil_tmp13) {
2590#line 202
2591 goto out;
2592 } else {
2593 {
2594#line 200
2595 __cil_tmp15 = options + 0;
2596#line 200
2597 __cil_tmp16 = *__cil_tmp15;
2598#line 200
2599 __cil_tmp17 = (int )__cil_tmp16;
2600#line 200
2601 if (__cil_tmp17 != 18) {
2602#line 202
2603 goto out;
2604 } else {
2605 {
2606#line 200
2607 __cil_tmp18 = options + 1;
2608#line 200
2609 __cil_tmp19 = *__cil_tmp18;
2610#line 200
2611 __cil_tmp20 = (int )__cil_tmp19;
2612#line 200
2613 if (__cil_tmp20 != 6) {
2614#line 202
2615 goto out;
2616 } else {
2617
2618 }
2619 }
2620 }
2621 }
2622 }
2623 }
2624 {
2625#line 204
2626 tmp = kzalloc(128UL, 208U);
2627#line 204
2628 state = (struct ppp_mppe_state *)tmp;
2629 }
2630 {
2631#line 205
2632 __cil_tmp21 = (void *)0;
2633#line 205
2634 __cil_tmp22 = (unsigned long )__cil_tmp21;
2635#line 205
2636 __cil_tmp23 = (unsigned long )state;
2637#line 205
2638 if (__cil_tmp23 == __cil_tmp22) {
2639#line 206
2640 goto out;
2641 } else {
2642
2643 }
2644 }
2645 {
2646#line 209
2647 __cil_tmp24 = (u32 )0;
2648#line 209
2649 __cil_tmp25 = (u32 )128;
2650#line 209
2651 *((struct crypto_blkcipher **)state) = crypto_alloc_blkcipher("ecb(arc4)", __cil_tmp24,
2652 __cil_tmp25);
2653#line 210
2654 __cil_tmp26 = *((struct crypto_blkcipher **)state);
2655#line 210
2656 __cil_tmp27 = (void const *)__cil_tmp26;
2657#line 210
2658 tmp___0 = (long )IS_ERR(__cil_tmp27);
2659 }
2660#line 210
2661 if (tmp___0) {
2662#line 211
2663 __cil_tmp28 = (void *)0;
2664#line 211
2665 *((struct crypto_blkcipher **)state) = (struct crypto_blkcipher *)__cil_tmp28;
2666#line 212
2667 goto out_free;
2668 } else {
2669
2670 }
2671 {
2672#line 215
2673 __cil_tmp29 = (unsigned long )state;
2674#line 215
2675 __cil_tmp30 = __cil_tmp29 + 8;
2676#line 215
2677 __cil_tmp31 = (u32 )0;
2678#line 215
2679 __cil_tmp32 = (u32 )128;
2680#line 215
2681 *((struct crypto_hash **)__cil_tmp30) = crypto_alloc_hash("sha1", __cil_tmp31, __cil_tmp32);
2682#line 216
2683 __cil_tmp33 = (unsigned long )state;
2684#line 216
2685 __cil_tmp34 = __cil_tmp33 + 8;
2686#line 216
2687 __cil_tmp35 = *((struct crypto_hash **)__cil_tmp34);
2688#line 216
2689 __cil_tmp36 = (void const *)__cil_tmp35;
2690#line 216
2691 tmp___1 = (long )IS_ERR(__cil_tmp36);
2692 }
2693#line 216
2694 if (tmp___1) {
2695#line 217
2696 __cil_tmp37 = (unsigned long )state;
2697#line 217
2698 __cil_tmp38 = __cil_tmp37 + 8;
2699#line 217
2700 __cil_tmp39 = (void *)0;
2701#line 217
2702 *((struct crypto_hash **)__cil_tmp38) = (struct crypto_hash *)__cil_tmp39;
2703#line 218
2704 goto out_free;
2705 } else {
2706
2707 }
2708 {
2709#line 221
2710 __cil_tmp40 = (unsigned long )state;
2711#line 221
2712 __cil_tmp41 = __cil_tmp40 + 8;
2713#line 221
2714 __cil_tmp42 = *((struct crypto_hash **)__cil_tmp41);
2715#line 221
2716 digestsize = crypto_hash_digestsize(__cil_tmp42);
2717 }
2718#line 222
2719 if (digestsize < 16U) {
2720#line 223
2721 goto out_free;
2722 } else {
2723
2724 }
2725 {
2726#line 225
2727 __cil_tmp43 = (size_t )digestsize;
2728#line 225
2729 tmp___2 = kmalloc(__cil_tmp43, 208U);
2730#line 225
2731 __cil_tmp44 = (unsigned long )state;
2732#line 225
2733 __cil_tmp45 = __cil_tmp44 + 16;
2734#line 225
2735 *((unsigned char **)__cil_tmp45) = (unsigned char *)tmp___2;
2736 }
2737 {
2738#line 226
2739 __cil_tmp46 = (unsigned long )state;
2740#line 226
2741 __cil_tmp47 = __cil_tmp46 + 16;
2742#line 226
2743 __cil_tmp48 = *((unsigned char **)__cil_tmp47);
2744#line 226
2745 if (! __cil_tmp48) {
2746#line 227
2747 goto out_free;
2748 } else {
2749
2750 }
2751 }
2752#line 230
2753 __len = 16UL;
2754#line 230
2755 if (__len >= 64UL) {
2756 {
2757#line 230
2758 __cil_tmp49 = 0 * 1UL;
2759#line 230
2760 __cil_tmp50 = 24 + __cil_tmp49;
2761#line 230
2762 __cil_tmp51 = (unsigned long )state;
2763#line 230
2764 __cil_tmp52 = __cil_tmp51 + __cil_tmp50;
2765#line 230
2766 __cil_tmp53 = (unsigned char *)__cil_tmp52;
2767#line 230
2768 __cil_tmp54 = (void *)__cil_tmp53;
2769#line 230
2770 __cil_tmp55 = options + 6;
2771#line 230
2772 __cil_tmp56 = (void const *)__cil_tmp55;
2773#line 230
2774 __ret = __memcpy(__cil_tmp54, __cil_tmp56, __len);
2775 }
2776 } else {
2777 {
2778#line 230
2779 __cil_tmp57 = 0 * 1UL;
2780#line 230
2781 __cil_tmp58 = 24 + __cil_tmp57;
2782#line 230
2783 __cil_tmp59 = (unsigned long )state;
2784#line 230
2785 __cil_tmp60 = __cil_tmp59 + __cil_tmp58;
2786#line 230
2787 __cil_tmp61 = (unsigned char *)__cil_tmp60;
2788#line 230
2789 __cil_tmp62 = (void *)__cil_tmp61;
2790#line 230
2791 __cil_tmp63 = options + 6;
2792#line 230
2793 __cil_tmp64 = (void const *)__cil_tmp63;
2794#line 230
2795 __ret = __builtin_memcpy(__cil_tmp62, __cil_tmp64, __len);
2796 }
2797 }
2798#line 232
2799 __len___0 = 16UL;
2800#line 232
2801 if (__len___0 >= 64UL) {
2802 {
2803#line 232
2804 __cil_tmp65 = 0 * 1UL;
2805#line 232
2806 __cil_tmp66 = 40 + __cil_tmp65;
2807#line 232
2808 __cil_tmp67 = (unsigned long )state;
2809#line 232
2810 __cil_tmp68 = __cil_tmp67 + __cil_tmp66;
2811#line 232
2812 __cil_tmp69 = (unsigned char *)__cil_tmp68;
2813#line 232
2814 __cil_tmp70 = (void *)__cil_tmp69;
2815#line 232
2816 __cil_tmp71 = 0 * 1UL;
2817#line 232
2818 __cil_tmp72 = 24 + __cil_tmp71;
2819#line 232
2820 __cil_tmp73 = (unsigned long )state;
2821#line 232
2822 __cil_tmp74 = __cil_tmp73 + __cil_tmp72;
2823#line 232
2824 __cil_tmp75 = (unsigned char *)__cil_tmp74;
2825#line 232
2826 __cil_tmp76 = (void const *)__cil_tmp75;
2827#line 232
2828 __ret___0 = __memcpy(__cil_tmp70, __cil_tmp76, __len___0);
2829 }
2830 } else {
2831 {
2832#line 232
2833 __cil_tmp77 = 0 * 1UL;
2834#line 232
2835 __cil_tmp78 = 40 + __cil_tmp77;
2836#line 232
2837 __cil_tmp79 = (unsigned long )state;
2838#line 232
2839 __cil_tmp80 = __cil_tmp79 + __cil_tmp78;
2840#line 232
2841 __cil_tmp81 = (unsigned char *)__cil_tmp80;
2842#line 232
2843 __cil_tmp82 = (void *)__cil_tmp81;
2844#line 232
2845 __cil_tmp83 = 0 * 1UL;
2846#line 232
2847 __cil_tmp84 = 24 + __cil_tmp83;
2848#line 232
2849 __cil_tmp85 = (unsigned long )state;
2850#line 232
2851 __cil_tmp86 = __cil_tmp85 + __cil_tmp84;
2852#line 232
2853 __cil_tmp87 = (unsigned char *)__cil_tmp86;
2854#line 232
2855 __cil_tmp88 = (void const *)__cil_tmp87;
2856#line 232
2857 __ret___0 = __builtin_memcpy(__cil_tmp82, __cil_tmp88, __len___0);
2858 }
2859 }
2860#line 240
2861 return ((void *)state);
2862 out_free:
2863 {
2864#line 243
2865 __cil_tmp89 = (unsigned long )state;
2866#line 243
2867 __cil_tmp90 = __cil_tmp89 + 16;
2868#line 243
2869 if (*((unsigned char **)__cil_tmp90)) {
2870 {
2871#line 244
2872 __cil_tmp91 = (unsigned long )state;
2873#line 244
2874 __cil_tmp92 = __cil_tmp91 + 16;
2875#line 244
2876 __cil_tmp93 = *((unsigned char **)__cil_tmp92);
2877#line 244
2878 __cil_tmp94 = (void const *)__cil_tmp93;
2879#line 244
2880 kfree(__cil_tmp94);
2881 }
2882 } else {
2883
2884 }
2885 }
2886 {
2887#line 245
2888 __cil_tmp95 = (unsigned long )state;
2889#line 245
2890 __cil_tmp96 = __cil_tmp95 + 8;
2891#line 245
2892 if (*((struct crypto_hash **)__cil_tmp96)) {
2893 {
2894#line 246
2895 __cil_tmp97 = (unsigned long )state;
2896#line 246
2897 __cil_tmp98 = __cil_tmp97 + 8;
2898#line 246
2899 __cil_tmp99 = *((struct crypto_hash **)__cil_tmp98);
2900#line 246
2901 crypto_free_hash(__cil_tmp99);
2902 }
2903 } else {
2904
2905 }
2906 }
2907#line 247
2908 if (*((struct crypto_blkcipher **)state)) {
2909 {
2910#line 248
2911 __cil_tmp100 = *((struct crypto_blkcipher **)state);
2912#line 248
2913 crypto_free_blkcipher(__cil_tmp100);
2914 }
2915 } else {
2916
2917 }
2918 {
2919#line 249
2920 __cil_tmp101 = (void const *)state;
2921#line 249
2922 kfree(__cil_tmp101);
2923 }
2924 out:
2925#line 251
2926 return ((void *)0);
2927}
2928}
2929#line 257 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
2930static void mppe_free(void *arg )
2931{ struct ppp_mppe_state *state ;
2932 unsigned long __cil_tmp3 ;
2933 unsigned long __cil_tmp4 ;
2934 unsigned long __cil_tmp5 ;
2935 unsigned long __cil_tmp6 ;
2936 unsigned char *__cil_tmp7 ;
2937 void const *__cil_tmp8 ;
2938 unsigned long __cil_tmp9 ;
2939 unsigned long __cil_tmp10 ;
2940 unsigned long __cil_tmp11 ;
2941 unsigned long __cil_tmp12 ;
2942 struct crypto_hash *__cil_tmp13 ;
2943 struct crypto_blkcipher *__cil_tmp14 ;
2944 void const *__cil_tmp15 ;
2945
2946 {
2947#line 259
2948 state = (struct ppp_mppe_state *)arg;
2949#line 260
2950 if (state) {
2951 {
2952#line 261
2953 __cil_tmp3 = (unsigned long )state;
2954#line 261
2955 __cil_tmp4 = __cil_tmp3 + 16;
2956#line 261
2957 if (*((unsigned char **)__cil_tmp4)) {
2958 {
2959#line 262
2960 __cil_tmp5 = (unsigned long )state;
2961#line 262
2962 __cil_tmp6 = __cil_tmp5 + 16;
2963#line 262
2964 __cil_tmp7 = *((unsigned char **)__cil_tmp6);
2965#line 262
2966 __cil_tmp8 = (void const *)__cil_tmp7;
2967#line 262
2968 kfree(__cil_tmp8);
2969 }
2970 } else {
2971
2972 }
2973 }
2974 {
2975#line 263
2976 __cil_tmp9 = (unsigned long )state;
2977#line 263
2978 __cil_tmp10 = __cil_tmp9 + 8;
2979#line 263
2980 if (*((struct crypto_hash **)__cil_tmp10)) {
2981 {
2982#line 264
2983 __cil_tmp11 = (unsigned long )state;
2984#line 264
2985 __cil_tmp12 = __cil_tmp11 + 8;
2986#line 264
2987 __cil_tmp13 = *((struct crypto_hash **)__cil_tmp12);
2988#line 264
2989 crypto_free_hash(__cil_tmp13);
2990 }
2991 } else {
2992
2993 }
2994 }
2995#line 265
2996 if (*((struct crypto_blkcipher **)state)) {
2997 {
2998#line 266
2999 __cil_tmp14 = *((struct crypto_blkcipher **)state);
3000#line 266
3001 crypto_free_blkcipher(__cil_tmp14);
3002 }
3003 } else {
3004
3005 }
3006 {
3007#line 267
3008 __cil_tmp15 = (void const *)state;
3009#line 267
3010 kfree(__cil_tmp15);
3011 }
3012 } else {
3013
3014 }
3015#line 269
3016 return;
3017}
3018}
3019#line 274 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
3020static int mppe_init(void *arg , unsigned char *options , int optlen , int unit ,
3021 int debug , char const *debugstr )
3022{ struct ppp_mppe_state *state ;
3023 unsigned char mppe_opts ;
3024 u_char *ptr ;
3025 int i ;
3026 char mkey[sizeof(state->master_key) * 2UL + 1UL] ;
3027 char skey[sizeof(state->session_key) * 2UL + 1UL] ;
3028 char const *tmp ;
3029 int tmp___0 ;
3030 unsigned char *__cil_tmp15 ;
3031 unsigned char __cil_tmp16 ;
3032 int __cil_tmp17 ;
3033 unsigned char *__cil_tmp18 ;
3034 unsigned char __cil_tmp19 ;
3035 int __cil_tmp20 ;
3036 u_char *__cil_tmp21 ;
3037 u_char __cil_tmp22 ;
3038 int __cil_tmp23 ;
3039 int __cil_tmp24 ;
3040 int __cil_tmp25 ;
3041 int __cil_tmp26 ;
3042 u_char *__cil_tmp27 ;
3043 u_char __cil_tmp28 ;
3044 int __cil_tmp29 ;
3045 int __cil_tmp30 ;
3046 int __cil_tmp31 ;
3047 u_char *__cil_tmp32 ;
3048 u_char __cil_tmp33 ;
3049 int __cil_tmp34 ;
3050 int __cil_tmp35 ;
3051 int __cil_tmp36 ;
3052 u_char *__cil_tmp37 ;
3053 u_char __cil_tmp38 ;
3054 int __cil_tmp39 ;
3055 int __cil_tmp40 ;
3056 int __cil_tmp41 ;
3057 u_char *__cil_tmp42 ;
3058 u_char __cil_tmp43 ;
3059 int __cil_tmp44 ;
3060 int __cil_tmp45 ;
3061 int __cil_tmp46 ;
3062 u_char *__cil_tmp47 ;
3063 u_char __cil_tmp48 ;
3064 int __cil_tmp49 ;
3065 int __cil_tmp50 ;
3066 int __cil_tmp51 ;
3067 u_char *__cil_tmp52 ;
3068 u_char __cil_tmp53 ;
3069 int __cil_tmp54 ;
3070 int __cil_tmp55 ;
3071 int __cil_tmp56 ;
3072 u_char *__cil_tmp57 ;
3073 int __cil_tmp58 ;
3074 int __cil_tmp59 ;
3075 u_char *__cil_tmp60 ;
3076 int __cil_tmp61 ;
3077 int __cil_tmp62 ;
3078 u_char *__cil_tmp63 ;
3079 u_char __cil_tmp64 ;
3080 int __cil_tmp65 ;
3081 int __cil_tmp66 ;
3082 int __cil_tmp67 ;
3083 int __cil_tmp68 ;
3084 unsigned long __cil_tmp69 ;
3085 unsigned long __cil_tmp70 ;
3086 int __cil_tmp71 ;
3087 unsigned long __cil_tmp72 ;
3088 unsigned long __cil_tmp73 ;
3089 int __cil_tmp74 ;
3090 unsigned long __cil_tmp75 ;
3091 unsigned long __cil_tmp76 ;
3092 unsigned long __cil_tmp77 ;
3093 unsigned long __cil_tmp78 ;
3094 unsigned long __cil_tmp79 ;
3095 unsigned long __cil_tmp80 ;
3096 unsigned int __cil_tmp81 ;
3097 unsigned long __cil_tmp82 ;
3098 int __cil_tmp83 ;
3099 unsigned long __cil_tmp84 ;
3100 unsigned long __cil_tmp85 ;
3101 char *__cil_tmp86 ;
3102 char *__cil_tmp87 ;
3103 unsigned long __cil_tmp88 ;
3104 unsigned long __cil_tmp89 ;
3105 unsigned long __cil_tmp90 ;
3106 unsigned long __cil_tmp91 ;
3107 unsigned char __cil_tmp92 ;
3108 int __cil_tmp93 ;
3109 unsigned long __cil_tmp94 ;
3110 int __cil_tmp95 ;
3111 unsigned long __cil_tmp96 ;
3112 unsigned long __cil_tmp97 ;
3113 char *__cil_tmp98 ;
3114 char *__cil_tmp99 ;
3115 unsigned long __cil_tmp100 ;
3116 unsigned long __cil_tmp101 ;
3117 unsigned long __cil_tmp102 ;
3118 unsigned long __cil_tmp103 ;
3119 unsigned char __cil_tmp104 ;
3120 int __cil_tmp105 ;
3121 unsigned long __cil_tmp106 ;
3122 unsigned long __cil_tmp107 ;
3123 char *__cil_tmp108 ;
3124 unsigned long __cil_tmp109 ;
3125 unsigned long __cil_tmp110 ;
3126 char *__cil_tmp111 ;
3127 unsigned long __cil_tmp112 ;
3128 unsigned long __cil_tmp113 ;
3129 unsigned long __cil_tmp114 ;
3130 unsigned long __cil_tmp115 ;
3131 unsigned long __cil_tmp116 ;
3132 unsigned long __cil_tmp117 ;
3133 unsigned long __cil_tmp118 ;
3134 unsigned long __cil_tmp119 ;
3135
3136 {
3137#line 278
3138 state = (struct ppp_mppe_state *)arg;
3139#line 281
3140 if (optlen != 6) {
3141#line 283
3142 return (0);
3143 } else {
3144 {
3145#line 281
3146 __cil_tmp15 = options + 0;
3147#line 281
3148 __cil_tmp16 = *__cil_tmp15;
3149#line 281
3150 __cil_tmp17 = (int )__cil_tmp16;
3151#line 281
3152 if (__cil_tmp17 != 18) {
3153#line 283
3154 return (0);
3155 } else {
3156 {
3157#line 281
3158 __cil_tmp18 = options + 1;
3159#line 281
3160 __cil_tmp19 = *__cil_tmp18;
3161#line 281
3162 __cil_tmp20 = (int )__cil_tmp19;
3163#line 281
3164 if (__cil_tmp20 != 6) {
3165#line 283
3166 return (0);
3167 } else {
3168
3169 }
3170 }
3171 }
3172 }
3173 }
3174 {
3175#line 285
3176 while (1) {
3177 while_continue: ;
3178#line 285
3179 ptr = options + 2;
3180#line 285
3181 mppe_opts = (unsigned char)0;
3182 {
3183#line 285
3184 __cil_tmp21 = ptr + 0;
3185#line 285
3186 __cil_tmp22 = *__cil_tmp21;
3187#line 285
3188 __cil_tmp23 = (int )__cil_tmp22;
3189#line 285
3190 __cil_tmp24 = __cil_tmp23 & 1;
3191#line 285
3192 if (! __cil_tmp24) {
3193#line 285
3194 __cil_tmp25 = (int )mppe_opts;
3195#line 285
3196 __cil_tmp26 = __cil_tmp25 | 4;
3197#line 285
3198 mppe_opts = (unsigned char )__cil_tmp26;
3199 } else {
3200
3201 }
3202 }
3203 {
3204#line 285
3205 __cil_tmp27 = ptr + 3;
3206#line 285
3207 __cil_tmp28 = *__cil_tmp27;
3208#line 285
3209 __cil_tmp29 = (int )__cil_tmp28;
3210#line 285
3211 if (__cil_tmp29 & 64) {
3212#line 285
3213 __cil_tmp30 = (int )mppe_opts;
3214#line 285
3215 __cil_tmp31 = __cil_tmp30 | 2;
3216#line 285
3217 mppe_opts = (unsigned char )__cil_tmp31;
3218 } else {
3219
3220 }
3221 }
3222 {
3223#line 285
3224 __cil_tmp32 = ptr + 3;
3225#line 285
3226 __cil_tmp33 = *__cil_tmp32;
3227#line 285
3228 __cil_tmp34 = (int )__cil_tmp33;
3229#line 285
3230 if (__cil_tmp34 & 32) {
3231#line 285
3232 __cil_tmp35 = (int )mppe_opts;
3233#line 285
3234 __cil_tmp36 = __cil_tmp35 | 1;
3235#line 285
3236 mppe_opts = (unsigned char )__cil_tmp36;
3237 } else {
3238
3239 }
3240 }
3241 {
3242#line 285
3243 __cil_tmp37 = ptr + 3;
3244#line 285
3245 __cil_tmp38 = *__cil_tmp37;
3246#line 285
3247 __cil_tmp39 = (int )__cil_tmp38;
3248#line 285
3249 if (__cil_tmp39 & 128) {
3250#line 285
3251 __cil_tmp40 = (int )mppe_opts;
3252#line 285
3253 __cil_tmp41 = __cil_tmp40 | 8;
3254#line 285
3255 mppe_opts = (unsigned char )__cil_tmp41;
3256 } else {
3257
3258 }
3259 }
3260 {
3261#line 285
3262 __cil_tmp42 = ptr + 3;
3263#line 285
3264 __cil_tmp43 = *__cil_tmp42;
3265#line 285
3266 __cil_tmp44 = (int )__cil_tmp43;
3267#line 285
3268 if (__cil_tmp44 & 16) {
3269#line 285
3270 __cil_tmp45 = (int )mppe_opts;
3271#line 285
3272 __cil_tmp46 = __cil_tmp45 | 32;
3273#line 285
3274 mppe_opts = (unsigned char )__cil_tmp46;
3275 } else {
3276
3277 }
3278 }
3279 {
3280#line 285
3281 __cil_tmp47 = ptr + 3;
3282#line 285
3283 __cil_tmp48 = *__cil_tmp47;
3284#line 285
3285 __cil_tmp49 = (int )__cil_tmp48;
3286#line 285
3287 if (__cil_tmp49 & 1) {
3288#line 285
3289 __cil_tmp50 = (int )mppe_opts;
3290#line 285
3291 __cil_tmp51 = __cil_tmp50 | 16;
3292#line 285
3293 mppe_opts = (unsigned char )__cil_tmp51;
3294 } else {
3295
3296 }
3297 }
3298 {
3299#line 285
3300 __cil_tmp52 = ptr + 0;
3301#line 285
3302 __cil_tmp53 = *__cil_tmp52;
3303#line 285
3304 __cil_tmp54 = (int )__cil_tmp53;
3305#line 285
3306 if (__cil_tmp54 & -2) {
3307#line 285
3308 __cil_tmp55 = (int )mppe_opts;
3309#line 285
3310 __cil_tmp56 = __cil_tmp55 | 64;
3311#line 285
3312 mppe_opts = (unsigned char )__cil_tmp56;
3313 } else {
3314
3315 }
3316 }
3317 {
3318#line 285
3319 __cil_tmp57 = ptr + 1;
3320#line 285
3321 if (*__cil_tmp57) {
3322#line 285
3323 __cil_tmp58 = (int )mppe_opts;
3324#line 285
3325 __cil_tmp59 = __cil_tmp58 | 64;
3326#line 285
3327 mppe_opts = (unsigned char )__cil_tmp59;
3328 } else {
3329 {
3330#line 285
3331 __cil_tmp60 = ptr + 2;
3332#line 285
3333 if (*__cil_tmp60) {
3334#line 285
3335 __cil_tmp61 = (int )mppe_opts;
3336#line 285
3337 __cil_tmp62 = __cil_tmp61 | 64;
3338#line 285
3339 mppe_opts = (unsigned char )__cil_tmp62;
3340 } else {
3341
3342 }
3343 }
3344 }
3345 }
3346 {
3347#line 285
3348 __cil_tmp63 = ptr + 3;
3349#line 285
3350 __cil_tmp64 = *__cil_tmp63;
3351#line 285
3352 __cil_tmp65 = (int )__cil_tmp64;
3353#line 285
3354 if (__cil_tmp65 & -242) {
3355#line 285
3356 __cil_tmp66 = (int )mppe_opts;
3357#line 285
3358 __cil_tmp67 = __cil_tmp66 | 64;
3359#line 285
3360 mppe_opts = (unsigned char )__cil_tmp67;
3361 } else {
3362
3363 }
3364 }
3365#line 285
3366 goto while_break;
3367 }
3368 while_break: ;
3369 }
3370 {
3371#line 286
3372 __cil_tmp68 = (int )mppe_opts;
3373#line 286
3374 if (__cil_tmp68 & 2) {
3375#line 287
3376 __cil_tmp69 = (unsigned long )state;
3377#line 287
3378 __cil_tmp70 = __cil_tmp69 + 56;
3379#line 287
3380 *((unsigned int *)__cil_tmp70) = 16U;
3381 } else {
3382 {
3383#line 288
3384 __cil_tmp71 = (int )mppe_opts;
3385#line 288
3386 if (__cil_tmp71 & 1) {
3387#line 289
3388 __cil_tmp72 = (unsigned long )state;
3389#line 289
3390 __cil_tmp73 = __cil_tmp72 + 56;
3391#line 289
3392 *((unsigned int *)__cil_tmp73) = 8U;
3393 } else {
3394 {
3395#line 291
3396 printk("<4>%s[%d]: unknown key length\n", debugstr, unit);
3397 }
3398#line 293
3399 return (0);
3400 }
3401 }
3402 }
3403 }
3404 {
3405#line 295
3406 __cil_tmp74 = (int )mppe_opts;
3407#line 295
3408 if (__cil_tmp74 & 4) {
3409#line 296
3410 __cil_tmp75 = (unsigned long )state;
3411#line 296
3412 __cil_tmp76 = __cil_tmp75 + 68;
3413#line 296
3414 *((unsigned int *)__cil_tmp76) = 1U;
3415 } else {
3416
3417 }
3418 }
3419 {
3420#line 299
3421 mppe_rekey(state, 1);
3422 }
3423#line 301
3424 if (debug) {
3425 {
3426#line 306
3427 __cil_tmp77 = (unsigned long )state;
3428#line 306
3429 __cil_tmp78 = __cil_tmp77 + 68;
3430#line 306
3431 if (*((unsigned int *)__cil_tmp78)) {
3432#line 306
3433 tmp = "stateful";
3434 } else {
3435#line 306
3436 tmp = "stateless";
3437 }
3438 }
3439 {
3440#line 306
3441 __cil_tmp79 = (unsigned long )state;
3442#line 306
3443 __cil_tmp80 = __cil_tmp79 + 56;
3444#line 306
3445 __cil_tmp81 = *((unsigned int *)__cil_tmp80);
3446#line 306
3447 if (__cil_tmp81 == 16U) {
3448#line 306
3449 tmp___0 = 128;
3450 } else {
3451#line 306
3452 tmp___0 = 40;
3453 }
3454 }
3455 {
3456#line 306
3457 printk("<7>%s[%d]: initialized with %d-bit %s mode\n", debugstr, unit, tmp___0,
3458 tmp);
3459#line 310
3460 i = 0;
3461 }
3462 {
3463#line 310
3464 while (1) {
3465 while_continue___0: ;
3466 {
3467#line 310
3468 __cil_tmp82 = (unsigned long )i;
3469#line 310
3470 if (__cil_tmp82 < 16UL) {
3471
3472 } else {
3473#line 310
3474 goto while_break___0;
3475 }
3476 }
3477 {
3478#line 311
3479 __cil_tmp83 = i * 2;
3480#line 311
3481 __cil_tmp84 = 0 * 1UL;
3482#line 311
3483 __cil_tmp85 = (unsigned long )(mkey) + __cil_tmp84;
3484#line 311
3485 __cil_tmp86 = (char *)__cil_tmp85;
3486#line 311
3487 __cil_tmp87 = __cil_tmp86 + __cil_tmp83;
3488#line 311
3489 __cil_tmp88 = i * 1UL;
3490#line 311
3491 __cil_tmp89 = 24 + __cil_tmp88;
3492#line 311
3493 __cil_tmp90 = (unsigned long )state;
3494#line 311
3495 __cil_tmp91 = __cil_tmp90 + __cil_tmp89;
3496#line 311
3497 __cil_tmp92 = *((unsigned char *)__cil_tmp91);
3498#line 311
3499 __cil_tmp93 = (int )__cil_tmp92;
3500#line 311
3501 sprintf(__cil_tmp87, "%02x", __cil_tmp93);
3502#line 310
3503 i = i + 1;
3504 }
3505 }
3506 while_break___0: ;
3507 }
3508#line 312
3509 i = 0;
3510 {
3511#line 312
3512 while (1) {
3513 while_continue___1: ;
3514 {
3515#line 312
3516 __cil_tmp94 = (unsigned long )i;
3517#line 312
3518 if (__cil_tmp94 < 16UL) {
3519
3520 } else {
3521#line 312
3522 goto while_break___1;
3523 }
3524 }
3525 {
3526#line 313
3527 __cil_tmp95 = i * 2;
3528#line 313
3529 __cil_tmp96 = 0 * 1UL;
3530#line 313
3531 __cil_tmp97 = (unsigned long )(skey) + __cil_tmp96;
3532#line 313
3533 __cil_tmp98 = (char *)__cil_tmp97;
3534#line 313
3535 __cil_tmp99 = __cil_tmp98 + __cil_tmp95;
3536#line 313
3537 __cil_tmp100 = i * 1UL;
3538#line 313
3539 __cil_tmp101 = 40 + __cil_tmp100;
3540#line 313
3541 __cil_tmp102 = (unsigned long )state;
3542#line 313
3543 __cil_tmp103 = __cil_tmp102 + __cil_tmp101;
3544#line 313
3545 __cil_tmp104 = *((unsigned char *)__cil_tmp103);
3546#line 313
3547 __cil_tmp105 = (int )__cil_tmp104;
3548#line 313
3549 sprintf(__cil_tmp99, "%02x", __cil_tmp105);
3550#line 312
3551 i = i + 1;
3552 }
3553 }
3554 while_break___1: ;
3555 }
3556 {
3557#line 314
3558 __cil_tmp106 = 0 * 1UL;
3559#line 314
3560 __cil_tmp107 = (unsigned long )(mkey) + __cil_tmp106;
3561#line 314
3562 __cil_tmp108 = (char *)__cil_tmp107;
3563#line 314
3564 __cil_tmp109 = 0 * 1UL;
3565#line 314
3566 __cil_tmp110 = (unsigned long )(skey) + __cil_tmp109;
3567#line 314
3568 __cil_tmp111 = (char *)__cil_tmp110;
3569#line 314
3570 printk("<7>%s[%d]: keys: master: %s initial session: %s\n", debugstr, unit, __cil_tmp108,
3571 __cil_tmp111);
3572 }
3573 } else {
3574
3575 }
3576#line 325
3577 __cil_tmp112 = (unsigned long )state;
3578#line 325
3579 __cil_tmp113 = __cil_tmp112 + 64;
3580#line 325
3581 *((unsigned int *)__cil_tmp113) = 4095U;
3582#line 331
3583 __cil_tmp114 = (unsigned long )state;
3584#line 331
3585 __cil_tmp115 = __cil_tmp114 + 60;
3586#line 331
3587 *((unsigned char *)__cil_tmp115) = (unsigned char)16;
3588#line 333
3589 __cil_tmp116 = (unsigned long )state;
3590#line 333
3591 __cil_tmp117 = __cil_tmp116 + 80;
3592#line 333
3593 *((int *)__cil_tmp117) = unit;
3594#line 334
3595 __cil_tmp118 = (unsigned long )state;
3596#line 334
3597 __cil_tmp119 = __cil_tmp118 + 84;
3598#line 334
3599 *((int *)__cil_tmp119) = debug;
3600#line 336
3601 return (1);
3602}
3603}
3604#line 339 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
3605static int mppe_comp_init(void *arg , unsigned char *options , int optlen , int unit ,
3606 int hdrlen , int debug )
3607{ int tmp ;
3608
3609 {
3610 {
3611#line 344
3612 tmp = mppe_init(arg, options, optlen, unit, debug, "mppe_comp_init");
3613 }
3614#line 344
3615 return (tmp);
3616}
3617}
3618#line 356 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
3619static void mppe_comp_reset(void *arg )
3620{ struct ppp_mppe_state *state ;
3621 unsigned long __cil_tmp3 ;
3622 unsigned long __cil_tmp4 ;
3623 unsigned long __cil_tmp5 ;
3624 unsigned long __cil_tmp6 ;
3625 unsigned char __cil_tmp7 ;
3626 int __cil_tmp8 ;
3627 int __cil_tmp9 ;
3628
3629 {
3630#line 358
3631 state = (struct ppp_mppe_state *)arg;
3632#line 360
3633 __cil_tmp3 = (unsigned long )state;
3634#line 360
3635 __cil_tmp4 = __cil_tmp3 + 60;
3636#line 360
3637 __cil_tmp5 = (unsigned long )state;
3638#line 360
3639 __cil_tmp6 = __cil_tmp5 + 60;
3640#line 360
3641 __cil_tmp7 = *((unsigned char *)__cil_tmp6);
3642#line 360
3643 __cil_tmp8 = (int )__cil_tmp7;
3644#line 360
3645 __cil_tmp9 = __cil_tmp8 | 128;
3646#line 360
3647 *((unsigned char *)__cil_tmp4) = (unsigned char )__cil_tmp9;
3648#line 361
3649 return;
3650}
3651}
3652#line 368 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
3653static int mppe_compress(void *arg , unsigned char *ibuf , unsigned char *obuf , int isize ,
3654 int osize )
3655{ struct ppp_mppe_state *state ;
3656 struct blkcipher_desc desc ;
3657 int proto ;
3658 struct scatterlist sg_in[1] ;
3659 struct scatterlist sg_out[1] ;
3660 int tmp ;
3661 struct blkcipher_desc *__cil_tmp12 ;
3662 unsigned long __cil_tmp13 ;
3663 unsigned long __cil_tmp14 ;
3664 __u8 *__cil_tmp15 ;
3665 __u8 __cil_tmp16 ;
3666 int __cil_tmp17 ;
3667 __u8 *__cil_tmp18 ;
3668 __u8 __cil_tmp19 ;
3669 int __cil_tmp20 ;
3670 int __cil_tmp21 ;
3671 int __cil_tmp22 ;
3672 int __cil_tmp23 ;
3673 unsigned long __cil_tmp24 ;
3674 unsigned long __cil_tmp25 ;
3675 int __cil_tmp26 ;
3676 int __cil_tmp27 ;
3677 int __cil_tmp28 ;
3678 int __cil_tmp29 ;
3679 unsigned char *__cil_tmp30 ;
3680 __u8 *__cil_tmp31 ;
3681 unsigned char *__cil_tmp32 ;
3682 __u8 *__cil_tmp33 ;
3683 u16 __cil_tmp34 ;
3684 unsigned char *__cil_tmp35 ;
3685 void *__cil_tmp36 ;
3686 unsigned long __cil_tmp37 ;
3687 unsigned long __cil_tmp38 ;
3688 unsigned long __cil_tmp39 ;
3689 unsigned long __cil_tmp40 ;
3690 unsigned int __cil_tmp41 ;
3691 unsigned int __cil_tmp42 ;
3692 unsigned long __cil_tmp43 ;
3693 unsigned long __cil_tmp44 ;
3694 int __cil_tmp45 ;
3695 unsigned long __cil_tmp46 ;
3696 unsigned long __cil_tmp47 ;
3697 int __cil_tmp48 ;
3698 unsigned long __cil_tmp49 ;
3699 unsigned long __cil_tmp50 ;
3700 unsigned int __cil_tmp51 ;
3701 unsigned long __cil_tmp52 ;
3702 unsigned long __cil_tmp53 ;
3703 unsigned int __cil_tmp54 ;
3704 u16 __cil_tmp55 ;
3705 void *__cil_tmp56 ;
3706 unsigned long __cil_tmp57 ;
3707 unsigned long __cil_tmp58 ;
3708 unsigned int __cil_tmp59 ;
3709 unsigned long __cil_tmp60 ;
3710 unsigned long __cil_tmp61 ;
3711 unsigned int __cil_tmp62 ;
3712 unsigned int __cil_tmp63 ;
3713 unsigned long __cil_tmp64 ;
3714 unsigned long __cil_tmp65 ;
3715 unsigned char __cil_tmp66 ;
3716 int __cil_tmp67 ;
3717 unsigned long __cil_tmp68 ;
3718 unsigned long __cil_tmp69 ;
3719 unsigned long __cil_tmp70 ;
3720 unsigned long __cil_tmp71 ;
3721 unsigned long __cil_tmp72 ;
3722 unsigned long __cil_tmp73 ;
3723 int __cil_tmp74 ;
3724 unsigned long __cil_tmp75 ;
3725 unsigned long __cil_tmp76 ;
3726 unsigned long __cil_tmp77 ;
3727 unsigned long __cil_tmp78 ;
3728 unsigned char __cil_tmp79 ;
3729 int __cil_tmp80 ;
3730 int __cil_tmp81 ;
3731 unsigned char *__cil_tmp82 ;
3732 unsigned long __cil_tmp83 ;
3733 unsigned long __cil_tmp84 ;
3734 unsigned char __cil_tmp85 ;
3735 int __cil_tmp86 ;
3736 unsigned char *__cil_tmp87 ;
3737 unsigned char __cil_tmp88 ;
3738 int __cil_tmp89 ;
3739 int __cil_tmp90 ;
3740 unsigned long __cil_tmp91 ;
3741 unsigned long __cil_tmp92 ;
3742 unsigned long __cil_tmp93 ;
3743 unsigned long __cil_tmp94 ;
3744 unsigned char __cil_tmp95 ;
3745 int __cil_tmp96 ;
3746 int __cil_tmp97 ;
3747 unsigned long __cil_tmp98 ;
3748 unsigned long __cil_tmp99 ;
3749 struct scatterlist *__cil_tmp100 ;
3750 unsigned long __cil_tmp101 ;
3751 unsigned long __cil_tmp102 ;
3752 struct scatterlist *__cil_tmp103 ;
3753 unsigned long __cil_tmp104 ;
3754 unsigned long __cil_tmp105 ;
3755 struct scatterlist *__cil_tmp106 ;
3756 void const *__cil_tmp107 ;
3757 unsigned int __cil_tmp108 ;
3758 unsigned long __cil_tmp109 ;
3759 unsigned long __cil_tmp110 ;
3760 struct scatterlist *__cil_tmp111 ;
3761 void const *__cil_tmp112 ;
3762 unsigned int __cil_tmp113 ;
3763 unsigned long __cil_tmp114 ;
3764 unsigned long __cil_tmp115 ;
3765 struct scatterlist *__cil_tmp116 ;
3766 unsigned long __cil_tmp117 ;
3767 unsigned long __cil_tmp118 ;
3768 struct scatterlist *__cil_tmp119 ;
3769 unsigned int __cil_tmp120 ;
3770 unsigned long __cil_tmp121 ;
3771 unsigned long __cil_tmp122 ;
3772 __u32 __cil_tmp123 ;
3773 unsigned long __cil_tmp124 ;
3774 unsigned long __cil_tmp125 ;
3775 __u32 __cil_tmp126 ;
3776 unsigned long __cil_tmp127 ;
3777 unsigned long __cil_tmp128 ;
3778 unsigned long __cil_tmp129 ;
3779 unsigned long __cil_tmp130 ;
3780 unsigned long __cil_tmp131 ;
3781 unsigned long __cil_tmp132 ;
3782 __u32 __cil_tmp133 ;
3783 unsigned long __cil_tmp134 ;
3784 unsigned long __cil_tmp135 ;
3785 unsigned long __cil_tmp136 ;
3786 __u32 __cil_tmp137 ;
3787 unsigned long __cil_tmp138 ;
3788 unsigned long __cil_tmp139 ;
3789 unsigned long __cil_tmp140 ;
3790 __u32 __cil_tmp141 ;
3791 unsigned long __cil_tmp142 ;
3792 unsigned long __cil_tmp143 ;
3793 unsigned long __cil_tmp144 ;
3794 unsigned long __cil_tmp145 ;
3795 unsigned long __cil_tmp146 ;
3796 unsigned long __cil_tmp147 ;
3797 __u32 __cil_tmp148 ;
3798
3799 {
3800#line 372
3801 state = (struct ppp_mppe_state *)arg;
3802#line 373
3803 __cil_tmp12 = & desc;
3804#line 373
3805 *((struct crypto_blkcipher **)__cil_tmp12) = *((struct crypto_blkcipher **)state);
3806#line 373
3807 __cil_tmp13 = (unsigned long )(& desc) + 8;
3808#line 373
3809 *((void **)__cil_tmp13) = (void *)0;
3810#line 373
3811 __cil_tmp14 = (unsigned long )(& desc) + 16;
3812#line 373
3813 *((u32 *)__cil_tmp14) = 0U;
3814#line 380
3815 __cil_tmp15 = ibuf + 3;
3816#line 380
3817 __cil_tmp16 = *__cil_tmp15;
3818#line 380
3819 __cil_tmp17 = (int )__cil_tmp16;
3820#line 380
3821 __cil_tmp18 = ibuf + 2;
3822#line 380
3823 __cil_tmp19 = *__cil_tmp18;
3824#line 380
3825 __cil_tmp20 = (int )__cil_tmp19;
3826#line 380
3827 __cil_tmp21 = __cil_tmp20 << 8;
3828#line 380
3829 proto = __cil_tmp21 + __cil_tmp17;
3830#line 381
3831 if (proto < 33) {
3832#line 382
3833 return (0);
3834 } else
3835#line 381
3836 if (proto > 250) {
3837#line 382
3838 return (0);
3839 } else {
3840
3841 }
3842 {
3843#line 385
3844 __cil_tmp22 = isize + 2;
3845#line 385
3846 __cil_tmp23 = __cil_tmp22 + 2;
3847#line 385
3848 if (osize < __cil_tmp23) {
3849 {
3850#line 387
3851 __cil_tmp24 = (unsigned long )state;
3852#line 387
3853 __cil_tmp25 = __cil_tmp24 + 80;
3854#line 387
3855 __cil_tmp26 = *((int *)__cil_tmp25);
3856#line 387
3857 __cil_tmp27 = osize + 2;
3858#line 387
3859 __cil_tmp28 = __cil_tmp27 + 2;
3860#line 387
3861 printk("<7>mppe_compress[%d]: osize too small! (have: %d need: %d)\n", __cil_tmp26,
3862 osize, __cil_tmp28);
3863 }
3864#line 390
3865 return (-1);
3866 } else {
3867
3868 }
3869 }
3870 {
3871#line 393
3872 __cil_tmp29 = isize + 2;
3873#line 393
3874 osize = __cil_tmp29 + 2;
3875#line 398
3876 __cil_tmp30 = obuf + 0;
3877#line 398
3878 __cil_tmp31 = ibuf + 0;
3879#line 398
3880 *__cil_tmp30 = *__cil_tmp31;
3881#line 399
3882 __cil_tmp32 = obuf + 1;
3883#line 399
3884 __cil_tmp33 = ibuf + 1;
3885#line 399
3886 *__cil_tmp32 = *__cil_tmp33;
3887#line 400
3888 __cil_tmp34 = (u16 )253;
3889#line 400
3890 __cil_tmp35 = obuf + 2;
3891#line 400
3892 __cil_tmp36 = (void *)__cil_tmp35;
3893#line 400
3894 put_unaligned_be16(__cil_tmp34, __cil_tmp36);
3895#line 401
3896 obuf = obuf + 4;
3897#line 403
3898 __cil_tmp37 = (unsigned long )state;
3899#line 403
3900 __cil_tmp38 = __cil_tmp37 + 64;
3901#line 403
3902 __cil_tmp39 = (unsigned long )state;
3903#line 403
3904 __cil_tmp40 = __cil_tmp39 + 64;
3905#line 403
3906 __cil_tmp41 = *((unsigned int *)__cil_tmp40);
3907#line 403
3908 __cil_tmp42 = __cil_tmp41 + 1U;
3909#line 403
3910 *((unsigned int *)__cil_tmp38) = __cil_tmp42 % 4096U;
3911 }
3912 {
3913#line 404
3914 __cil_tmp43 = (unsigned long )state;
3915#line 404
3916 __cil_tmp44 = __cil_tmp43 + 84;
3917#line 404
3918 __cil_tmp45 = *((int *)__cil_tmp44);
3919#line 404
3920 if (__cil_tmp45 >= 7) {
3921 {
3922#line 405
3923 __cil_tmp46 = (unsigned long )state;
3924#line 405
3925 __cil_tmp47 = __cil_tmp46 + 80;
3926#line 405
3927 __cil_tmp48 = *((int *)__cil_tmp47);
3928#line 405
3929 __cil_tmp49 = (unsigned long )state;
3930#line 405
3931 __cil_tmp50 = __cil_tmp49 + 64;
3932#line 405
3933 __cil_tmp51 = *((unsigned int *)__cil_tmp50);
3934#line 405
3935 printk("<7>mppe_compress[%d]: ccount %d\n", __cil_tmp48, __cil_tmp51);
3936 }
3937 } else {
3938
3939 }
3940 }
3941 {
3942#line 407
3943 __cil_tmp52 = (unsigned long )state;
3944#line 407
3945 __cil_tmp53 = __cil_tmp52 + 64;
3946#line 407
3947 __cil_tmp54 = *((unsigned int *)__cil_tmp53);
3948#line 407
3949 __cil_tmp55 = (u16 )__cil_tmp54;
3950#line 407
3951 __cil_tmp56 = (void *)obuf;
3952#line 407
3953 put_unaligned_be16(__cil_tmp55, __cil_tmp56);
3954 }
3955 {
3956#line 409
3957 __cil_tmp57 = (unsigned long )state;
3958#line 409
3959 __cil_tmp58 = __cil_tmp57 + 68;
3960#line 409
3961 __cil_tmp59 = *((unsigned int *)__cil_tmp58);
3962#line 409
3963 if (! __cil_tmp59) {
3964#line 409
3965 goto _L;
3966 } else {
3967 {
3968#line 409
3969 __cil_tmp60 = (unsigned long )state;
3970#line 409
3971 __cil_tmp61 = __cil_tmp60 + 64;
3972#line 409
3973 __cil_tmp62 = *((unsigned int *)__cil_tmp61);
3974#line 409
3975 __cil_tmp63 = __cil_tmp62 & 255U;
3976#line 409
3977 if (__cil_tmp63 == 255U) {
3978#line 409
3979 goto _L;
3980 } else {
3981 {
3982#line 409
3983 __cil_tmp64 = (unsigned long )state;
3984#line 409
3985 __cil_tmp65 = __cil_tmp64 + 60;
3986#line 409
3987 __cil_tmp66 = *((unsigned char *)__cil_tmp65);
3988#line 409
3989 __cil_tmp67 = (int )__cil_tmp66;
3990#line 409
3991 if (__cil_tmp67 & 128) {
3992 _L:
3993 {
3994#line 413
3995 __cil_tmp68 = (unsigned long )state;
3996#line 413
3997 __cil_tmp69 = __cil_tmp68 + 84;
3998#line 413
3999 if (*((int *)__cil_tmp69)) {
4000 {
4001#line 413
4002 __cil_tmp70 = (unsigned long )state;
4003#line 413
4004 __cil_tmp71 = __cil_tmp70 + 68;
4005#line 413
4006 if (*((unsigned int *)__cil_tmp71)) {
4007 {
4008#line 414
4009 __cil_tmp72 = (unsigned long )state;
4010#line 414
4011 __cil_tmp73 = __cil_tmp72 + 80;
4012#line 414
4013 __cil_tmp74 = *((int *)__cil_tmp73);
4014#line 414
4015 printk("<7>mppe_compress[%d]: rekeying\n", __cil_tmp74);
4016 }
4017 } else {
4018
4019 }
4020 }
4021 } else {
4022
4023 }
4024 }
4025 {
4026#line 416
4027 mppe_rekey(state, 0);
4028#line 417
4029 __cil_tmp75 = (unsigned long )state;
4030#line 417
4031 __cil_tmp76 = __cil_tmp75 + 60;
4032#line 417
4033 __cil_tmp77 = (unsigned long )state;
4034#line 417
4035 __cil_tmp78 = __cil_tmp77 + 60;
4036#line 417
4037 __cil_tmp79 = *((unsigned char *)__cil_tmp78);
4038#line 417
4039 __cil_tmp80 = (int )__cil_tmp79;
4040#line 417
4041 __cil_tmp81 = __cil_tmp80 | 128;
4042#line 417
4043 *((unsigned char *)__cil_tmp76) = (unsigned char )__cil_tmp81;
4044 }
4045 } else {
4046
4047 }
4048 }
4049 }
4050 }
4051 }
4052 }
4053 {
4054#line 419
4055 __cil_tmp82 = obuf + 0;
4056#line 419
4057 __cil_tmp83 = (unsigned long )state;
4058#line 419
4059 __cil_tmp84 = __cil_tmp83 + 60;
4060#line 419
4061 __cil_tmp85 = *((unsigned char *)__cil_tmp84);
4062#line 419
4063 __cil_tmp86 = (int )__cil_tmp85;
4064#line 419
4065 __cil_tmp87 = obuf + 0;
4066#line 419
4067 __cil_tmp88 = *__cil_tmp87;
4068#line 419
4069 __cil_tmp89 = (int )__cil_tmp88;
4070#line 419
4071 __cil_tmp90 = __cil_tmp89 | __cil_tmp86;
4072#line 419
4073 *__cil_tmp82 = (unsigned char )__cil_tmp90;
4074#line 420
4075 __cil_tmp91 = (unsigned long )state;
4076#line 420
4077 __cil_tmp92 = __cil_tmp91 + 60;
4078#line 420
4079 __cil_tmp93 = (unsigned long )state;
4080#line 420
4081 __cil_tmp94 = __cil_tmp93 + 60;
4082#line 420
4083 __cil_tmp95 = *((unsigned char *)__cil_tmp94);
4084#line 420
4085 __cil_tmp96 = (int )__cil_tmp95;
4086#line 420
4087 __cil_tmp97 = __cil_tmp96 & -129;
4088#line 420
4089 *((unsigned char *)__cil_tmp92) = (unsigned char )__cil_tmp97;
4090#line 422
4091 obuf = obuf + 2;
4092#line 423
4093 ibuf = ibuf + 2;
4094#line 424
4095 isize = isize - 2;
4096#line 427
4097 __cil_tmp98 = 0 * 40UL;
4098#line 427
4099 __cil_tmp99 = (unsigned long )(sg_in) + __cil_tmp98;
4100#line 427
4101 __cil_tmp100 = (struct scatterlist *)__cil_tmp99;
4102#line 427
4103 sg_init_table(__cil_tmp100, 1U);
4104#line 428
4105 __cil_tmp101 = 0 * 40UL;
4106#line 428
4107 __cil_tmp102 = (unsigned long )(sg_out) + __cil_tmp101;
4108#line 428
4109 __cil_tmp103 = (struct scatterlist *)__cil_tmp102;
4110#line 428
4111 sg_init_table(__cil_tmp103, 1U);
4112#line 429
4113 __cil_tmp104 = 0 * 40UL;
4114#line 429
4115 __cil_tmp105 = (unsigned long )(sg_in) + __cil_tmp104;
4116#line 429
4117 __cil_tmp106 = (struct scatterlist *)__cil_tmp105;
4118#line 429
4119 __cil_tmp107 = (void const *)ibuf;
4120#line 429
4121 __cil_tmp108 = (unsigned int )isize;
4122#line 429
4123 setup_sg(__cil_tmp106, __cil_tmp107, __cil_tmp108);
4124#line 430
4125 __cil_tmp109 = 0 * 40UL;
4126#line 430
4127 __cil_tmp110 = (unsigned long )(sg_out) + __cil_tmp109;
4128#line 430
4129 __cil_tmp111 = (struct scatterlist *)__cil_tmp110;
4130#line 430
4131 __cil_tmp112 = (void const *)obuf;
4132#line 430
4133 __cil_tmp113 = (unsigned int )osize;
4134#line 430
4135 setup_sg(__cil_tmp111, __cil_tmp112, __cil_tmp113);
4136#line 431
4137 __cil_tmp114 = 0 * 40UL;
4138#line 431
4139 __cil_tmp115 = (unsigned long )(sg_out) + __cil_tmp114;
4140#line 431
4141 __cil_tmp116 = (struct scatterlist *)__cil_tmp115;
4142#line 431
4143 __cil_tmp117 = 0 * 40UL;
4144#line 431
4145 __cil_tmp118 = (unsigned long )(sg_in) + __cil_tmp117;
4146#line 431
4147 __cil_tmp119 = (struct scatterlist *)__cil_tmp118;
4148#line 431
4149 __cil_tmp120 = (unsigned int )isize;
4150#line 431
4151 tmp = crypto_blkcipher_encrypt(& desc, __cil_tmp116, __cil_tmp119, __cil_tmp120);
4152 }
4153#line 431
4154 if (tmp != 0) {
4155 {
4156#line 432
4157 printk("<7>crypto_cypher_encrypt failed\n");
4158 }
4159#line 433
4160 return (-1);
4161 } else {
4162
4163 }
4164#line 436
4165 __cil_tmp121 = (unsigned long )state;
4166#line 436
4167 __cil_tmp122 = __cil_tmp121 + 88;
4168#line 436
4169 __cil_tmp123 = (__u32 )isize;
4170#line 436
4171 __cil_tmp124 = (unsigned long )state;
4172#line 436
4173 __cil_tmp125 = __cil_tmp124 + 88;
4174#line 436
4175 __cil_tmp126 = *((__u32 *)__cil_tmp125);
4176#line 436
4177 *((__u32 *)__cil_tmp122) = __cil_tmp126 + __cil_tmp123;
4178#line 437
4179 __cil_tmp127 = 88 + 4;
4180#line 437
4181 __cil_tmp128 = (unsigned long )state;
4182#line 437
4183 __cil_tmp129 = __cil_tmp128 + __cil_tmp127;
4184#line 437
4185 __cil_tmp130 = 88 + 4;
4186#line 437
4187 __cil_tmp131 = (unsigned long )state;
4188#line 437
4189 __cil_tmp132 = __cil_tmp131 + __cil_tmp130;
4190#line 437
4191 __cil_tmp133 = *((__u32 *)__cil_tmp132);
4192#line 437
4193 *((__u32 *)__cil_tmp129) = __cil_tmp133 + 1U;
4194#line 438
4195 __cil_tmp134 = 88 + 8;
4196#line 438
4197 __cil_tmp135 = (unsigned long )state;
4198#line 438
4199 __cil_tmp136 = __cil_tmp135 + __cil_tmp134;
4200#line 438
4201 __cil_tmp137 = (__u32 )osize;
4202#line 438
4203 __cil_tmp138 = 88 + 8;
4204#line 438
4205 __cil_tmp139 = (unsigned long )state;
4206#line 438
4207 __cil_tmp140 = __cil_tmp139 + __cil_tmp138;
4208#line 438
4209 __cil_tmp141 = *((__u32 *)__cil_tmp140);
4210#line 438
4211 *((__u32 *)__cil_tmp136) = __cil_tmp141 + __cil_tmp137;
4212#line 439
4213 __cil_tmp142 = 88 + 12;
4214#line 439
4215 __cil_tmp143 = (unsigned long )state;
4216#line 439
4217 __cil_tmp144 = __cil_tmp143 + __cil_tmp142;
4218#line 439
4219 __cil_tmp145 = 88 + 12;
4220#line 439
4221 __cil_tmp146 = (unsigned long )state;
4222#line 439
4223 __cil_tmp147 = __cil_tmp146 + __cil_tmp145;
4224#line 439
4225 __cil_tmp148 = *((__u32 *)__cil_tmp147);
4226#line 439
4227 *((__u32 *)__cil_tmp144) = __cil_tmp148 + 1U;
4228#line 441
4229 return (osize);
4230}
4231}
4232#line 448 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
4233static void mppe_comp_stats(void *arg , struct compstat *stats )
4234{ struct ppp_mppe_state *state ;
4235 unsigned long __cil_tmp4 ;
4236 unsigned long __cil_tmp5 ;
4237
4238 {
4239#line 450
4240 state = (struct ppp_mppe_state *)arg;
4241#line 452
4242 __cil_tmp4 = (unsigned long )state;
4243#line 452
4244 __cil_tmp5 = __cil_tmp4 + 88;
4245#line 452
4246 *stats = *((struct compstat *)__cil_tmp5);
4247#line 453
4248 return;
4249}
4250}
4251#line 455 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
4252static int mppe_decomp_init(void *arg , unsigned char *options , int optlen , int unit ,
4253 int hdrlen , int mru , int debug )
4254{ int tmp ;
4255
4256 {
4257 {
4258#line 460
4259 tmp = mppe_init(arg, options, optlen, unit, debug, "mppe_decomp_init");
4260 }
4261#line 460
4262 return (tmp);
4263}
4264}
4265#line 466 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
4266static void mppe_decomp_reset(void *arg )
4267{
4268
4269 {
4270#line 469
4271 return;
4272}
4273}
4274#line 475 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
4275static int mppe_decompress(void *arg , unsigned char *ibuf , int isize , unsigned char *obuf ,
4276 int osize )
4277{ struct ppp_mppe_state *state ;
4278 struct blkcipher_desc desc ;
4279 unsigned int ccount ;
4280 int flushed ;
4281 int sanity ;
4282 struct scatterlist sg_in[1] ;
4283 struct scatterlist sg_out[1] ;
4284 int tmp ;
4285 int tmp___0 ;
4286 struct blkcipher_desc *__cil_tmp15 ;
4287 unsigned long __cil_tmp16 ;
4288 unsigned long __cil_tmp17 ;
4289 unsigned char *__cil_tmp18 ;
4290 unsigned char __cil_tmp19 ;
4291 int __cil_tmp20 ;
4292 int __cil_tmp21 ;
4293 unsigned long __cil_tmp22 ;
4294 unsigned long __cil_tmp23 ;
4295 unsigned long __cil_tmp24 ;
4296 unsigned long __cil_tmp25 ;
4297 int __cil_tmp26 ;
4298 int __cil_tmp27 ;
4299 int __cil_tmp28 ;
4300 unsigned long __cil_tmp29 ;
4301 unsigned long __cil_tmp30 ;
4302 int __cil_tmp31 ;
4303 int __cil_tmp32 ;
4304 int __cil_tmp33 ;
4305 int __cil_tmp34 ;
4306 unsigned char *__cil_tmp35 ;
4307 unsigned char __cil_tmp36 ;
4308 int __cil_tmp37 ;
4309 unsigned char *__cil_tmp38 ;
4310 unsigned char __cil_tmp39 ;
4311 int __cil_tmp40 ;
4312 int __cil_tmp41 ;
4313 int __cil_tmp42 ;
4314 int __cil_tmp43 ;
4315 unsigned long __cil_tmp44 ;
4316 unsigned long __cil_tmp45 ;
4317 int __cil_tmp46 ;
4318 unsigned long __cil_tmp47 ;
4319 unsigned long __cil_tmp48 ;
4320 int __cil_tmp49 ;
4321 unsigned char *__cil_tmp50 ;
4322 unsigned char __cil_tmp51 ;
4323 int __cil_tmp52 ;
4324 int __cil_tmp53 ;
4325 int __cil_tmp54 ;
4326 unsigned long __cil_tmp55 ;
4327 unsigned long __cil_tmp56 ;
4328 int __cil_tmp57 ;
4329 unsigned long __cil_tmp58 ;
4330 unsigned long __cil_tmp59 ;
4331 unsigned long __cil_tmp60 ;
4332 unsigned long __cil_tmp61 ;
4333 int __cil_tmp62 ;
4334 unsigned long __cil_tmp63 ;
4335 unsigned long __cil_tmp64 ;
4336 unsigned int __cil_tmp65 ;
4337 unsigned long __cil_tmp66 ;
4338 unsigned long __cil_tmp67 ;
4339 int __cil_tmp68 ;
4340 unsigned long __cil_tmp69 ;
4341 unsigned long __cil_tmp70 ;
4342 unsigned long __cil_tmp71 ;
4343 unsigned long __cil_tmp72 ;
4344 int __cil_tmp73 ;
4345 unsigned long __cil_tmp74 ;
4346 unsigned long __cil_tmp75 ;
4347 unsigned int __cil_tmp76 ;
4348 unsigned long __cil_tmp77 ;
4349 unsigned long __cil_tmp78 ;
4350 int __cil_tmp79 ;
4351 unsigned long __cil_tmp80 ;
4352 unsigned long __cil_tmp81 ;
4353 unsigned long __cil_tmp82 ;
4354 unsigned long __cil_tmp83 ;
4355 int __cil_tmp84 ;
4356 unsigned long __cil_tmp85 ;
4357 unsigned long __cil_tmp86 ;
4358 int __cil_tmp87 ;
4359 unsigned long __cil_tmp88 ;
4360 unsigned long __cil_tmp89 ;
4361 unsigned int __cil_tmp90 ;
4362 unsigned long __cil_tmp91 ;
4363 unsigned long __cil_tmp92 ;
4364 unsigned int __cil_tmp93 ;
4365 unsigned long __cil_tmp94 ;
4366 unsigned long __cil_tmp95 ;
4367 unsigned long __cil_tmp96 ;
4368 unsigned long __cil_tmp97 ;
4369 unsigned int __cil_tmp98 ;
4370 unsigned int __cil_tmp99 ;
4371 unsigned long __cil_tmp100 ;
4372 unsigned long __cil_tmp101 ;
4373 int __cil_tmp102 ;
4374 unsigned long __cil_tmp103 ;
4375 unsigned long __cil_tmp104 ;
4376 unsigned long __cil_tmp105 ;
4377 unsigned long __cil_tmp106 ;
4378 unsigned int __cil_tmp107 ;
4379 unsigned int __cil_tmp108 ;
4380 unsigned long __cil_tmp109 ;
4381 unsigned long __cil_tmp110 ;
4382 unsigned int __cil_tmp111 ;
4383 unsigned long __cil_tmp112 ;
4384 unsigned long __cil_tmp113 ;
4385 unsigned long __cil_tmp114 ;
4386 unsigned long __cil_tmp115 ;
4387 unsigned int __cil_tmp116 ;
4388 unsigned int __cil_tmp117 ;
4389 unsigned int __cil_tmp118 ;
4390 unsigned long __cil_tmp119 ;
4391 unsigned long __cil_tmp120 ;
4392 unsigned long __cil_tmp121 ;
4393 unsigned long __cil_tmp122 ;
4394 unsigned int __cil_tmp123 ;
4395 unsigned int __cil_tmp124 ;
4396 unsigned long __cil_tmp125 ;
4397 unsigned long __cil_tmp126 ;
4398 unsigned long __cil_tmp127 ;
4399 unsigned long __cil_tmp128 ;
4400 unsigned char *__cil_tmp129 ;
4401 __u8 *__cil_tmp130 ;
4402 unsigned char *__cil_tmp131 ;
4403 __u8 *__cil_tmp132 ;
4404 unsigned long __cil_tmp133 ;
4405 unsigned long __cil_tmp134 ;
4406 struct scatterlist *__cil_tmp135 ;
4407 unsigned long __cil_tmp136 ;
4408 unsigned long __cil_tmp137 ;
4409 struct scatterlist *__cil_tmp138 ;
4410 unsigned long __cil_tmp139 ;
4411 unsigned long __cil_tmp140 ;
4412 struct scatterlist *__cil_tmp141 ;
4413 void const *__cil_tmp142 ;
4414 unsigned long __cil_tmp143 ;
4415 unsigned long __cil_tmp144 ;
4416 struct scatterlist *__cil_tmp145 ;
4417 void const *__cil_tmp146 ;
4418 unsigned long __cil_tmp147 ;
4419 unsigned long __cil_tmp148 ;
4420 struct scatterlist *__cil_tmp149 ;
4421 unsigned long __cil_tmp150 ;
4422 unsigned long __cil_tmp151 ;
4423 struct scatterlist *__cil_tmp152 ;
4424 unsigned char *__cil_tmp153 ;
4425 unsigned char __cil_tmp154 ;
4426 int __cil_tmp155 ;
4427 int __cil_tmp156 ;
4428 unsigned char *__cil_tmp157 ;
4429 unsigned char *__cil_tmp158 ;
4430 unsigned char *__cil_tmp159 ;
4431 unsigned long __cil_tmp160 ;
4432 unsigned long __cil_tmp161 ;
4433 struct scatterlist *__cil_tmp162 ;
4434 unsigned char *__cil_tmp163 ;
4435 void const *__cil_tmp164 ;
4436 int __cil_tmp165 ;
4437 unsigned int __cil_tmp166 ;
4438 unsigned long __cil_tmp167 ;
4439 unsigned long __cil_tmp168 ;
4440 struct scatterlist *__cil_tmp169 ;
4441 unsigned char *__cil_tmp170 ;
4442 void const *__cil_tmp171 ;
4443 int __cil_tmp172 ;
4444 unsigned int __cil_tmp173 ;
4445 unsigned long __cil_tmp174 ;
4446 unsigned long __cil_tmp175 ;
4447 struct scatterlist *__cil_tmp176 ;
4448 unsigned long __cil_tmp177 ;
4449 unsigned long __cil_tmp178 ;
4450 struct scatterlist *__cil_tmp179 ;
4451 int __cil_tmp180 ;
4452 unsigned int __cil_tmp181 ;
4453 unsigned long __cil_tmp182 ;
4454 unsigned long __cil_tmp183 ;
4455 __u32 __cil_tmp184 ;
4456 unsigned long __cil_tmp185 ;
4457 unsigned long __cil_tmp186 ;
4458 __u32 __cil_tmp187 ;
4459 unsigned long __cil_tmp188 ;
4460 unsigned long __cil_tmp189 ;
4461 unsigned long __cil_tmp190 ;
4462 unsigned long __cil_tmp191 ;
4463 unsigned long __cil_tmp192 ;
4464 unsigned long __cil_tmp193 ;
4465 __u32 __cil_tmp194 ;
4466 unsigned long __cil_tmp195 ;
4467 unsigned long __cil_tmp196 ;
4468 unsigned long __cil_tmp197 ;
4469 __u32 __cil_tmp198 ;
4470 unsigned long __cil_tmp199 ;
4471 unsigned long __cil_tmp200 ;
4472 unsigned long __cil_tmp201 ;
4473 __u32 __cil_tmp202 ;
4474 unsigned long __cil_tmp203 ;
4475 unsigned long __cil_tmp204 ;
4476 unsigned long __cil_tmp205 ;
4477 unsigned long __cil_tmp206 ;
4478 unsigned long __cil_tmp207 ;
4479 unsigned long __cil_tmp208 ;
4480 __u32 __cil_tmp209 ;
4481 unsigned long __cil_tmp210 ;
4482 unsigned long __cil_tmp211 ;
4483 unsigned long __cil_tmp212 ;
4484 unsigned long __cil_tmp213 ;
4485 int __cil_tmp214 ;
4486
4487 {
4488#line 479
4489 state = (struct ppp_mppe_state *)arg;
4490#line 480
4491 __cil_tmp15 = & desc;
4492#line 480
4493 *((struct crypto_blkcipher **)__cil_tmp15) = *((struct crypto_blkcipher **)state);
4494#line 480
4495 __cil_tmp16 = (unsigned long )(& desc) + 8;
4496#line 480
4497 *((void **)__cil_tmp16) = (void *)0;
4498#line 480
4499 __cil_tmp17 = (unsigned long )(& desc) + 16;
4500#line 480
4501 *((u32 *)__cil_tmp17) = 0U;
4502#line 482
4503 __cil_tmp18 = ibuf + 4;
4504#line 482
4505 __cil_tmp19 = *__cil_tmp18;
4506#line 482
4507 __cil_tmp20 = (int )__cil_tmp19;
4508#line 482
4509 __cil_tmp21 = __cil_tmp20 & 240;
4510#line 482
4511 flushed = __cil_tmp21 & 128;
4512#line 483
4513 sanity = 0;
4514#line 486
4515 if (isize <= 6) {
4516 {
4517#line 487
4518 __cil_tmp22 = (unsigned long )state;
4519#line 487
4520 __cil_tmp23 = __cil_tmp22 + 84;
4521#line 487
4522 if (*((int *)__cil_tmp23)) {
4523 {
4524#line 488
4525 __cil_tmp24 = (unsigned long )state;
4526#line 488
4527 __cil_tmp25 = __cil_tmp24 + 80;
4528#line 488
4529 __cil_tmp26 = *((int *)__cil_tmp25);
4530#line 488
4531 printk("<7>mppe_decompress[%d]: short pkt (%d)\n", __cil_tmp26, isize);
4532 }
4533 } else {
4534
4535 }
4536 }
4537#line 491
4538 return (-1);
4539 } else {
4540
4541 }
4542 {
4543#line 500
4544 __cil_tmp27 = isize - 2;
4545#line 500
4546 __cil_tmp28 = __cil_tmp27 - 1;
4547#line 500
4548 if (osize < __cil_tmp28) {
4549 {
4550#line 501
4551 __cil_tmp29 = (unsigned long )state;
4552#line 501
4553 __cil_tmp30 = __cil_tmp29 + 80;
4554#line 501
4555 __cil_tmp31 = *((int *)__cil_tmp30);
4556#line 501
4557 __cil_tmp32 = isize - 2;
4558#line 501
4559 __cil_tmp33 = __cil_tmp32 - 1;
4560#line 501
4561 printk("<7>mppe_decompress[%d]: osize too small! (have: %d need: %d)\n", __cil_tmp31,
4562 osize, __cil_tmp33);
4563 }
4564#line 504
4565 return (-1);
4566 } else {
4567
4568 }
4569 }
4570#line 506
4571 __cil_tmp34 = isize - 2;
4572#line 506
4573 osize = __cil_tmp34 - 2;
4574#line 508
4575 __cil_tmp35 = ibuf + 5;
4576#line 508
4577 __cil_tmp36 = *__cil_tmp35;
4578#line 508
4579 __cil_tmp37 = (int )__cil_tmp36;
4580#line 508
4581 __cil_tmp38 = ibuf + 4;
4582#line 508
4583 __cil_tmp39 = *__cil_tmp38;
4584#line 508
4585 __cil_tmp40 = (int )__cil_tmp39;
4586#line 508
4587 __cil_tmp41 = __cil_tmp40 & 15;
4588#line 508
4589 __cil_tmp42 = __cil_tmp41 << 8;
4590#line 508
4591 __cil_tmp43 = __cil_tmp42 + __cil_tmp37;
4592#line 508
4593 ccount = (unsigned int )__cil_tmp43;
4594 {
4595#line 509
4596 __cil_tmp44 = (unsigned long )state;
4597#line 509
4598 __cil_tmp45 = __cil_tmp44 + 84;
4599#line 509
4600 __cil_tmp46 = *((int *)__cil_tmp45);
4601#line 509
4602 if (__cil_tmp46 >= 7) {
4603 {
4604#line 510
4605 __cil_tmp47 = (unsigned long )state;
4606#line 510
4607 __cil_tmp48 = __cil_tmp47 + 80;
4608#line 510
4609 __cil_tmp49 = *((int *)__cil_tmp48);
4610#line 510
4611 printk("<7>mppe_decompress[%d]: ccount %d\n", __cil_tmp49, ccount);
4612 }
4613 } else {
4614
4615 }
4616 }
4617 {
4618#line 514
4619 __cil_tmp50 = ibuf + 4;
4620#line 514
4621 __cil_tmp51 = *__cil_tmp50;
4622#line 514
4623 __cil_tmp52 = (int )__cil_tmp51;
4624#line 514
4625 __cil_tmp53 = __cil_tmp52 & 240;
4626#line 514
4627 __cil_tmp54 = __cil_tmp53 & 16;
4628#line 514
4629 if (! __cil_tmp54) {
4630 {
4631#line 515
4632 __cil_tmp55 = (unsigned long )state;
4633#line 515
4634 __cil_tmp56 = __cil_tmp55 + 80;
4635#line 515
4636 __cil_tmp57 = *((int *)__cil_tmp56);
4637#line 515
4638 printk("<7>mppe_decompress[%d]: ENCRYPTED bit not set!\n", __cil_tmp57);
4639#line 518
4640 __cil_tmp58 = (unsigned long )state;
4641#line 518
4642 __cil_tmp59 = __cil_tmp58 + 76;
4643#line 518
4644 __cil_tmp60 = (unsigned long )state;
4645#line 518
4646 __cil_tmp61 = __cil_tmp60 + 76;
4647#line 518
4648 __cil_tmp62 = *((int *)__cil_tmp61);
4649#line 518
4650 *((int *)__cil_tmp59) = __cil_tmp62 + 100;
4651#line 519
4652 sanity = 1;
4653 }
4654 } else {
4655
4656 }
4657 }
4658 {
4659#line 521
4660 __cil_tmp63 = (unsigned long )state;
4661#line 521
4662 __cil_tmp64 = __cil_tmp63 + 68;
4663#line 521
4664 __cil_tmp65 = *((unsigned int *)__cil_tmp64);
4665#line 521
4666 if (! __cil_tmp65) {
4667#line 521
4668 if (! flushed) {
4669 {
4670#line 522
4671 __cil_tmp66 = (unsigned long )state;
4672#line 522
4673 __cil_tmp67 = __cil_tmp66 + 80;
4674#line 522
4675 __cil_tmp68 = *((int *)__cil_tmp67);
4676#line 522
4677 printk("<7>mppe_decompress[%d]: FLUSHED bit not set in stateless mode!\n", __cil_tmp68);
4678#line 524
4679 __cil_tmp69 = (unsigned long )state;
4680#line 524
4681 __cil_tmp70 = __cil_tmp69 + 76;
4682#line 524
4683 __cil_tmp71 = (unsigned long )state;
4684#line 524
4685 __cil_tmp72 = __cil_tmp71 + 76;
4686#line 524
4687 __cil_tmp73 = *((int *)__cil_tmp72);
4688#line 524
4689 *((int *)__cil_tmp70) = __cil_tmp73 + 100;
4690#line 525
4691 sanity = 1;
4692 }
4693 } else {
4694
4695 }
4696 } else {
4697
4698 }
4699 }
4700 {
4701#line 527
4702 __cil_tmp74 = (unsigned long )state;
4703#line 527
4704 __cil_tmp75 = __cil_tmp74 + 68;
4705#line 527
4706 if (*((unsigned int *)__cil_tmp75)) {
4707 {
4708#line 527
4709 __cil_tmp76 = ccount & 255U;
4710#line 527
4711 if (__cil_tmp76 == 255U) {
4712#line 527
4713 if (! flushed) {
4714 {
4715#line 528
4716 __cil_tmp77 = (unsigned long )state;
4717#line 528
4718 __cil_tmp78 = __cil_tmp77 + 80;
4719#line 528
4720 __cil_tmp79 = *((int *)__cil_tmp78);
4721#line 528
4722 printk("<7>mppe_decompress[%d]: FLUSHED bit not set on flag packet!\n", __cil_tmp79);
4723#line 530
4724 __cil_tmp80 = (unsigned long )state;
4725#line 530
4726 __cil_tmp81 = __cil_tmp80 + 76;
4727#line 530
4728 __cil_tmp82 = (unsigned long )state;
4729#line 530
4730 __cil_tmp83 = __cil_tmp82 + 76;
4731#line 530
4732 __cil_tmp84 = *((int *)__cil_tmp83);
4733#line 530
4734 *((int *)__cil_tmp81) = __cil_tmp84 + 100;
4735#line 531
4736 sanity = 1;
4737 }
4738 } else {
4739
4740 }
4741 } else {
4742
4743 }
4744 }
4745 } else {
4746
4747 }
4748 }
4749#line 534
4750 if (sanity) {
4751 {
4752#line 535
4753 __cil_tmp85 = (unsigned long )state;
4754#line 535
4755 __cil_tmp86 = __cil_tmp85 + 76;
4756#line 535
4757 __cil_tmp87 = *((int *)__cil_tmp86);
4758#line 535
4759 if (__cil_tmp87 < 1600) {
4760#line 536
4761 return (-1);
4762 } else {
4763#line 543
4764 return (-2);
4765 }
4766 }
4767 } else {
4768
4769 }
4770 {
4771#line 550
4772 __cil_tmp88 = (unsigned long )state;
4773#line 550
4774 __cil_tmp89 = __cil_tmp88 + 68;
4775#line 550
4776 __cil_tmp90 = *((unsigned int *)__cil_tmp89);
4777#line 550
4778 if (! __cil_tmp90) {
4779 {
4780#line 552
4781 while (1) {
4782 while_continue: ;
4783 {
4784#line 552
4785 __cil_tmp91 = (unsigned long )state;
4786#line 552
4787 __cil_tmp92 = __cil_tmp91 + 64;
4788#line 552
4789 __cil_tmp93 = *((unsigned int *)__cil_tmp92);
4790#line 552
4791 if (__cil_tmp93 != ccount) {
4792
4793 } else {
4794#line 552
4795 goto while_break;
4796 }
4797 }
4798 {
4799#line 553
4800 mppe_rekey(state, 0);
4801#line 554
4802 __cil_tmp94 = (unsigned long )state;
4803#line 554
4804 __cil_tmp95 = __cil_tmp94 + 64;
4805#line 554
4806 __cil_tmp96 = (unsigned long )state;
4807#line 554
4808 __cil_tmp97 = __cil_tmp96 + 64;
4809#line 554
4810 __cil_tmp98 = *((unsigned int *)__cil_tmp97);
4811#line 554
4812 __cil_tmp99 = __cil_tmp98 + 1U;
4813#line 554
4814 *((unsigned int *)__cil_tmp95) = __cil_tmp99 % 4096U;
4815 }
4816 }
4817 while_break: ;
4818 }
4819 } else {
4820 {
4821#line 558
4822 __cil_tmp100 = (unsigned long )state;
4823#line 558
4824 __cil_tmp101 = __cil_tmp100 + 72;
4825#line 558
4826 __cil_tmp102 = *((int *)__cil_tmp101);
4827#line 558
4828 if (! __cil_tmp102) {
4829#line 560
4830 __cil_tmp103 = (unsigned long )state;
4831#line 560
4832 __cil_tmp104 = __cil_tmp103 + 64;
4833#line 560
4834 __cil_tmp105 = (unsigned long )state;
4835#line 560
4836 __cil_tmp106 = __cil_tmp105 + 64;
4837#line 560
4838 __cil_tmp107 = *((unsigned int *)__cil_tmp106);
4839#line 560
4840 __cil_tmp108 = __cil_tmp107 + 1U;
4841#line 560
4842 *((unsigned int *)__cil_tmp104) = __cil_tmp108 % 4096U;
4843 {
4844#line 561
4845 __cil_tmp109 = (unsigned long )state;
4846#line 561
4847 __cil_tmp110 = __cil_tmp109 + 64;
4848#line 561
4849 __cil_tmp111 = *((unsigned int *)__cil_tmp110);
4850#line 561
4851 if (ccount != __cil_tmp111) {
4852#line 567
4853 __cil_tmp112 = (unsigned long )state;
4854#line 567
4855 __cil_tmp113 = __cil_tmp112 + 72;
4856#line 567
4857 *((int *)__cil_tmp113) = 1;
4858#line 568
4859 return (-1);
4860 } else {
4861
4862 }
4863 }
4864 } else
4865#line 572
4866 if (! flushed) {
4867#line 574
4868 return (-1);
4869 } else {
4870 {
4871#line 577
4872 while (1) {
4873 while_continue___0: ;
4874 {
4875#line 577
4876 __cil_tmp114 = (unsigned long )state;
4877#line 577
4878 __cil_tmp115 = __cil_tmp114 + 64;
4879#line 577
4880 __cil_tmp116 = *((unsigned int *)__cil_tmp115);
4881#line 577
4882 __cil_tmp117 = __cil_tmp116 & 4294967040U;
4883#line 577
4884 __cil_tmp118 = ccount & 4294967040U;
4885#line 577
4886 if (__cil_tmp118 != __cil_tmp117) {
4887
4888 } else {
4889#line 577
4890 goto while_break___0;
4891 }
4892 }
4893 {
4894#line 579
4895 mppe_rekey(state, 0);
4896#line 580
4897 __cil_tmp119 = (unsigned long )state;
4898#line 580
4899 __cil_tmp120 = __cil_tmp119 + 64;
4900#line 580
4901 __cil_tmp121 = (unsigned long )state;
4902#line 580
4903 __cil_tmp122 = __cil_tmp121 + 64;
4904#line 580
4905 __cil_tmp123 = *((unsigned int *)__cil_tmp122);
4906#line 580
4907 __cil_tmp124 = __cil_tmp123 + 256U;
4908#line 580
4909 *((unsigned int *)__cil_tmp120) = __cil_tmp124 % 4096U;
4910 }
4911 }
4912 while_break___0: ;
4913 }
4914#line 586
4915 __cil_tmp125 = (unsigned long )state;
4916#line 586
4917 __cil_tmp126 = __cil_tmp125 + 72;
4918#line 586
4919 *((int *)__cil_tmp126) = 0;
4920#line 587
4921 __cil_tmp127 = (unsigned long )state;
4922#line 587
4923 __cil_tmp128 = __cil_tmp127 + 64;
4924#line 587
4925 *((unsigned int *)__cil_tmp128) = ccount;
4926 }
4927 }
4928#line 597
4929 if (flushed) {
4930 {
4931#line 598
4932 mppe_rekey(state, 0);
4933 }
4934 } else {
4935
4936 }
4937 }
4938 }
4939 {
4940#line 605
4941 __cil_tmp129 = obuf + 0;
4942#line 605
4943 __cil_tmp130 = ibuf + 0;
4944#line 605
4945 *__cil_tmp129 = *__cil_tmp130;
4946#line 606
4947 __cil_tmp131 = obuf + 1;
4948#line 606
4949 __cil_tmp132 = ibuf + 1;
4950#line 606
4951 *__cil_tmp131 = *__cil_tmp132;
4952#line 607
4953 obuf = obuf + 2;
4954#line 608
4955 ibuf = ibuf + 6;
4956#line 609
4957 isize = isize - 6;
4958#line 616
4959 __cil_tmp133 = 0 * 40UL;
4960#line 616
4961 __cil_tmp134 = (unsigned long )(sg_in) + __cil_tmp133;
4962#line 616
4963 __cil_tmp135 = (struct scatterlist *)__cil_tmp134;
4964#line 616
4965 sg_init_table(__cil_tmp135, 1U);
4966#line 617
4967 __cil_tmp136 = 0 * 40UL;
4968#line 617
4969 __cil_tmp137 = (unsigned long )(sg_out) + __cil_tmp136;
4970#line 617
4971 __cil_tmp138 = (struct scatterlist *)__cil_tmp137;
4972#line 617
4973 sg_init_table(__cil_tmp138, 1U);
4974#line 618
4975 __cil_tmp139 = 0 * 40UL;
4976#line 618
4977 __cil_tmp140 = (unsigned long )(sg_in) + __cil_tmp139;
4978#line 618
4979 __cil_tmp141 = (struct scatterlist *)__cil_tmp140;
4980#line 618
4981 __cil_tmp142 = (void const *)ibuf;
4982#line 618
4983 setup_sg(__cil_tmp141, __cil_tmp142, 1U);
4984#line 619
4985 __cil_tmp143 = 0 * 40UL;
4986#line 619
4987 __cil_tmp144 = (unsigned long )(sg_out) + __cil_tmp143;
4988#line 619
4989 __cil_tmp145 = (struct scatterlist *)__cil_tmp144;
4990#line 619
4991 __cil_tmp146 = (void const *)obuf;
4992#line 619
4993 setup_sg(__cil_tmp145, __cil_tmp146, 1U);
4994#line 620
4995 __cil_tmp147 = 0 * 40UL;
4996#line 620
4997 __cil_tmp148 = (unsigned long )(sg_out) + __cil_tmp147;
4998#line 620
4999 __cil_tmp149 = (struct scatterlist *)__cil_tmp148;
5000#line 620
5001 __cil_tmp150 = 0 * 40UL;
5002#line 620
5003 __cil_tmp151 = (unsigned long )(sg_in) + __cil_tmp150;
5004#line 620
5005 __cil_tmp152 = (struct scatterlist *)__cil_tmp151;
5006#line 620
5007 tmp = crypto_blkcipher_decrypt(& desc, __cil_tmp149, __cil_tmp152, 1U);
5008 }
5009#line 620
5010 if (tmp != 0) {
5011 {
5012#line 621
5013 printk("<7>crypto_cypher_decrypt failed\n");
5014 }
5015#line 622
5016 return (-1);
5017 } else {
5018
5019 }
5020 {
5021#line 630
5022 __cil_tmp153 = obuf + 0;
5023#line 630
5024 __cil_tmp154 = *__cil_tmp153;
5025#line 630
5026 __cil_tmp155 = (int )__cil_tmp154;
5027#line 630
5028 __cil_tmp156 = __cil_tmp155 & 1;
5029#line 630
5030 if (__cil_tmp156 != 0) {
5031#line 631
5032 __cil_tmp157 = obuf + 1;
5033#line 631
5034 __cil_tmp158 = obuf + 0;
5035#line 631
5036 *__cil_tmp157 = *__cil_tmp158;
5037#line 632
5038 __cil_tmp159 = obuf + 0;
5039#line 632
5040 *__cil_tmp159 = (unsigned char)0;
5041#line 633
5042 obuf = obuf + 1;
5043#line 634
5044 osize = osize + 1;
5045 } else {
5046
5047 }
5048 }
5049 {
5050#line 638
5051 __cil_tmp160 = 0 * 40UL;
5052#line 638
5053 __cil_tmp161 = (unsigned long )(sg_in) + __cil_tmp160;
5054#line 638
5055 __cil_tmp162 = (struct scatterlist *)__cil_tmp161;
5056#line 638
5057 __cil_tmp163 = ibuf + 1;
5058#line 638
5059 __cil_tmp164 = (void const *)__cil_tmp163;
5060#line 638
5061 __cil_tmp165 = isize - 1;
5062#line 638
5063 __cil_tmp166 = (unsigned int )__cil_tmp165;
5064#line 638
5065 setup_sg(__cil_tmp162, __cil_tmp164, __cil_tmp166);
5066#line 639
5067 __cil_tmp167 = 0 * 40UL;
5068#line 639
5069 __cil_tmp168 = (unsigned long )(sg_out) + __cil_tmp167;
5070#line 639
5071 __cil_tmp169 = (struct scatterlist *)__cil_tmp168;
5072#line 639
5073 __cil_tmp170 = obuf + 1;
5074#line 639
5075 __cil_tmp171 = (void const *)__cil_tmp170;
5076#line 639
5077 __cil_tmp172 = osize - 1;
5078#line 639
5079 __cil_tmp173 = (unsigned int )__cil_tmp172;
5080#line 639
5081 setup_sg(__cil_tmp169, __cil_tmp171, __cil_tmp173);
5082#line 640
5083 __cil_tmp174 = 0 * 40UL;
5084#line 640
5085 __cil_tmp175 = (unsigned long )(sg_out) + __cil_tmp174;
5086#line 640
5087 __cil_tmp176 = (struct scatterlist *)__cil_tmp175;
5088#line 640
5089 __cil_tmp177 = 0 * 40UL;
5090#line 640
5091 __cil_tmp178 = (unsigned long )(sg_in) + __cil_tmp177;
5092#line 640
5093 __cil_tmp179 = (struct scatterlist *)__cil_tmp178;
5094#line 640
5095 __cil_tmp180 = isize - 1;
5096#line 640
5097 __cil_tmp181 = (unsigned int )__cil_tmp180;
5098#line 640
5099 tmp___0 = crypto_blkcipher_decrypt(& desc, __cil_tmp176, __cil_tmp179, __cil_tmp181);
5100 }
5101#line 640
5102 if (tmp___0) {
5103 {
5104#line 641
5105 printk("<7>crypto_cypher_decrypt failed\n");
5106 }
5107#line 642
5108 return (-1);
5109 } else {
5110
5111 }
5112#line 645
5113 __cil_tmp182 = (unsigned long )state;
5114#line 645
5115 __cil_tmp183 = __cil_tmp182 + 88;
5116#line 645
5117 __cil_tmp184 = (__u32 )osize;
5118#line 645
5119 __cil_tmp185 = (unsigned long )state;
5120#line 645
5121 __cil_tmp186 = __cil_tmp185 + 88;
5122#line 645
5123 __cil_tmp187 = *((__u32 *)__cil_tmp186);
5124#line 645
5125 *((__u32 *)__cil_tmp183) = __cil_tmp187 + __cil_tmp184;
5126#line 646
5127 __cil_tmp188 = 88 + 4;
5128#line 646
5129 __cil_tmp189 = (unsigned long )state;
5130#line 646
5131 __cil_tmp190 = __cil_tmp189 + __cil_tmp188;
5132#line 646
5133 __cil_tmp191 = 88 + 4;
5134#line 646
5135 __cil_tmp192 = (unsigned long )state;
5136#line 646
5137 __cil_tmp193 = __cil_tmp192 + __cil_tmp191;
5138#line 646
5139 __cil_tmp194 = *((__u32 *)__cil_tmp193);
5140#line 646
5141 *((__u32 *)__cil_tmp190) = __cil_tmp194 + 1U;
5142#line 647
5143 __cil_tmp195 = 88 + 8;
5144#line 647
5145 __cil_tmp196 = (unsigned long )state;
5146#line 647
5147 __cil_tmp197 = __cil_tmp196 + __cil_tmp195;
5148#line 647
5149 __cil_tmp198 = (__u32 )isize;
5150#line 647
5151 __cil_tmp199 = 88 + 8;
5152#line 647
5153 __cil_tmp200 = (unsigned long )state;
5154#line 647
5155 __cil_tmp201 = __cil_tmp200 + __cil_tmp199;
5156#line 647
5157 __cil_tmp202 = *((__u32 *)__cil_tmp201);
5158#line 647
5159 *((__u32 *)__cil_tmp197) = __cil_tmp202 + __cil_tmp198;
5160#line 648
5161 __cil_tmp203 = 88 + 12;
5162#line 648
5163 __cil_tmp204 = (unsigned long )state;
5164#line 648
5165 __cil_tmp205 = __cil_tmp204 + __cil_tmp203;
5166#line 648
5167 __cil_tmp206 = 88 + 12;
5168#line 648
5169 __cil_tmp207 = (unsigned long )state;
5170#line 648
5171 __cil_tmp208 = __cil_tmp207 + __cil_tmp206;
5172#line 648
5173 __cil_tmp209 = *((__u32 *)__cil_tmp208);
5174#line 648
5175 *((__u32 *)__cil_tmp205) = __cil_tmp209 + 1U;
5176#line 651
5177 __cil_tmp210 = (unsigned long )state;
5178#line 651
5179 __cil_tmp211 = __cil_tmp210 + 76;
5180#line 651
5181 __cil_tmp212 = (unsigned long )state;
5182#line 651
5183 __cil_tmp213 = __cil_tmp212 + 76;
5184#line 651
5185 __cil_tmp214 = *((int *)__cil_tmp213);
5186#line 651
5187 *((int *)__cil_tmp211) = __cil_tmp214 >> 1;
5188#line 653
5189 return (osize);
5190}
5191}
5192#line 662 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5193static void mppe_incomp(void *arg , unsigned char *ibuf , int icnt )
5194{ struct ppp_mppe_state *state ;
5195 unsigned long __cil_tmp5 ;
5196 unsigned long __cil_tmp6 ;
5197 __u8 *__cil_tmp7 ;
5198 __u8 __cil_tmp8 ;
5199 int __cil_tmp9 ;
5200 __u8 *__cil_tmp10 ;
5201 __u8 __cil_tmp11 ;
5202 int __cil_tmp12 ;
5203 int __cil_tmp13 ;
5204 int __cil_tmp14 ;
5205 __u8 *__cil_tmp15 ;
5206 __u8 __cil_tmp16 ;
5207 int __cil_tmp17 ;
5208 __u8 *__cil_tmp18 ;
5209 __u8 __cil_tmp19 ;
5210 int __cil_tmp20 ;
5211 int __cil_tmp21 ;
5212 int __cil_tmp22 ;
5213 unsigned long __cil_tmp23 ;
5214 unsigned long __cil_tmp24 ;
5215 int __cil_tmp25 ;
5216 __u8 *__cil_tmp26 ;
5217 __u8 __cil_tmp27 ;
5218 int __cil_tmp28 ;
5219 __u8 *__cil_tmp29 ;
5220 __u8 __cil_tmp30 ;
5221 int __cil_tmp31 ;
5222 int __cil_tmp32 ;
5223 int __cil_tmp33 ;
5224 unsigned long __cil_tmp34 ;
5225 unsigned long __cil_tmp35 ;
5226 unsigned long __cil_tmp36 ;
5227 __u32 __cil_tmp37 ;
5228 unsigned long __cil_tmp38 ;
5229 unsigned long __cil_tmp39 ;
5230 unsigned long __cil_tmp40 ;
5231 __u32 __cil_tmp41 ;
5232 unsigned long __cil_tmp42 ;
5233 unsigned long __cil_tmp43 ;
5234 unsigned long __cil_tmp44 ;
5235 unsigned long __cil_tmp45 ;
5236 unsigned long __cil_tmp46 ;
5237 unsigned long __cil_tmp47 ;
5238 __u32 __cil_tmp48 ;
5239 unsigned long __cil_tmp49 ;
5240 unsigned long __cil_tmp50 ;
5241 __u32 __cil_tmp51 ;
5242 unsigned long __cil_tmp52 ;
5243 unsigned long __cil_tmp53 ;
5244 __u32 __cil_tmp54 ;
5245 unsigned long __cil_tmp55 ;
5246 unsigned long __cil_tmp56 ;
5247 unsigned long __cil_tmp57 ;
5248 unsigned long __cil_tmp58 ;
5249 unsigned long __cil_tmp59 ;
5250 unsigned long __cil_tmp60 ;
5251 __u32 __cil_tmp61 ;
5252
5253 {
5254#line 664
5255 state = (struct ppp_mppe_state *)arg;
5256 {
5257#line 666
5258 __cil_tmp5 = (unsigned long )state;
5259#line 666
5260 __cil_tmp6 = __cil_tmp5 + 84;
5261#line 666
5262 if (*((int *)__cil_tmp6)) {
5263 {
5264#line 666
5265 __cil_tmp7 = ibuf + 3;
5266#line 666
5267 __cil_tmp8 = *__cil_tmp7;
5268#line 666
5269 __cil_tmp9 = (int )__cil_tmp8;
5270#line 666
5271 __cil_tmp10 = ibuf + 2;
5272#line 666
5273 __cil_tmp11 = *__cil_tmp10;
5274#line 666
5275 __cil_tmp12 = (int )__cil_tmp11;
5276#line 666
5277 __cil_tmp13 = __cil_tmp12 << 8;
5278#line 666
5279 __cil_tmp14 = __cil_tmp13 + __cil_tmp9;
5280#line 666
5281 if (__cil_tmp14 >= 33) {
5282 {
5283#line 666
5284 __cil_tmp15 = ibuf + 3;
5285#line 666
5286 __cil_tmp16 = *__cil_tmp15;
5287#line 666
5288 __cil_tmp17 = (int )__cil_tmp16;
5289#line 666
5290 __cil_tmp18 = ibuf + 2;
5291#line 666
5292 __cil_tmp19 = *__cil_tmp18;
5293#line 666
5294 __cil_tmp20 = (int )__cil_tmp19;
5295#line 666
5296 __cil_tmp21 = __cil_tmp20 << 8;
5297#line 666
5298 __cil_tmp22 = __cil_tmp21 + __cil_tmp17;
5299#line 666
5300 if (__cil_tmp22 <= 250) {
5301 {
5302#line 668
5303 __cil_tmp23 = (unsigned long )state;
5304#line 668
5305 __cil_tmp24 = __cil_tmp23 + 80;
5306#line 668
5307 __cil_tmp25 = *((int *)__cil_tmp24);
5308#line 668
5309 __cil_tmp26 = ibuf + 3;
5310#line 668
5311 __cil_tmp27 = *__cil_tmp26;
5312#line 668
5313 __cil_tmp28 = (int )__cil_tmp27;
5314#line 668
5315 __cil_tmp29 = ibuf + 2;
5316#line 668
5317 __cil_tmp30 = *__cil_tmp29;
5318#line 668
5319 __cil_tmp31 = (int )__cil_tmp30;
5320#line 668
5321 __cil_tmp32 = __cil_tmp31 << 8;
5322#line 668
5323 __cil_tmp33 = __cil_tmp32 + __cil_tmp28;
5324#line 668
5325 printk("<7>mppe_incomp[%d]: incompressible (unencrypted) data! (proto %04x)\n",
5326 __cil_tmp25, __cil_tmp33);
5327 }
5328 } else {
5329
5330 }
5331 }
5332 } else {
5333
5334 }
5335 }
5336 } else {
5337
5338 }
5339 }
5340#line 672
5341 __cil_tmp34 = 88 + 16;
5342#line 672
5343 __cil_tmp35 = (unsigned long )state;
5344#line 672
5345 __cil_tmp36 = __cil_tmp35 + __cil_tmp34;
5346#line 672
5347 __cil_tmp37 = (__u32 )icnt;
5348#line 672
5349 __cil_tmp38 = 88 + 16;
5350#line 672
5351 __cil_tmp39 = (unsigned long )state;
5352#line 672
5353 __cil_tmp40 = __cil_tmp39 + __cil_tmp38;
5354#line 672
5355 __cil_tmp41 = *((__u32 *)__cil_tmp40);
5356#line 672
5357 *((__u32 *)__cil_tmp36) = __cil_tmp41 + __cil_tmp37;
5358#line 673
5359 __cil_tmp42 = 88 + 20;
5360#line 673
5361 __cil_tmp43 = (unsigned long )state;
5362#line 673
5363 __cil_tmp44 = __cil_tmp43 + __cil_tmp42;
5364#line 673
5365 __cil_tmp45 = 88 + 20;
5366#line 673
5367 __cil_tmp46 = (unsigned long )state;
5368#line 673
5369 __cil_tmp47 = __cil_tmp46 + __cil_tmp45;
5370#line 673
5371 __cil_tmp48 = *((__u32 *)__cil_tmp47);
5372#line 673
5373 *((__u32 *)__cil_tmp44) = __cil_tmp48 + 1U;
5374#line 674
5375 __cil_tmp49 = (unsigned long )state;
5376#line 674
5377 __cil_tmp50 = __cil_tmp49 + 88;
5378#line 674
5379 __cil_tmp51 = (__u32 )icnt;
5380#line 674
5381 __cil_tmp52 = (unsigned long )state;
5382#line 674
5383 __cil_tmp53 = __cil_tmp52 + 88;
5384#line 674
5385 __cil_tmp54 = *((__u32 *)__cil_tmp53);
5386#line 674
5387 *((__u32 *)__cil_tmp50) = __cil_tmp54 + __cil_tmp51;
5388#line 675
5389 __cil_tmp55 = 88 + 4;
5390#line 675
5391 __cil_tmp56 = (unsigned long )state;
5392#line 675
5393 __cil_tmp57 = __cil_tmp56 + __cil_tmp55;
5394#line 675
5395 __cil_tmp58 = 88 + 4;
5396#line 675
5397 __cil_tmp59 = (unsigned long )state;
5398#line 675
5399 __cil_tmp60 = __cil_tmp59 + __cil_tmp58;
5400#line 675
5401 __cil_tmp61 = *((__u32 *)__cil_tmp60);
5402#line 675
5403 *((__u32 *)__cil_tmp57) = __cil_tmp61 + 1U;
5404#line 676
5405 return;
5406}
5407}
5408#line 685 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5409static struct compressor ppp_mppe =
5410#line 685
5411 {18, & mppe_alloc, & mppe_free, & mppe_comp_init, & mppe_comp_reset, & mppe_compress,
5412 & mppe_comp_stats, & mppe_alloc, & mppe_free, & mppe_decomp_init, & mppe_decomp_reset,
5413 & mppe_decompress, & mppe_incomp, & mppe_comp_stats, & __this_module, 4U};
5414#line 712
5415static int ppp_mppe_init(void) __attribute__((__section__(".init.text"), __no_instrument_function__)) ;
5416#line 712 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5417static int ppp_mppe_init(void)
5418{ int answer ;
5419 int tmp ;
5420 int tmp___0 ;
5421 void *tmp___1 ;
5422 u32 __cil_tmp5 ;
5423 u32 __cil_tmp6 ;
5424 u32 __cil_tmp7 ;
5425 u32 __cil_tmp8 ;
5426 void const *__cil_tmp9 ;
5427
5428 {
5429 {
5430#line 715
5431 __cil_tmp5 = (u32 )0;
5432#line 715
5433 __cil_tmp6 = (u32 )128;
5434#line 715
5435 tmp = crypto_has_blkcipher("ecb(arc4)", __cil_tmp5, __cil_tmp6);
5436 }
5437#line 715
5438 if (tmp) {
5439 {
5440#line 715
5441 __cil_tmp7 = (u32 )0;
5442#line 715
5443 __cil_tmp8 = (u32 )128;
5444#line 715
5445 tmp___0 = crypto_has_hash("sha1", __cil_tmp7, __cil_tmp8);
5446 }
5447#line 715
5448 if (tmp___0) {
5449
5450 } else {
5451#line 717
5452 return (-19);
5453 }
5454 } else {
5455#line 717
5456 return (-19);
5457 }
5458 {
5459#line 719
5460 tmp___1 = kmalloc(80UL, 208U);
5461#line 719
5462 sha_pad = (struct sha_pad *)tmp___1;
5463 }
5464#line 720
5465 if (! sha_pad) {
5466#line 721
5467 return (-12);
5468 } else {
5469
5470 }
5471 {
5472#line 722
5473 sha_pad_init(sha_pad);
5474#line 724
5475 answer = ppp_register_compressor(& ppp_mppe);
5476 }
5477#line 726
5478 if (answer == 0) {
5479 {
5480#line 727
5481 printk("<6>PPP MPPE Compression module registered\n");
5482 }
5483 } else {
5484 {
5485#line 729
5486 __cil_tmp9 = (void const *)sha_pad;
5487#line 729
5488 kfree(__cil_tmp9);
5489 }
5490 }
5491#line 731
5492 return (answer);
5493}
5494}
5495#line 734
5496static void ppp_mppe_cleanup(void) __attribute__((__section__(".exit.text"), __no_instrument_function__)) ;
5497#line 734 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5498static void ppp_mppe_cleanup(void)
5499{ void const *__cil_tmp1 ;
5500
5501 {
5502 {
5503#line 736
5504 ppp_unregister_compressor(& ppp_mppe);
5505#line 737
5506 __cil_tmp1 = (void const *)sha_pad;
5507#line 737
5508 kfree(__cil_tmp1);
5509 }
5510#line 738
5511 return;
5512}
5513}
5514#line 740 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5515int init_module(void)
5516{ int tmp ;
5517
5518 {
5519 {
5520#line 740
5521 tmp = ppp_mppe_init();
5522 }
5523#line 740
5524 return (tmp);
5525}
5526}
5527#line 741 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5528void cleanup_module(void)
5529{
5530
5531 {
5532 {
5533#line 741
5534 ppp_mppe_cleanup();
5535 }
5536#line 741
5537 return;
5538}
5539}
5540#line 759
5541void ldv_check_final_state(void) ;
5542#line 765
5543extern void ldv_initialize(void) ;
5544#line 768
5545extern int __VERIFIER_nondet_int(void) ;
5546#line 771 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5547int LDV_IN_INTERRUPT ;
5548#line 774 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5549void main(void)
5550{ unsigned char *var_mppe_alloc_4_p0 ;
5551 int var_mppe_alloc_4_p1 ;
5552 void *var_mppe_free_5_p0 ;
5553 void *var_mppe_comp_init_7_p0 ;
5554 unsigned char *var_mppe_comp_init_7_p1 ;
5555 int var_mppe_comp_init_7_p2 ;
5556 int var_mppe_comp_init_7_p3 ;
5557 int var_mppe_comp_init_7_p4 ;
5558 int var_mppe_comp_init_7_p5 ;
5559 void *var_mppe_comp_reset_8_p0 ;
5560 void *var_mppe_compress_9_p0 ;
5561 unsigned char *var_mppe_compress_9_p1 ;
5562 unsigned char *var_mppe_compress_9_p2 ;
5563 int var_mppe_compress_9_p3 ;
5564 int var_mppe_compress_9_p4 ;
5565 void *var_mppe_comp_stats_10_p0 ;
5566 struct compstat *var_group1 ;
5567 void *var_mppe_decomp_init_11_p0 ;
5568 unsigned char *var_mppe_decomp_init_11_p1 ;
5569 int var_mppe_decomp_init_11_p2 ;
5570 int var_mppe_decomp_init_11_p3 ;
5571 int var_mppe_decomp_init_11_p4 ;
5572 int var_mppe_decomp_init_11_p5 ;
5573 int var_mppe_decomp_init_11_p6 ;
5574 void *var_mppe_decomp_reset_12_p0 ;
5575 void *var_mppe_decompress_13_p0 ;
5576 unsigned char *var_mppe_decompress_13_p1 ;
5577 int var_mppe_decompress_13_p2 ;
5578 unsigned char *var_mppe_decompress_13_p3 ;
5579 int var_mppe_decompress_13_p4 ;
5580 void *var_mppe_incomp_14_p0 ;
5581 unsigned char *var_mppe_incomp_14_p1 ;
5582 int var_mppe_incomp_14_p2 ;
5583 int tmp ;
5584 int tmp___0 ;
5585 int tmp___1 ;
5586
5587 {
5588 {
5589#line 1004
5590 LDV_IN_INTERRUPT = 1;
5591#line 1013
5592 ldv_initialize();
5593#line 1032
5594 tmp = ppp_mppe_init();
5595 }
5596#line 1032
5597 if (tmp) {
5598#line 1033
5599 goto ldv_final;
5600 } else {
5601
5602 }
5603 {
5604#line 1037
5605 while (1) {
5606 while_continue: ;
5607 {
5608#line 1037
5609 tmp___1 = __VERIFIER_nondet_int();
5610 }
5611#line 1037
5612 if (tmp___1) {
5613
5614 } else {
5615#line 1037
5616 goto while_break;
5617 }
5618 {
5619#line 1040
5620 tmp___0 = __VERIFIER_nondet_int();
5621 }
5622#line 1042
5623 if (tmp___0 == 0) {
5624#line 1042
5625 goto case_0;
5626 } else
5627#line 1071
5628 if (tmp___0 == 1) {
5629#line 1071
5630 goto case_1;
5631 } else
5632#line 1100
5633 if (tmp___0 == 2) {
5634#line 1100
5635 goto case_2;
5636 } else
5637#line 1129
5638 if (tmp___0 == 3) {
5639#line 1129
5640 goto case_3;
5641 } else
5642#line 1158
5643 if (tmp___0 == 4) {
5644#line 1158
5645 goto case_4;
5646 } else
5647#line 1187
5648 if (tmp___0 == 5) {
5649#line 1187
5650 goto case_5;
5651 } else
5652#line 1216
5653 if (tmp___0 == 6) {
5654#line 1216
5655 goto case_6;
5656 } else
5657#line 1245
5658 if (tmp___0 == 7) {
5659#line 1245
5660 goto case_7;
5661 } else
5662#line 1274
5663 if (tmp___0 == 8) {
5664#line 1274
5665 goto case_8;
5666 } else
5667#line 1303
5668 if (tmp___0 == 9) {
5669#line 1303
5670 goto case_9;
5671 } else {
5672 {
5673#line 1332
5674 goto switch_default;
5675#line 1040
5676 if (0) {
5677 case_0:
5678 {
5679#line 1063
5680 mppe_alloc(var_mppe_alloc_4_p0, var_mppe_alloc_4_p1);
5681 }
5682#line 1070
5683 goto switch_break;
5684 case_1:
5685 {
5686#line 1092
5687 mppe_free(var_mppe_free_5_p0);
5688 }
5689#line 1099
5690 goto switch_break;
5691 case_2:
5692 {
5693#line 1121
5694 mppe_comp_init(var_mppe_comp_init_7_p0, var_mppe_comp_init_7_p1, var_mppe_comp_init_7_p2,
5695 var_mppe_comp_init_7_p3, var_mppe_comp_init_7_p4, var_mppe_comp_init_7_p5);
5696 }
5697#line 1128
5698 goto switch_break;
5699 case_3:
5700 {
5701#line 1150
5702 mppe_comp_reset(var_mppe_comp_reset_8_p0);
5703 }
5704#line 1157
5705 goto switch_break;
5706 case_4:
5707 {
5708#line 1179
5709 mppe_compress(var_mppe_compress_9_p0, var_mppe_compress_9_p1, var_mppe_compress_9_p2,
5710 var_mppe_compress_9_p3, var_mppe_compress_9_p4);
5711 }
5712#line 1186
5713 goto switch_break;
5714 case_5:
5715 {
5716#line 1208
5717 mppe_comp_stats(var_mppe_comp_stats_10_p0, var_group1);
5718 }
5719#line 1215
5720 goto switch_break;
5721 case_6:
5722 {
5723#line 1237
5724 mppe_decomp_init(var_mppe_decomp_init_11_p0, var_mppe_decomp_init_11_p1, var_mppe_decomp_init_11_p2,
5725 var_mppe_decomp_init_11_p3, var_mppe_decomp_init_11_p4, var_mppe_decomp_init_11_p5,
5726 var_mppe_decomp_init_11_p6);
5727 }
5728#line 1244
5729 goto switch_break;
5730 case_7:
5731 {
5732#line 1266
5733 mppe_decomp_reset(var_mppe_decomp_reset_12_p0);
5734 }
5735#line 1273
5736 goto switch_break;
5737 case_8:
5738 {
5739#line 1295
5740 mppe_decompress(var_mppe_decompress_13_p0, var_mppe_decompress_13_p1, var_mppe_decompress_13_p2,
5741 var_mppe_decompress_13_p3, var_mppe_decompress_13_p4);
5742 }
5743#line 1302
5744 goto switch_break;
5745 case_9:
5746 {
5747#line 1324
5748 mppe_incomp(var_mppe_incomp_14_p0, var_mppe_incomp_14_p1, var_mppe_incomp_14_p2);
5749 }
5750#line 1331
5751 goto switch_break;
5752 switch_default:
5753#line 1332
5754 goto switch_break;
5755 } else {
5756 switch_break: ;
5757 }
5758 }
5759 }
5760 }
5761 while_break: ;
5762 }
5763 {
5764#line 1357
5765 ppp_mppe_cleanup();
5766 }
5767 ldv_final:
5768 {
5769#line 1360
5770 ldv_check_final_state();
5771 }
5772#line 1363
5773 return;
5774}
5775}
5776#line 5 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast-assert.h"
5777void ldv_blast_assert(void)
5778{
5779
5780 {
5781 ERROR:
5782#line 6
5783 goto ERROR;
5784}
5785}
5786#line 6 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast.h"
5787extern int __VERIFIER_nondet_int(void) ;
5788#line 19 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5789int ldv_mutex = 1;
5790#line 22 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5791int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock )
5792{ int nondetermined ;
5793
5794 {
5795#line 29
5796 if (ldv_mutex == 1) {
5797
5798 } else {
5799 {
5800#line 29
5801 ldv_blast_assert();
5802 }
5803 }
5804 {
5805#line 32
5806 nondetermined = __VERIFIER_nondet_int();
5807 }
5808#line 35
5809 if (nondetermined) {
5810#line 38
5811 ldv_mutex = 2;
5812#line 40
5813 return (0);
5814 } else {
5815#line 45
5816 return (-4);
5817 }
5818}
5819}
5820#line 50 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5821int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock )
5822{ int nondetermined ;
5823
5824 {
5825#line 57
5826 if (ldv_mutex == 1) {
5827
5828 } else {
5829 {
5830#line 57
5831 ldv_blast_assert();
5832 }
5833 }
5834 {
5835#line 60
5836 nondetermined = __VERIFIER_nondet_int();
5837 }
5838#line 63
5839 if (nondetermined) {
5840#line 66
5841 ldv_mutex = 2;
5842#line 68
5843 return (0);
5844 } else {
5845#line 73
5846 return (-4);
5847 }
5848}
5849}
5850#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5851int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock )
5852{ int atomic_value_after_dec ;
5853
5854 {
5855#line 83
5856 if (ldv_mutex == 1) {
5857
5858 } else {
5859 {
5860#line 83
5861 ldv_blast_assert();
5862 }
5863 }
5864 {
5865#line 86
5866 atomic_value_after_dec = __VERIFIER_nondet_int();
5867 }
5868#line 89
5869 if (atomic_value_after_dec == 0) {
5870#line 92
5871 ldv_mutex = 2;
5872#line 94
5873 return (1);
5874 } else {
5875
5876 }
5877#line 98
5878 return (0);
5879}
5880}
5881#line 103 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5882void mutex_lock(struct mutex *lock )
5883{
5884
5885 {
5886#line 108
5887 if (ldv_mutex == 1) {
5888
5889 } else {
5890 {
5891#line 108
5892 ldv_blast_assert();
5893 }
5894 }
5895#line 110
5896 ldv_mutex = 2;
5897#line 111
5898 return;
5899}
5900}
5901#line 114 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5902int mutex_trylock(struct mutex *lock )
5903{ int nondetermined ;
5904
5905 {
5906#line 121
5907 if (ldv_mutex == 1) {
5908
5909 } else {
5910 {
5911#line 121
5912 ldv_blast_assert();
5913 }
5914 }
5915 {
5916#line 124
5917 nondetermined = __VERIFIER_nondet_int();
5918 }
5919#line 127
5920 if (nondetermined) {
5921#line 130
5922 ldv_mutex = 2;
5923#line 132
5924 return (1);
5925 } else {
5926#line 137
5927 return (0);
5928 }
5929}
5930}
5931#line 142 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5932void mutex_unlock(struct mutex *lock )
5933{
5934
5935 {
5936#line 147
5937 if (ldv_mutex == 2) {
5938
5939 } else {
5940 {
5941#line 147
5942 ldv_blast_assert();
5943 }
5944 }
5945#line 149
5946 ldv_mutex = 1;
5947#line 150
5948 return;
5949}
5950}
5951#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5952void ldv_check_final_state(void)
5953{
5954
5955 {
5956#line 156
5957 if (ldv_mutex == 1) {
5958
5959 } else {
5960 {
5961#line 156
5962 ldv_blast_assert();
5963 }
5964 }
5965#line 157
5966 return;
5967}
5968}
5969#line 1372 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/9572/dscv_tempdir/dscv/ri/32_1/drivers/net/ppp/ppp_mppe.c.common.c"
5970long s__builtin_expect(long val , long res )
5971{
5972
5973 {
5974#line 1373
5975 return (val);
5976}
5977}