Merge lp:~stefan.goetz-deactivatedaccount/hipl/style-check-hook-review into lp:hipl

[Stefan Götz]

1) a pre-commit hook for bazaar that aborts a commit if the code to be committed does not adhere to the HIPL style guide lines.

2) all HIPL code has been automatically beautified so that the pre-commit hook only complains about newly introduced style violations.

[Stefan Götz (stefan.goetz-deactivatedaccount)]

As promised last week, this branch will be merged very soon now. Any last minute comments are welcome, of course.

review: Approve

=== added file '.uncrustify-0.57.cfg'
--- .uncrustify-0.57.cfg	1970-01-01 00:00:00 +0000
+++ .uncrustify-0.57.cfg	2011-01-11 14:04:40 +0000
@@ -0,0 +1,1376 @@
+# Uncrustify 0.57
+
+#
+# General options
+#
+
+# The type of line endings
+newlines                                 = lf       # auto/lf/crlf/cr
+
+# The original size of tabs in the input
+input_tab_size                           = 8        # number
+
+# The size of tabs in the output (only used if align_with_tabs=true)
+output_tab_size                          = 4        # number
+
+# The ASCII value of the string escape char, usually 92 (\) or 94 (^). (Pawn)
+string_escape_char                       = 92       # number
+
+# Alternate string escape char for Pawn. Only works right before the quote char.
+string_escape_char2                      = 0        # number
+
+#
+# Indenting
+#
+
+# The number of columns to indent per level.
+# Usually 2, 3, 4, or 8.
+indent_columns                           = 4        # number
+
+# The continuation indent. If non-zero, this overrides the indent of '(' and '=' continuation indents.
+# For FreeBSD, this is set to 4.
+indent_continue                          = 0        # number
+
+# How to use tabs when indenting code
+# 0=spaces only
+# 1=indent with tabs to brace level, align with spaces
+# 2=indent and align with tabs, using spaces when not on a tabstop
+indent_with_tabs                         = 0        # number
+
+# Comments that are not a brace level are indented with tabs on a tabstop.
+# Requires indent_with_tabs=2. If false, will use spaces.
+indent_cmt_with_tabs                     = false    # false/true
+
+# Whether to indent strings broken by '\' so that they line up
+indent_align_string                      = true     # false/true
+
+# The number of spaces to indent multi-line XML strings.
+# Requires indent_align_string=True
+indent_xml_string                        = 0        # number
+
+# Spaces to indent '{' from level
+indent_brace                             = 0        # number
+
+# Whether braces are indented to the body level
+indent_braces                            = false    # false/true
+
+# Disabled indenting function braces if indent_braces is true
+indent_braces_no_func                    = false    # false/true
+
+# Disabled indenting class braces if indent_braces is true
+indent_braces_no_class                   = false    # false/true
+
+# Disabled indenting struct braces if indent_braces is true
+indent_braces_no_struct                  = false    # false/true
+
+# Indent based on the size of the brace parent, i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc.
+indent_brace_parent                      = false    # false/true
+
+# Whether the 'namespace' body is indented
+indent_namespace                         = false    # false/true
+
+# The number of spaces to indent a namespace block
+indent_namespace_level                   = 0        # number
+
+# If the body of the namespace is longer than this number, it won't be indented.
+# Requires indent_namespace=true. Default=0 (no limit)
+indent_namespace_limit                   = 0        # number
+
+# Whether the 'extern "C"' body is indented
+indent_extern                            = false    # false/true
+
+# Whether the 'class' body is indented
+indent_class                             = false    # false/true
+
+# Whether to indent the stuff after a leading class colon
+indent_class_colon                       = false    # false/true
+
+# False=treat 'else\nif' as 'else if' for indenting purposes
+# True=indent the 'if' one level
+indent_else_if                           = false    # false/true
+
+# Amount to indent variable declarations after a open brace. neg=relative, pos=absolute
+indent_var_def_blk                       = 0        # number
+
+# Indent continued variable declarations instead of aligning.
+indent_var_def_cont                      = false    # false/true
+
+# True:  indent continued function call parameters one indent level
+# False: align parameters under the open paren
+indent_func_call_param                   = false    # false/true
+
+# Same as indent_func_call_param, but for function defs
+indent_func_def_param                    = false    # false/true
+
+# Same as indent_func_call_param, but for function protos
+indent_func_proto_param                  = false    # false/true
+
+# Same as indent_func_call_param, but for class declarations
+indent_func_class_param                  = false    # false/true
+
+# Same as indent_func_call_param, but for class variable constructors
+indent_func_ctor_var_param               = false    # false/true
+
+# Same as indent_func_call_param, but for templates
+indent_template_param                    = false    # false/true
+
+# Double the indent for indent_func_xxx_param options
+indent_func_param_double                 = false    # false/true
+
+# Indentation column for standalone 'const' function decl/proto qualifier
+indent_func_const                        = 0        # number
+
+# Indentation column for standalone 'throw' function decl/proto qualifier
+indent_func_throw                        = 0        # number
+
+# The number of spaces to indent a continued '->' or '.'
+# Usually set to 0, 1, or indent_columns.
+indent_member                            = 0        # number
+
+# Spaces to indent single line ('//') comments on lines before code
+indent_sing_line_comments                = 0        # number
+
+# If set, will indent trailing single line ('//') comments relative
+# to the code instead of trying to keep the same absolute column
+indent_relative_single_line_comments     = false    # false/true
+
+# Spaces to indent 'case' from 'switch'
+# Usually 0 or indent_columns.
+indent_switch_case                       = 0        # number
+
+# Spaces to shift the 'case' line, without affecting any other lines
+# Usually 0.
+indent_case_shift                        = 0        # number
+
+# Spaces to indent '{' from 'case'.
+# By default, the brace will appear under the 'c' in case.
+# Usually set to 0 or indent_columns.
+indent_case_brace                        = 0        # number
+
+# Whether to indent comments found in first column
+indent_col1_comment                      = false    # false/true
+
+# How to indent goto labels
+#  >0 : absolute column where 1 is the leftmost column
+#  <=0 : subtract from brace indent
+indent_label                             = 1        # number
+
+# Same as indent_label, but for access specifiers that are followed by a colon
+indent_access_spec                       = 1        # number
+
+# Indent the code after an access specifier by one level.
+# If set, this option forces 'indent_access_spec=0'
+indent_access_spec_body                  = false    # false/true
+
+# If an open paren is followed by a newline, indent the next line so that it lines up after the open paren (not recommended)
+indent_paren_nl                          = false    # false/true
+
+# Controls the indent of a close paren after a newline.
+# 0: Indent to body level
+# 1: Align under the open paren
+# 2: Indent to the brace level
+indent_paren_close                       = 0        # number
+
+# Controls the indent of a comma when inside a paren.If TRUE, aligns under the open paren
+indent_comma_paren                       = false    # false/true
+
+# Controls the indent of a BOOL operator when inside a paren.If TRUE, aligns under the open paren
+indent_bool_paren                        = false    # false/true
+
+# If 'indent_bool_paren' is true, controls the indent of the first expression. If TRUE, aligns the first expression to the following ones
+indent_first_bool_expr                   = false    # false/true
+
+# If an open square is followed by a newline, indent the next line so that it lines up after the open square (not recommended)
+indent_square_nl                         = false    # false/true
+
+# Don't change the relative indent of ESQL/C 'EXEC SQL' bodies
+indent_preserve_sql                      = false    # false/true
+
+# Align continued statements at the '='. Default=True
+# If FALSE or the '=' is followed by a newline, the next line is indent one tab.
+indent_align_assign                      = true     # false/true
+
+#
+# Spacing options
+#
+
+# Add or remove space around arithmetic operator '+', '-', '/', '*', etc
+sp_arith                                 = add      # ignore/add/remove/force
+
+# Add or remove space around assignment operator '=', '+=', etc
+sp_assign                                = add      # ignore/add/remove/force
+
+# Add or remove space around assignment operator '=' in a prototype
+sp_assign_default                        = add   # ignore/add/remove/force
+
+# Add or remove space before assignment operator '=', '+=', etc. Overrides sp_assign.
+sp_before_assign                         = ignore   # ignore/add/remove/force
+
+# Add or remove space after assignment operator '=', '+=', etc. Overrides sp_assign.
+sp_after_assign                          = ignore   # ignore/add/remove/force
+
+# Add or remove space around assignment '=' in enum
+sp_enum_assign                           = add      # ignore/add/remove/force
+
+# Add or remove space before assignment '=' in enum. Overrides sp_enum_assign.
+sp_enum_before_assign                    = ignore   # ignore/add/remove/force
+
+# Add or remove space after assignment '=' in enum. Overrides sp_enum_assign.
+sp_enum_after_assign                     = ignore   # ignore/add/remove/force
+
+# Add or remove space around preprocessor '##' concatenation operator. Default=Add
+sp_pp_concat                             = add      # ignore/add/remove/force
+
+# Add or remove space after preprocessor '#' stringify operator. Also affects the '#@' charizing operator. Default=Add
+sp_pp_stringify                          = add      # ignore/add/remove/force
+
+# Add or remove space around boolean operators '&&' and '||'
+sp_bool                                  = add      # ignore/add/remove/force
+
+# Add or remove space around compare operator '<', '>', '==', etc
+sp_compare                               = add      # ignore/add/remove/force
+
+# Add or remove space inside '(' and ')'
+sp_inside_paren                          = remove   # ignore/add/remove/force
+
+# Add or remove space between nested parens
+sp_paren_paren                           = remove   # ignore/add/remove/force
+
+# Whether to balance spaces inside nested parens
+sp_balance_nested_parens                 = false    # false/true
+
+# Add or remove space between ')' and '{'
+sp_paren_brace                           = force    # ignore/add/remove/force
+
+# Add or remove space before pointer star '*'
+sp_before_ptr_star                       = add      # ignore/add/remove/force
+
+# Add or remove space before pointer star '*' that isn't followed by a variable name
+# If set to 'ignore', sp_before_ptr_star is used instead.
+sp_before_unnamed_ptr_star               = ignore   # ignore/add/remove/force
+
+# Add or remove space between pointer stars '*'
+sp_between_ptr_star                      = remove   # ignore/add/remove/force
+
+# Add or remove space after pointer star '*', if followed by a word.
+sp_after_ptr_star                        = remove   # ignore/add/remove/force
+
+# Add or remove space after a pointer star '*', if followed by a func proto/def.
+sp_after_ptr_star_func                   = remove   # ignore/add/remove/force
+
+# Add or remove space before a pointer star '*', if followed by a func proto/def.
+sp_before_ptr_star_func                  = ignore   # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&'
+sp_before_byref                          = force    # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&' that isn't followed by a variable name
+# If set to 'ignore', sp_before_byref is used instead.
+sp_before_unnamed_byref                  = add      # ignore/add/remove/force
+
+# Add or remove space after reference sign '&', if followed by a word.
+sp_after_byref                           = ignore   # ignore/add/remove/force
+
+# Add or remove space after a reference sign '&', if followed by a func proto/def.
+sp_after_byref_func                      = ignore   # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&', if followed by a func proto/def.
+sp_before_byref_func                     = ignore   # ignore/add/remove/force
+
+# Add or remove space between type and word. Default=Force
+sp_after_type                            = ignore    # ignore/add/remove/force
+
+# Add or remove space in 'template <' vs 'template<'.
+# If set to ignore, sp_before_angle is used.
+sp_template_angle                        = ignore   # ignore/add/remove/force
+
+# Add or remove space before '<>'
+sp_before_angle                          = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '<' and '>'
+sp_inside_angle                          = ignore   # ignore/add/remove/force
+
+# Add or remove space after '<>'
+sp_after_angle                           = ignore   # ignore/add/remove/force
+
+# Add or remove space between '<>' and '(' as found in 'new List<byte>();'
+sp_angle_paren                           = ignore   # ignore/add/remove/force
+
+# Add or remove space between '<>' and a word as in 'List<byte> m;'
+sp_angle_word                            = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and '>' in '>>' (template stuff C++/C# only). Default=Add
+sp_angle_shift                           = add      # ignore/add/remove/force
+
+# Add or remove space before '(' of 'if', 'for', 'switch', and 'while'
+sp_before_sparen                         = add      # ignore/add/remove/force
+
+# Add or remove space inside if-condition '(' and ')'
+sp_inside_sparen                         = remove   # ignore/add/remove/force
+
+# Add or remove space before if-condition ')'. Overrides sp_inside_sparen.
+sp_inside_sparen_close                   = ignore   # ignore/add/remove/force
+
+# Add or remove space after ')' of 'if', 'for', 'switch', and 'while'
+sp_after_sparen                          = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of 'if', 'for', 'switch', and 'while'
+sp_sparen_brace                          = add      # ignore/add/remove/force
+
+# Add or remove space between 'invariant' and '(' in the D language.
+sp_invariant_paren                       = ignore   # ignore/add/remove/force
+
+# Add or remove space after the ')' in 'invariant (C) c' in the D language.
+sp_after_invariant_paren                 = ignore   # ignore/add/remove/force
+
+# Add or remove space before empty statement ';' on 'if', 'for' and 'while'
+sp_special_semi                          = add      # ignore/add/remove/force
+
+# Add or remove space before ';'. Default=Remove
+sp_before_semi                           = remove   # ignore/add/remove/force
+
+# Add or remove space before ';' in non-empty 'for' statements
+sp_before_semi_for                       = ignore   # ignore/add/remove/force
+
+# Add or remove space before a semicolon of an empty part of a for statement.
+sp_before_semi_for_empty                 = ignore   # ignore/add/remove/force
+
+# Add or remove space after ';', except when followed by a comment. Default=Add
+sp_after_semi                            = add      # ignore/add/remove/force
+
+# Add or remove space after ';' in non-empty 'for' statements. Default=Force
+sp_after_semi_for                        = force    # ignore/add/remove/force
+
+# Add or remove space after the final semicolon of an empty part of a for statement: for ( ; ; <here> ).
+sp_after_semi_for_empty                  = ignore   # ignore/add/remove/force
+
+# Add or remove space before '[' (except '[]')
+sp_before_square                         = remove   # ignore/add/remove/force
+
+# Add or remove space before '[]'
+sp_before_squares                        = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '[' and ']'
+sp_inside_square                         = ignore   # ignore/add/remove/force
+
+# Add or remove space after ','
+sp_after_comma                           = add      # ignore/add/remove/force
+
+# Add or remove space before ','
+sp_before_comma                          = remove   # ignore/add/remove/force
+
+# Add or remove space between an open paren and comma: '(,' vs '( ,'
+sp_paren_comma                           = force    # ignore/add/remove/force
+
+# Add or remove space before the variadic '...' when preceded by a non-punctuator
+sp_before_ellipsis                       = ignore   # ignore/add/remove/force
+
+# Add or remove space after class ':'
+sp_after_class_colon                     = ignore   # ignore/add/remove/force
+
+# Add or remove space before class ':'
+sp_before_class_colon                    = ignore   # ignore/add/remove/force
+
+# Add or remove space before case ':'. Default=Remove
+sp_before_case_colon                     = remove   # ignore/add/remove/force
+
+# Add or remove space between 'operator' and operator sign
+sp_after_operator                        = ignore   # ignore/add/remove/force
+
+# Add or remove space between the operator symbol and the open paren, as in 'operator ++('
+sp_after_operator_sym                    = ignore   # ignore/add/remove/force
+
+# Add or remove space after C/D cast, i.e. 'cast(int)a' vs 'cast(int) a' or '(int)a' vs '(int) a'
+sp_after_cast                            = add      # ignore/add/remove/force
+
+# Add or remove spaces inside cast parens
+sp_inside_paren_cast                     = ignore   # ignore/add/remove/force
+
+# Add or remove space between the type and open paren in a C++ cast, i.e. 'int(exp)' vs 'int (exp)'
+sp_cpp_cast_paren                        = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'sizeof' and '('
+sp_sizeof_paren                          = remove   # ignore/add/remove/force
+
+# Add or remove space after the tag keyword (Pawn)
+sp_after_tag                             = ignore   # ignore/add/remove/force
+
+# Add or remove space inside enum '{' and '}'
+sp_inside_braces_enum                    = add      # ignore/add/remove/force
+
+# Add or remove space inside struct/union '{' and '}'
+sp_inside_braces_struct                  = add      # ignore/add/remove/force
+
+# Add or remove space inside '{' and '}'
+sp_inside_braces                         = add      # ignore/add/remove/force
+
+# Add or remove space inside '{}'
+sp_inside_braces_empty                   = remove   # ignore/add/remove/force
+
+# Add or remove space between return type and function name
+# A minimum of 1 is forced except for pointer return types.
+sp_type_func                             = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '(' on function declaration
+sp_func_proto_paren                      = remove   # ignore/add/remove/force
+
+# Add or remove space between function name and '(' on function definition
+sp_func_def_paren                        = remove   # ignore/add/remove/force
+
+# Add or remove space inside empty function '()'
+sp_inside_fparens                        = remove   # ignore/add/remove/force
+
+# Add or remove space inside function '(' and ')'
+sp_inside_fparen                         = remove   # ignore/add/remove/force
+
+# Add or remove space between ']' and '(' when part of a function call.
+sp_square_fparen                         = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of function
+sp_fparen_brace                          = add      # ignore/add/remove/force
+
+# Add or remove space between function name and '(' on function calls
+sp_func_call_paren                       = remove   # ignore/add/remove/force
+
+# Add or remove space between function name and '()' on function calls without parameters.
+# If set to 'ignore' (the default), sp_func_call_paren is used.
+sp_func_call_paren_empty                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between the user function name and '(' on function calls
+# You need to set a keyword to be a user function, like this: 'set func_call_user _' in the config file.
+sp_func_call_user_paren                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between a constructor/destructor and the open paren
+sp_func_class_paren                      = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'return' and '('
+sp_return_paren                          = ignore   # ignore/add/remove/force
+
+# Add or remove space between '__attribute__' and '('
+sp_attribute_paren                       = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'defined' and '(' in '#if defined (FOO)'
+sp_defined_paren                         = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'throw' and '(' in 'throw (something)'
+sp_throw_paren                           = ignore   # ignore/add/remove/force
+
+# Add or remove space between macro and value
+sp_macro                                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between macro function ')' and value
+sp_macro_func                            = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'else' and '{' if on the same line
+sp_else_brace                            = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and 'else' if on the same line
+sp_brace_else                            = add      # ignore/add/remove/force
+
+# Add or remove space between '}' and the name of a typedef on the same line
+sp_brace_typedef                         = add      # ignore/add/remove/force
+
+# Add or remove space between 'catch' and '{' if on the same line
+sp_catch_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove space between '}' and 'catch' if on the same line
+sp_brace_catch                           = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'finally' and '{' if on the same line
+sp_finally_brace                         = ignore   # ignore/add/remove/force
+
+# Add or remove space between '}' and 'finally' if on the same line
+sp_brace_finally                         = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'try' and '{' if on the same line
+sp_try_brace                             = ignore   # ignore/add/remove/force
+
+# Add or remove space between get/set and '{' if on the same line
+sp_getset_brace                          = ignore   # ignore/add/remove/force
+
+# Add or remove space before the '::' operator
+sp_before_dc                             = ignore   # ignore/add/remove/force
+
+# Add or remove space after the '::' operator
+sp_after_dc                              = ignore   # ignore/add/remove/force
+
+# Add or remove around the D named array initializer ':' operator
+sp_d_array_colon                         = ignore   # ignore/add/remove/force
+
+# Add or remove space after the '!' (not) operator. Default=Remove
+sp_not                                   = remove   # ignore/add/remove/force
+
+# Add or remove space after the '~' (invert) operator. Default=Remove
+sp_inv                                   = remove   # ignore/add/remove/force
+
+# Add or remove space after the '&' (address-of) operator. Default=Remove
+# This does not affect the spacing after a '&' that is part of a type.
+sp_addr                                  = remove   # ignore/add/remove/force
+
+# Add or remove space around the '.' or '->' operators. Default=Remove
+sp_member                                = remove   # ignore/add/remove/force
+
+# Add or remove space after the '*' (dereference) operator. Default=Remove
+# This does not affect the spacing after a '*' that is part of a type.
+sp_deref                                 = remove   # ignore/add/remove/force
+
+# Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. Default=Remove
+sp_sign                                  = remove   # ignore/add/remove/force
+
+# Add or remove space before or after '++' and '--', as in '(--x)' or 'y++;'. Default=Remove
+sp_incdec                                = remove   # ignore/add/remove/force
+
+# Add or remove space before a backslash-newline at the end of a line. Default=Add
+sp_before_nl_cont                        = add      # ignore/add/remove/force
+
+# Add or remove space after the scope '+' or '-', as in '-(void) foo;' or '+(int) bar;'
+sp_after_oc_scope                        = ignore   # ignore/add/remove/force
+
+# Add or remove space after the colon in message specs
+# '-(int) f:(int) x;' vs '-(int) f: (int) x;'
+sp_after_oc_colon                        = ignore   # ignore/add/remove/force
+
+# Add or remove space before the colon in message specs
+# '-(int) f: (int) x;' vs '-(int) f : (int) x;'
+sp_before_oc_colon                       = ignore   # ignore/add/remove/force
+
+# Add or remove space after the colon in message specs
+# '[object setValue:1];' vs '[object setValue: 1];'
+sp_after_send_oc_colon                   = ignore   # ignore/add/remove/force
+
+# Add or remove space before the colon in message specs
+# '[object setValue:1];' vs '[object setValue :1];'
+sp_before_send_oc_colon                  = ignore   # ignore/add/remove/force
+
+# Add or remove space after the (type) in message specs
+# '-(int)f: (int) x;' vs '-(int)f: (int)x;'
+sp_after_oc_type                         = ignore   # ignore/add/remove/force
+
+# Add or remove space after the first (type) in message specs
+# '-(int) f:(int)x;' vs '-(int)f:(int)x;'
+sp_after_oc_return_type                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between '@selector' and '('
+# '@selector(msgName)' vs '@selector (msgName)'
+# Also applies to @protocol() constructs
+sp_after_oc_at_sel                       = ignore   # ignore/add/remove/force
+
+# Add or remove space between '@selector(x)' and the following word
+# '@selector(foo) a:' vs '@selector(foo)a:'
+sp_after_oc_at_sel_parens                = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '@selector' parens
+# '@selector(foo)' vs '@selector( foo )'
+# Also applies to @protocol() constructs
+sp_inside_oc_at_sel_parens               = ignore   # ignore/add/remove/force
+
+# Add or remove space before a block pointer caret
+# '^int (int arg){...}' vs. ' ^int (int arg){...}'
+sp_before_oc_block_caret                 = ignore   # ignore/add/remove/force
+
+# Add or remove space after a block pointer caret
+# '^int (int arg){...}' vs. '^ int (int arg){...}'
+sp_after_oc_block_caret                  = ignore   # ignore/add/remove/force
+
+# Add or remove space around the ':' in 'b ? t : f'
+sp_cond_colon                            = add      # ignore/add/remove/force
+
+# Add or remove space around the '?' in 'b ? t : f'
+sp_cond_question                         = add      # ignore/add/remove/force
+
+# Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make sense here.
+sp_case_label                            = ignore   # ignore/add/remove/force
+
+# Control the space around the D '..' operator.
+sp_range                                 = ignore   # ignore/add/remove/force
+
+# Control the space after the opening of a C++ comment '// A' vs '//A'
+sp_cmt_cpp_start                         = ignore   # ignore/add/remove/force
+
+# Controls the spaces between #else or #endif and a trailing comment
+sp_endif_cmt                             = force   # ignore/add/remove/force
+
+#
+# Code alignment (not left column spaces/tabs)
+#
+
+# Whether to keep non-indenting tabs
+align_keep_tabs                          = false    # false/true
+
+# Whether to use tabs for aligning
+align_with_tabs                          = false    # false/true
+
+# Whether to bump out to the next tab when aligning
+align_on_tabstop                         = false    # false/true
+
+# Whether to left-align numbers
+align_number_left                        = false    # false/true
+
+# Align variable definitions in prototypes and functions
+align_func_params                        = false    # false/true
+
+# Align parameters in single-line functions that have the same name.
+# The function names must already be aligned with each other.
+align_same_func_call_params              = false    # false/true
+
+# The span for aligning variable definitions (0=don't align)
+align_var_def_span                       = 1        # number
+
+# How to align the star in variable definitions.
+#  0=Part of the type     'void *   foo;'
+#  1=Part of the variable 'void     *foo;'
+#  2=Dangling             'void    *foo;'
+align_var_def_star_style                 = 2        # number
+
+# How to align the '&' in variable definitions.
+#  0=Part of the type
+#  1=Part of the variable
+#  2=Dangling
+align_var_def_amp_style                  = 0        # number
+
+# The threshold for aligning variable definitions (0=no limit)
+align_var_def_thresh                     = 0        # number
+
+# The gap for aligning variable definitions
+align_var_def_gap                        = 0        # number
+
+# Whether to align the colon in struct bit fields
+align_var_def_colon                      = false    # false/true
+
+# Whether to align any attribute after the variable name
+align_var_def_attribute                  = false    # false/true
+
+# Whether to align inline struct/enum/union variable definitions
+align_var_def_inline                     = false    # false/true
+
+# The span for aligning on '=' in assignments (0=don't align)
+align_assign_span                        = 1        # number
+
+# The threshold for aligning on '=' in assignments (0=no limit)
+align_assign_thresh                      = 0        # number
+
+# The span for aligning on '=' in enums (0=don't align)
+align_enum_equ_span                      = 1        # number
+
+# The threshold for aligning on '=' in enums (0=no limit)
+align_enum_equ_thresh                    = 0        # number
+
+# The span for aligning struct/union (0=don't align)
+align_var_struct_span                    = 1        # number
+
+# The threshold for aligning struct/union member definitions (0=no limit)
+align_var_struct_thresh                  = 0        # number
+
+# The gap for aligning struct/union member definitions
+align_var_struct_gap                     = 0        # number
+
+# The span for aligning struct initializer values (0=don't align)
+align_struct_init_span                   = 1        # number
+
+# The minimum space between the type and the synonym of a typedef
+align_typedef_gap                        = 0        # number
+
+# The span for aligning single-line typedefs (0=don't align)
+align_typedef_span                       = 0        # number
+
+# How to align typedef'd functions with other typedefs
+# 0: Don't mix them at all
+# 1: align the open paren with the types
+# 2: align the function type name with the other type names
+align_typedef_func                       = 0        # number
+
+# Controls the positioning of the '*' in typedefs. Just try it.
+# 0: Align on typedef type, ignore '*'
+# 1: The '*' is part of type name: typedef int  *pint;
+# 2: The '*' is part of the type, but dangling: typedef int *pint;
+align_typedef_star_style                 = 0        # number
+
+# Controls the positioning of the '&' in typedefs. Just try it.
+# 0: Align on typedef type, ignore '&'
+# 1: The '&' is part of type name: typedef int  &pint;
+# 2: The '&' is part of the type, but dangling: typedef int &pint;
+align_typedef_amp_style                  = 0        # number
+
+# The span for aligning comments that end lines (0=don't align)
+align_right_cmt_span                     = 0        # number
+
+# If aligning comments, mix with comments after '}' and #endif with less than 3 spaces before the comment
+align_right_cmt_mix                      = false    # false/true
+
+# If a trailing comment is more than this number of columns away from the text it follows,
+# it will qualify for being aligned. This has to be > 0 to do anything.
+align_right_cmt_gap                      = 0        # number
+
+# Align trailing comment at or beyond column N; 'pulls in' comments as a bonus side effect (0=ignore)
+align_right_cmt_at_col                   = 0        # number
+
+# The span for aligning function prototypes (0=don't align)
+align_func_proto_span                    = 0        # number
+
+# Minimum gap between the return type and the function name.
+align_func_proto_gap                     = 0        # number
+
+# Align function protos on the 'operator' keyword instead of what follows
+align_on_operator                        = false    # false/true
+
+# Whether to mix aligning prototype and variable declarations.
+# If true, align_var_def_XXX options are used instead of align_func_proto_XXX options.
+align_mix_var_proto                      = false    # false/true
+
+# Align single-line functions with function prototypes, uses align_func_proto_span
+align_single_line_func                   = false    # false/true
+
+# Aligning the open brace of single-line functions.
+# Requires align_single_line_func=true, uses align_func_proto_span
+align_single_line_brace                  = false    # false/true
+
+# Gap for align_single_line_brace.
+align_single_line_brace_gap              = 0        # number
+
+# The span for aligning ObjC msg spec (0=don't align)
+align_oc_msg_spec_span                   = 0        # number
+
+# Whether to align macros wrapped with a backslash and a newline.
+# This will not work right if the macro contains a multi-line comment.
+align_nl_cont                            = false    # false/true
+
+# The minimum space between label and value of a preprocessor define
+align_pp_define_gap                      = 0        # number
+
+# The span for aligning on '#define' bodies (0=don't align)
+align_pp_define_span                     = 0        # number
+
+# Align lines that start with '<<' with previous '<<'. Default=true
+align_left_shift                         = true     # false/true
+
+# Span for aligning parameters in an Obj-C message call on the ':' (0=don't align)
+align_oc_msg_colon_span                  = 0        # number
+
+# Aligning parameters in an Obj-C '+' or '-' declaration on the ':'
+align_oc_decl_colon                      = false    # false/true
+
+#
+# Newline adding and removing options
+#
+
+# Whether to collapse empty blocks between '{' and '}'
+nl_collapse_empty_body                   = false    # false/true
+
+# Don't split one-line braced assignments - 'foo_t f = { 1, 2 };'
+nl_assign_leave_one_liners               = false    # false/true
+
+# Don't split one-line braced statements inside a class xx { } body
+nl_class_leave_one_liners                = false    # false/true
+
+# Don't split one-line enums: 'enum foo { BAR = 15 };'
+nl_enum_leave_one_liners                 = false    # false/true
+
+# Don't split one-line get or set functions
+nl_getset_leave_one_liners               = false    # false/true
+
+# Don't split one-line function definitions - 'int foo() { return 0; }'
+nl_func_leave_one_liners                 = false    # false/true
+
+# Don't split one-line if/else statements - 'if(a) b++;'
+nl_if_leave_one_liners                   = false    # false/true
+
+# Add or remove newlines at the start of the file
+nl_start_of_file                         = remove   # ignore/add/remove/force
+
+# The number of newlines at the start of the file (only used if nl_start_of_file is 'add' or 'force'
+nl_start_of_file_min                     = 0        # number
+
+# Add or remove newline at the end of the file
+nl_end_of_file                           = force    # ignore/add/remove/force
+
+# The number of newlines at the end of the file (only used if nl_end_of_file is 'add' or 'force')
+nl_end_of_file_min                       = 1        # number
+
+# Add or remove newline between '=' and '{'
+nl_assign_brace                          = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '=' and '[' (D only)
+nl_assign_square                         = ignore   # ignore/add/remove/force
+
+# Add or remove newline after '= [' (D only). Will also affect the newline before the ']'
+nl_after_square_assign                   = ignore   # ignore/add/remove/force
+
+# The number of blank lines after a block of variable definitions
+nl_func_var_def_blk                      = 0        # number
+
+# Add or remove newline between a function call's ')' and '{', as in:
+# list_for_each(item, &list) { }
+nl_fcall_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum' and '{'
+nl_enum_brace                            = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'struct and '{'
+nl_struct_brace                          = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'union' and '{'
+nl_union_brace                           = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'if' and '{'
+nl_if_brace                              = remove   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'else'
+nl_brace_else                            = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'else if' and '{'
+# If set to ignore, nl_if_brace is used instead
+nl_elseif_brace                          = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'else' and '{'
+nl_else_brace                            = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'else' and 'if'
+nl_else_if                               = remove   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'finally'
+nl_brace_finally                         = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'finally' and '{'
+nl_finally_brace                         = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'try' and '{'
+nl_try_brace                             = ignore   # ignore/add/remove/force
+
+# Add or remove newline between get/set and '{'
+nl_getset_brace                          = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'for' and '{'
+nl_for_brace                             = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'catch' and '{'
+nl_catch_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'catch'
+nl_brace_catch                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'while' and '{'
+nl_while_brace                           = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'using' and '{'
+nl_using_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline between two open or close braces.
+# Due to general newline/brace handling, REMOVE may not work.
+nl_brace_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'do' and '{'
+nl_do_brace                              = remove   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'while' of 'do' statement
+nl_brace_while                           = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'switch' and '{'
+nl_switch_brace                          = remove   # ignore/add/remove/force
+
+# Add a newline between ')' and '{' if the ')' is on a different line than the if/for/etc.
+# Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch, and nl_catch_brace.
+nl_multi_line_cond                       = false    # false/true
+
+# Force a newline in a define after the macro name for multi-line defines.
+nl_multi_line_define                     = false    # false/true
+
+# Whether to put a newline before 'case' statement
+nl_before_case                           = false    # false/true
+
+# Add or remove newline between ')' and 'throw'
+nl_before_throw                          = ignore   # ignore/add/remove/force
+
+# Whether to put a newline after 'case' statement
+nl_after_case                            = false    # false/true
+
+# Newline between namespace and {
+nl_namespace_brace                       = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'template<>' and whatever follows.
+nl_template_class                        = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'class' and '{'
+nl_class_brace                           = ignore   # ignore/add/remove/force
+
+# Add or remove newline after each ',' in the constructor member initialization
+nl_class_init_args                       = ignore   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name in a function definition
+nl_func_type_name                        = remove   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name inside a class {}
+# Uses nl_func_type_name or nl_func_proto_type_name if set to ignore.
+nl_func_type_name_class                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between function scope and name in a definition
+# Controls the newline after '::' in 'void A::f() { }'
+nl_func_scope_name                       = ignore   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name in a prototype
+nl_func_proto_type_name                  = remove   # ignore/add/remove/force
+
+# Add or remove newline between a function name and the opening '('
+nl_func_paren                            = remove   # ignore/add/remove/force
+
+# Add or remove newline between a function name and the opening '(' in the definition
+nl_func_def_paren                        = remove   # ignore/add/remove/force
+
+# Add or remove newline after '(' in a function declaration
+nl_func_decl_start                       = remove   # ignore/add/remove/force
+
+# Add or remove newline after '(' in a function definition
+nl_func_def_start                        = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_decl_start when there is only one parameter.
+nl_func_decl_start_single                = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_def_start when there is only one parameter.
+nl_func_def_start_single                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline after each ',' in a function declaration
+nl_func_decl_args                        = ignore   # ignore/add/remove/force
+
+# Add or remove newline after each ',' in a function definition
+nl_func_def_args                         = ignore   # ignore/add/remove/force
+
+# Add or remove newline before the ')' in a function declaration
+nl_func_decl_end                         = remove   # ignore/add/remove/force
+
+# Add or remove newline before the ')' in a function definition
+nl_func_def_end                          = remove   # ignore/add/remove/force
+
+# Overrides nl_func_decl_end when there is only one parameter.
+nl_func_decl_end_single                  = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_def_end when there is only one parameter.
+nl_func_def_end_single                   = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '()' in a function declaration.
+nl_func_decl_empty                       = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '()' in a function definition.
+nl_func_def_empty                        = ignore   # ignore/add/remove/force
+
+# Add or remove newline between function signature and '{'
+nl_fdef_brace                            = add      # ignore/add/remove/force
+
+# Whether to put a newline after 'return' statement
+nl_after_return                          = false    # false/true
+
+# Add or remove a newline between the return keyword and return expression.
+nl_return_expr                           = ignore   # ignore/add/remove/force
+
+# Whether to put a newline after semicolons, except in 'for' statements
+nl_after_semicolon                       = true     # false/true
+
+# Whether to put a newline after brace open.
+# This also adds a newline before the matching brace close.
+nl_after_brace_open                      = false    # false/true
+
+# If nl_after_brace_open and nl_after_brace_open_cmt are true, a newline is
+# placed between the open brace and a trailing single-line comment.
+nl_after_brace_open_cmt                  = false    # false/true
+
+# Whether to put a newline after a virtual brace open with a non-empty body.
+# These occur in un-braced if/while/do/for statement bodies.
+nl_after_vbrace_open                     = true     # false/true
+
+# Whether to put a newline after a virtual brace open with an empty body.
+# These occur in un-braced if/while/do/for statement bodies.
+nl_after_vbrace_open_empty               = true    # false/true
+
+# Whether to put a newline after a brace close.
+# Does not apply if followed by a necessary ';'.
+nl_after_brace_close                     = false    # false/true
+
+# Whether to put a newline after a virtual brace close.
+# Would add a newline before return in: 'if (foo) a++; return;'
+nl_after_vbrace_close                    = false    # false/true
+
+# Whether to alter newlines in '#define' macros
+nl_define_macro                          = false    # false/true
+
+# Whether to not put blanks after '#ifxx', '#elxx', or before '#endif'
+nl_squeeze_ifdef                         = false    # false/true
+
+# Add or remove blank line before 'if'
+nl_before_if                             = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'if' statement
+nl_after_if                              = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'for'
+nl_before_for                            = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'for' statement
+nl_after_for                             = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'while'
+nl_before_while                          = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'while' statement
+nl_after_while                           = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'switch'
+nl_before_switch                         = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'switch' statement
+nl_after_switch                          = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'do'
+nl_before_do                             = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'do/while' statement
+nl_after_do                              = ignore   # ignore/add/remove/force
+
+# Whether to double-space commented-entries in struct/enum
+nl_ds_struct_enum_cmt                    = false    # false/true
+
+# Whether to double-space before the close brace of a struct/union/enum
+# (lower priority than 'eat_blanks_before_close_brace')
+nl_ds_struct_enum_close_brace            = false    # false/true
+
+# Add or remove a newline around a class colon.
+# Related to pos_class_colon, nl_class_init_args, and pos_comma.
+nl_class_colon                           = ignore   # ignore/add/remove/force
+
+# Change simple unbraced if statements into a one-liner
+# 'if(b)\n i++;' => 'if(b) i++;'
+nl_create_if_one_liner                   = false    # false/true
+
+# Change simple unbraced for statements into a one-liner
+# 'for (i=0;i<5;i++)\n foo(i);' => 'for (i=0;i<5;i++) foo(i);'
+nl_create_for_one_liner                  = false    # false/true
+
+# Change simple unbraced while statements into a one-liner
+# 'while (i<5)\n foo(i++);' => 'while (i<5) foo(i++);'
+nl_create_while_one_liner                = false    # false/true
+
+#
+# Positioning options
+#
+
+# The position of arithmetic operators in wrapped expressions
+pos_arith                                = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of assignment in wrapped expressions.
+# Do not affect '=' followed by '{'
+pos_assign                               = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of boolean operators in wrapped expressions
+pos_bool                                 = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of comparison operators in wrapped expressions
+pos_compare                              = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of conditional (b ? t : f) operators in wrapped expressions
+pos_conditional                          = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of the comma in wrapped expressions
+pos_comma                                = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of the comma in the constructor initialization list
+pos_class_comma                          = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+# The position of colons between constructor and member initialization
+pos_class_colon                          = ignore   # ignore/lead/lead_break/lead_force/trail/trail_break/trail_force
+
+#
+# Line Splitting options
+#
+
+# Try to limit code width to N number of columns
+code_width                               = 0        # number
+
+# Whether to fully split long 'for' statements at semi-colons
+ls_for_split_full                        = false    # false/true
+
+# Whether to fully split long function protos/calls at commas
+ls_func_split_full                       = false    # false/true
+
+#
+# Blank line options
+#
+
+# The maximum consecutive newlines
+nl_max                                   = 0        # number
+
+# The number of newlines after a function prototype, if followed by another function prototype
+nl_after_func_proto                      = 0        # number
+
+# The number of newlines after a function prototype, if not followed by another function prototype
+nl_after_func_proto_group                = 0        # number
+
+# The number of newlines after '}' of a multi-line function body
+nl_after_func_body                       = 2        # number
+
+# The number of newlines after '}' of a single line function body
+nl_after_func_body_one_liner             = 2        # number
+
+# The minimum number of newlines before a multi-line comment.
+# Doesn't apply if after a brace open or another multi-line comment.
+nl_before_block_comment                  = 0        # number
+
+# The minimum number of newlines before a single-line C comment.
+# Doesn't apply if after a brace open or other single-line C comments.
+nl_before_c_comment                      = 0        # number
+
+# The minimum number of newlines before a CPP comment.
+# Doesn't apply if after a brace open or other CPP comments.
+nl_before_cpp_comment                    = 0        # number
+
+# Whether to force a newline after a multi-line comment.
+nl_after_multiline_comment               = false    # false/true
+
+# The number of newlines before a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label.
+# Will not change the newline count if after a brace open.
+# 0 = No change.
+nl_before_access_spec                    = 0        # number
+
+# The number of newlines after a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label.
+# 0 = No change.
+nl_after_access_spec                     = 0        # number
+
+# The number of newlines between a function def and the function comment.
+# 0 = No change.
+nl_comment_func_def                      = 0        # number
+
+# The number of newlines after a try-catch-finally block that isn't followed by a brace close.
+# 0 = No change.
+nl_after_try_catch_finally               = 0        # number
+
+# The number of newlines before and after a property, indexer or event decl.
+# 0 = No change.
+nl_around_cs_property                    = 0        # number
+
+# The number of newlines between the get/set/add/remove handlers in C#.
+# 0 = No change.
+nl_between_get_set                       = 0        # number
+
+# Whether to remove blank lines after '{'
+eat_blanks_after_open_brace              = true     # false/true
+
+# Whether to remove blank lines before '}'
+eat_blanks_before_close_brace            = true     # false/true
+
+#
+# Code modifying options (non-whitespace)
+#
+
+# Add or remove braces on single-line 'do' statement
+mod_full_brace_do                        = add      # ignore/add/remove/force
+
+# Add or remove braces on single-line 'for' statement
+mod_full_brace_for                       = add      # ignore/add/remove/force
+
+# Add or remove braces on single-line function definitions. (Pawn)
+mod_full_brace_function                  = ignore   # ignore/add/remove/force
+
+# Add or remove braces on single-line 'if' statement. Will not remove the braces if they contain an 'else'.
+mod_full_brace_if                        = add      # ignore/add/remove/force
+
+# Make all if/elseif/else statements in a chain be braced or not. Overrides mod_full_brace_if.
+# If any must be braced, they are all braced.  If all can be unbraced, then the braces are removed.
+mod_full_brace_if_chain                  = false    # false/true
+
+# Don't remove braces around statements that span N newlines
+mod_full_brace_nl                        = 0        # number
+
+# Add or remove braces on single-line 'while' statement
+mod_full_brace_while                     = add      # ignore/add/remove/force
+
+# Add or remove braces on single-line 'using ()' statement
+mod_full_brace_using                     = add      # ignore/add/remove/force
+
+# Add or remove unnecessary paren on 'return' statement
+mod_paren_on_return                      = remove   # ignore/add/remove/force
+
+# Whether to change optional semicolons to real semicolons
+mod_pawn_semicolon                       = false    # false/true
+
+# Add parens on 'while' and 'if' statement around bools
+mod_full_paren_if_bool                   = false    # false/true
+
+# Whether to remove superfluous semicolons
+mod_remove_extra_semicolon               = false    # false/true
+
+# If a function body exceeds the specified number of newlines and doesn't have a comment after
+# the close brace, a comment will be added.
+mod_add_long_function_closebrace_comment = 0        # number
+
+# If a switch body exceeds the specified number of newlines and doesn't have a comment after
+# the close brace, a comment will be added.
+mod_add_long_switch_closebrace_comment   = 0        # number
+
+# If an #ifdef body exceeds the specified number of newlines and doesn't have a comment after
+# the #else, a comment will be added.
+mod_add_long_ifdef_endif_comment         = 0        # number
+
+# If an #ifdef or #else body exceeds the specified number of newlines and doesn't have a comment after
+# the #endif, a comment will be added.
+mod_add_long_ifdef_else_comment          = 0        # number
+
+# If TRUE, will sort consecutive single-line 'import' statements [Java, D]
+mod_sort_import                          = false    # false/true
+
+# If TRUE, will sort consecutive single-line 'using' statements [C#]
+mod_sort_using                           = false    # false/true
+
+# If TRUE, will sort consecutive single-line '#include' statements [C/C++] and '#import' statements [Obj-C]
+# This is generally a bad idea, as it may break your code.
+mod_sort_include                         = false    # false/true
+
+# If TRUE, it will move a 'break' that appears after a fully braced 'case' before the close brace.
+mod_move_case_break                      = false    # false/true
+
+# Will add or remove the braces around a fully braced case statement.
+# Will only remove the braces if there are no variable declarations in the block.
+mod_case_brace                           = ignore   # ignore/add/remove/force
+
+# If TRUE, it will remove a void 'return;' that appears as the last statement in a function.
+mod_remove_empty_return                  = false    # false/true
+
+#
+# Comment modifications
+#
+
+# Try to wrap comments at cmt_width columns
+cmt_width                                = 0        # number
+
+# Set the comment reflow mode (default: 0)
+# 0: no reflowing (apart from the line wrapping due to cmt_width)
+# 1: no touching at all
+# 2: full reflow
+cmt_reflow_mode                          = 0        # number
+
+# If false, disable all multi-line comment changes, including cmt_width. keyword substitution, and leading chars.
+# Default is true.
+cmt_indent_multi                         = true     # false/true
+
+# Whether to group c-comments that look like they are in a block
+cmt_c_group                              = false    # false/true
+
+# Whether to put an empty '/*' on the first line of the combined c-comment
+cmt_c_nl_start                           = false    # false/true
+
+# Whether to put a newline before the closing '*/' of the combined c-comment
+cmt_c_nl_end                             = false    # false/true
+
+# Whether to group cpp-comments that look like they are in a block
+cmt_cpp_group                            = false    # false/true
+
+# Whether to put an empty '/*' on the first line of the combined cpp-comment
+cmt_cpp_nl_start                         = false    # false/true
+
+# Whether to put a newline before the closing '*/' of the combined cpp-comment
+cmt_cpp_nl_end                           = false    # false/true
+
+# Whether to change cpp-comments into c-comments
+cmt_cpp_to_c                             = false    # false/true
+
+# Whether to put a star on subsequent comment lines
+cmt_star_cont                            = true     # false/true
+
+# The number of spaces to insert at the start of subsequent comment lines
+cmt_sp_before_star_cont                  = 0        # number
+
+# The number of spaces to insert after the star on subsequent comment lines
+cmt_sp_after_star_cont                   = 0        # number
+
+# For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of
+# the comment are the same length. Default=True
+cmt_multi_check_last                     = false    # false/true
+
+# The filename that contains text to insert at the head of a file if the file doesn't start with a C/C++ comment.
+# Will substitute $(filename) with the current file's name.
+cmt_insert_file_header                   = ""         # string
+
+# The filename that contains text to insert at the end of a file if the file doesn't end with a C/C++ comment.
+# Will substitute $(filename) with the current file's name.
+cmt_insert_file_footer                   = ""         # string
+
+# The filename that contains text to insert before a function implementation if the function isn't preceded with a C/C++ comment.
+# Will substitute $(function) with the function name and $(javaparam) with the javadoc @param and @return stuff.
+# Will also substitute $(fclass) with the class name: void CFoo::Bar() { ... }
+cmt_insert_func_header                   = ""         # string
+
+# The filename that contains text to insert before a class if the class isn't preceded with a C/C++ comment.
+# Will substitute $(class) with the class name.
+cmt_insert_class_header                  = ""         # string
+
+# If a preprocessor is encountered when stepping backwards from a function name, then
+# this option decides whether the comment should be inserted.
+# Affects cmt_insert_func_header and cmt_insert_class_header.
+cmt_insert_before_preproc                = false    # false/true
+
+#
+# Preprocessor options
+#
+
+# Control indent of preprocessors inside #if blocks at brace level 0
+pp_indent                                = remove   # ignore/add/remove/force
+
+# Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false)
+pp_indent_at_level                       = false    # false/true
+
+# If pp_indent_at_level=false, specifies the number of columns to indent per level. Default=1.
+pp_indent_count                          = 1        # number
+
+# Add or remove space after # based on pp_level of #if blocks
+pp_space                                 = remove   # ignore/add/remove/force
+
+# Sets the number of spaces added with pp_space
+pp_space_count                           = 0        # number
+
+# The indent for #region and #endregion in C# and '#pragma region' in C/C++
+pp_indent_region                         = 0        # number
+
+# Whether to indent the code between #region and #endregion
+pp_region_indent_code                    = false    # false/true
+
+# If pp_indent_at_level=true, sets the indent for #if, #else, and #endif when not at file-level
+pp_indent_if                             = 0        # number
+
+# Control whether to indent the code between #if, #else and #endif when not at file-level
+pp_if_indent_code                        = false    # false/true
+
+# Whether to indent '#define' at the brace level (true) or from column 1 (false)
+pp_define_at_level                       = false    # false/true
+
+# You can force a token to be a type with the 'type' option.
+# Example:
+# type myfoo1 myfoo2
+#
+# You can create custom macro-based indentation using macro-open,
+# macro-else and macro-close.
+# Example:
+# macro-open  BEGIN_TEMPLATE_MESSAGE_MAP
+# macro-open  BEGIN_MESSAGE_MAP
+# macro-close END_MESSAGE_MAP
+#
+# You can assign any keyword to any type with the set option.
+# set func_call_user _ N_
+#
+# The full syntax description of all custom definition config entries
+# is shown below:
+#
+# define custom tokens as:
+# - embed whitespace in token using '' escape character, or
+#   put token in quotes
+# - these: ' " and ` are recognized as quote delimiters
+#
+# type token1 token2 token3 ...
+#             ^ optionally specify multiple tokens on a single line
+# define def_token output_token
+#                  ^ output_token is optional, then NULL is assumed
+# macro-open token
+# macro-close token
+# macro-else token
+# set id token1 token2 ...
+#               ^ optionally specify multiple tokens on a single line
+#     ^ id is one of the names in token_enum.h sans the CT_ prefix,
+#       e.g. PP_PRAGMA
+#
+# all tokens are separated by any mix of ',' commas, '=' equal signs
+# and whitespace (space, tab)
+#

=== renamed file 'tools/dot_uncrustify.cfg' => '.uncrustify.cfg'
--- tools/dot_uncrustify.cfg	2010-12-31 12:30:21 +0000
+++ .uncrustify.cfg	2011-01-11 14:04:40 +0000
@@ -255,7 +255,7 @@
 sp_before_byref_func                     = ignore   # ignore/add/remove/force
 
 # Add or remove space between type and word. Default=Force
-sp_after_type                            = force    # ignore/add/remove/force
+sp_after_type                            = ignore    # ignore/add/remove/force
 
 # Add or remove space in 'template <' vs 'template<'.
 # If set to ignore, sp_before_angle is used.
@@ -367,16 +367,16 @@
 sp_after_tag                             = ignore   # ignore/add/remove/force
 
 # Add or remove space inside enum '{' and '}'
-sp_inside_braces_enum                    = force    # ignore/add/remove/force
+sp_inside_braces_enum                    = add      # ignore/add/remove/force
 
 # Add or remove space inside struct/union '{' and '}'
-sp_inside_braces_struct                  = force    # ignore/add/remove/force
+sp_inside_braces_struct                  = add      # ignore/add/remove/force
 
 # Add or remove space inside '{' and '}'
-sp_inside_braces                         = ignore   # ignore/add/remove/force
+sp_inside_braces                         = add      # ignore/add/remove/force
 
 # Add or remove space inside '{}'
-sp_inside_braces_empty                   = ignore   # ignore/add/remove/force
+sp_inside_braces_empty                   = remove   # ignore/add/remove/force
 
 # Add or remove space between return type and function name
 # A minimum of 1 is forced except for pointer return types.
@@ -560,13 +560,13 @@
 align_same_func_call_params              = false    # false/true
 
 # The span for aligning variable definitions (0=don't align)
-align_var_def_span                       = 0        # number
+align_var_def_span                       = 1        # number
 
 # How to align the star in variable definitions.
 #  0=Part of the type     'void *   foo;'
 #  1=Part of the variable 'void     *foo;'
 #  2=Dangling             'void    *foo;'
-align_var_def_star_style                 = 0        # number
+align_var_def_star_style                 = 2        # number
 
 # How to align the '&' in variable definitions.
 #  0=Part of the type
@@ -590,19 +590,19 @@
 align_var_def_inline                     = false    # false/true
 
 # The span for aligning on '=' in assignments (0=don't align)
-align_assign_span                        = 4        # number
+align_assign_span                        = 1        # number
 
 # The threshold for aligning on '=' in assignments (0=no limit)
 align_assign_thresh                      = 0        # number
 
 # The span for aligning on '=' in enums (0=don't align)
-align_enum_equ_span                      = 4        # number
+align_enum_equ_span                      = 1        # number
 
 # The threshold for aligning on '=' in enums (0=no limit)
 align_enum_equ_thresh                    = 0        # number
 
 # The span for aligning struct/union (0=don't align)
-align_var_struct_span                    = 4        # number
+align_var_struct_span                    = 1        # number
 
 # The threshold for aligning struct/union member definitions (0=no limit)
 align_var_struct_thresh                  = 0        # number
@@ -611,7 +611,7 @@
 align_var_struct_gap                     = 0        # number
 
 # The span for aligning struct initializer values (0=don't align)
-align_struct_init_span                   = 4        # number
+align_struct_init_span                   = 1        # number
 
 # The minimum space between the type and the synonym of a typedef
 align_typedef_gap                        = 0        # number
@@ -1175,8 +1175,8 @@
 cmt_sp_after_star_cont                   = 0        # number
 
 # For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of
-# the comment are the same length. Default=true
-cmt_multi_check_last                     = true     # false/true
+# the comment are the same length. Default=True
+cmt_multi_check_last                     = false    # false/true
 
 # The filename that contains text to insert at the head of a file if the file doesn't start with a C/C++ comment.
 # Will substitute $(filename) with the current file's name.
@@ -1205,7 +1205,7 @@
 #
 
 # Control indent of preprocessors inside #if blocks at brace level 0
-pp_indent                                = ignore   # ignore/add/remove/force
+pp_indent                                = remove   # ignore/add/remove/force
 
 # Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false)
 pp_indent_at_level                       = false    # false/true
@@ -1214,7 +1214,7 @@
 pp_indent_count                          = 1        # number
 
 # Add or remove space after # based on pp_level of #if blocks
-pp_space                                 = ignore   # ignore/add/remove/force
+pp_space                                 = remove   # ignore/add/remove/force
 
 # Sets the number of spaces added with pp_space
 pp_space_count                           = 0        # number

=== modified file 'firewall/cache.c'
--- firewall/cache.c	2011-01-09 22:18:11 +0000
+++ firewall/cache.c	2011-01-11 14:04:40 +0000
@@ -66,7 +66,7 @@
 struct hip_hadb_user_info_state *hip_cache_create_hl_entry(void)
 {
     struct hip_hadb_user_info_state *entry = NULL;
-    int err = 0;
+    int                              err   = 0;
 
     HIP_IFEL(!(entry = calloc(1, sizeof(struct hip_hadb_user_info_state))),
              -ENOMEM, "No memory available for firewall database entry\n");
@@ -120,7 +120,7 @@
                                                                       const void *peer,
                                                                       enum fw_cache_query_type type)
 {
-    int err = 0;
+    int                                    err           = 0;
     struct       hip_hadb_user_info_state *ha_ret        = NULL;
     const struct hip_hadb_user_info_state *ha_match      = NULL;
     const struct hip_hadb_user_info_state *ha_curr       = NULL;
@@ -143,13 +143,13 @@
             ha_match = ha_curr;
             break;
         } else if (type == FW_CACHE_LSI &&
-            !ipv4_addr_cmp(peer, &ha_curr->lsi_peer) &&
-            (!local || !ipv4_addr_cmp(local, &ha_curr->lsi_our))) {
+                   !ipv4_addr_cmp(peer, &ha_curr->lsi_peer) &&
+                   (!local || !ipv4_addr_cmp(local, &ha_curr->lsi_our))) {
             ha_match = ha_curr;
             break;
         } else if (type == FW_CACHE_IP &&
-            !ipv6_addr_cmp(peer, &ha_curr->ip_peer) &&
-            (!local || !ipv6_addr_cmp(local, &ha_curr->ip_our))) {
+                   !ipv6_addr_cmp(peer, &ha_curr->ip_peer) &&
+                   (!local || !ipv6_addr_cmp(local, &ha_curr->ip_our))) {
             ha_match = ha_curr;
             break;
         }
@@ -179,9 +179,9 @@
                                                              enum fw_cache_query_type type,
                                                              int query_daemon)
 {
-    int i;
+    int                              i;
     struct hip_hadb_user_info_state *this = NULL, *ha_match = NULL;
-    LHASH_NODE *item = NULL, *tmp = NULL;
+    LHASH_NODE                      *item = NULL, *tmp = NULL;
 
     if (type == FW_CACHE_HIT) {
         ha_match = hip_ht_find(firewall_cache_db, peer);
@@ -204,17 +204,16 @@
             ha_match = this;
             break;
         } else if (type == FW_CACHE_LSI &&
-            !ipv4_addr_cmp(peer, &this->lsi_peer) &&
-            (!local || !ipv4_addr_cmp(local, &this->lsi_our))) {
+                   !ipv4_addr_cmp(peer, &this->lsi_peer) &&
+                   (!local || !ipv4_addr_cmp(local, &this->lsi_our))) {
             ha_match = this;
             break;
         } else if (type == FW_CACHE_IP &&
-            !ipv6_addr_cmp(peer, &this->ip_peer) &&
-            (!local || !ipv6_addr_cmp(local, &this->ip_our))) {
+                   !ipv6_addr_cmp(peer, &this->ip_peer) &&
+                   (!local || !ipv6_addr_cmp(local, &this->ip_our))) {
             ha_match = this;
             break;
         }
-
     }
     HIP_UNLOCK_HT(&firewall_cache_db);
 
@@ -260,7 +259,7 @@
 static unsigned long hip_firewall_hash_hit_peer(const void *ptr)
 {
     const struct in6_addr *hit_peer = &((const struct hip_hadb_user_info_state *) ptr)->hit_peer;
-    uint8_t hash[HIP_AH_SHA_LEN];
+    uint8_t                hash[HIP_AH_SHA_LEN];
 
     hip_build_digest(HIP_DIGEST_SHA1, hit_peer, sizeof(*hit_peer), hash);
     return *((unsigned long *) hash);
@@ -305,9 +304,9 @@
  */
 void hip_firewall_cache_delete_hldb(int exiting)
 {
-    int i;
+    int                              i;
     struct hip_hadb_user_info_state *this = NULL;
-    LHASH_NODE *item = NULL, *tmp = NULL;
+    LHASH_NODE                      *item = NULL, *tmp = NULL;
 
     HIP_DEBUG("Start hldb delete\n");
     HIP_LOCK_HT(&firewall_cache_db);
@@ -324,8 +323,9 @@
      * we handle it in firewall_exit(). */
 
     HIP_UNLOCK_HT(&firewall_cache_db);
-    if (exiting)
+    if (exiting) {
         hip_ht_uninit(firewall_cache_db);
+    }
     HIP_DEBUG("End hldbdb delete\n");
 }
 
@@ -335,12 +335,12 @@
  * @param  hit_peer Peer HIT
  * @param state New state
  * @return 0 on success, negative on error
-*/
+ */
 int hip_firewall_cache_set_bex_state(const struct in6_addr *hit_our,
                                      const struct in6_addr *hit_peer,
                                      int state)
 {
-    int err = 0;
+    int                              err = 0;
     struct hip_hadb_user_info_state *entry;
 
     HIP_IFEL(!hit_peer, -1, "Need peer HIT to search\n");
@@ -372,7 +372,7 @@
                                     const struct in6_addr *hit_peer,
                                     int state)
 {
-    int err = 0;
+    int                              err = 0;
     struct hip_hadb_user_info_state *entry;
 
     HIP_IFEL(!ip_peer, -1, "Need peer IP to search\n");

=== modified file 'firewall/conntrack.c'
--- firewall/conntrack.c	2011-01-09 22:18:11 +0000
+++ firewall/conntrack.c	2011-01-11 14:04:40 +0000
@@ -84,8 +84,8 @@
     STATE_CLOSING
 };
 
-int timeoutChecking        = 0;
-unsigned long timeoutValue = 0;
+int           timeoutChecking = 0;
+unsigned long timeoutValue    = 0;
 
 /*------------print functions-------------*/
 /**
@@ -223,7 +223,7 @@
                                  const struct in6_addr *ip6_from)
 {
     struct dlist *list = (struct dlist *) hip_list;
-    hip_hit_t phit;
+    hip_hit_t     phit;
 
     HIP_DEBUG("updating opportunistic entries\n");
     /* the pseudo hit is compared with the hit in the entries */
@@ -259,7 +259,7 @@
                                       OPP const struct in6_addr *ip6_from)
 {
     struct hip_tuple *tuple = NULL;
-    struct dlist *list = hip_list;
+    struct dlist     *list  = hip_list;
 
     while (list) {
         tuple = list->data;
@@ -295,7 +295,7 @@
 static struct esp_address *get_esp_address(const struct slist *addr_list,
                                            const struct in6_addr *addr)
 {
-    const struct slist *list = addr_list;
+    const struct slist *list     = addr_list;
     struct esp_address *esp_addr = NULL;
 
     HIP_DEBUG("get_esp_address\n");
@@ -403,8 +403,8 @@
 struct esp_tuple *find_esp_tuple(const struct slist *search_list,
                                  const uint32_t spi)
 {
-    const struct slist *list = search_list;
-    struct esp_tuple *esp_tuple = NULL;
+    const struct slist *list      = search_list;
+    struct esp_tuple   *esp_tuple = NULL;
 
     if (!list) {
         HIP_DEBUG("Esp tuple slist is empty\n");
@@ -438,7 +438,7 @@
     //set time stamp
     gettimeofday(&connection->time_stamp, NULL);
 #ifdef HIP_CONFIG_MIDAUTH
-    connection->pisa_state                       = PISA_STATE_DISALLOW;
+    connection->pisa_state = PISA_STATE_DISALLOW;
 #endif
 
     //original direction tuple
@@ -491,7 +491,6 @@
 {
     if (hip_tuple) {
         if (hip_tuple->data) {
-
             // free keys depending on cipher
             if (hip_tuple->data->src_pub_key && hip_tuple->data->src_hi) {
                 if (hip_get_host_id_algo(hip_tuple->data->src_hi) == HIP_HI_RSA) {
@@ -520,7 +519,7 @@
 static void free_esp_tuple(struct esp_tuple *esp_tuple)
 {
     if (esp_tuple) {
-        struct slist *list       = esp_tuple->dst_addr_list;
+        struct slist       *list = esp_tuple->dst_addr_list;
         struct esp_address *addr = NULL;
 
         // remove eventual cached anchor elements for this esp tuple
@@ -565,9 +564,9 @@
 
             tuple->esp_tuples = remove_link_slist(tuple->esp_tuples, list);
             free_esp_tuple(list->data);
-            list->data        = NULL;
+            list->data = NULL;
             free(list);
-            list              = tuple->esp_tuples;
+            list = tuple->esp_tuples;
         }
         tuple->esp_tuples = NULL;
         tuple->connection = NULL;
@@ -623,9 +622,9 @@
                                                          const struct hip_seq *seq,
                                                          struct tuple *tuple)
 {
-    struct esp_tuple *new_esp                             = NULL;
+    struct esp_tuple                        *new_esp      = NULL;
     const struct hip_locator_info_addr_item *locator_addr = NULL;
-    int n                                                 = 0;
+    int                                      n            = 0;
 
     if (esp_info && locator && esp_info->new_spi == esp_info->old_spi) {
         HIP_DEBUG("esp_tuple_from_esp_info_locator: new spi 0x%lx\n", esp_info->new_spi);
@@ -634,8 +633,8 @@
         new_esp->spi   = ntohl(esp_info->new_spi);
         new_esp->tuple = tuple;
 
-        n              = (hip_get_param_total_len(locator) - sizeof(struct hip_locator)) /
-                         sizeof(struct hip_locator_info_addr_item);
+        n = (hip_get_param_total_len(locator) - sizeof(struct hip_locator)) /
+            sizeof(struct hip_locator_info_addr_item);
         HIP_DEBUG("esp_tuple_from_esp_info_locator: %d addresses in locator\n", n);
         if (n > 0) {
             locator_addr = (const struct hip_locator_info_addr_item *)
@@ -707,7 +706,7 @@
                                          const struct hip_seq *seq)
 {
     struct connection *connection = malloc(sizeof(struct connection));
-    struct esp_tuple *esp_tuple   = NULL;
+    struct esp_tuple  *esp_tuple  = NULL;
 
     esp_tuple = esp_tuple_from_esp_info_locator(esp_info, locator, seq,
                                                 &connection->reply);
@@ -716,9 +715,9 @@
         HIP_DEBUG("insert_connection_from_update: can't create connection\n");
         return 0;
     }
-    connection->state                             = STATE_ESTABLISHING_FROM_UPDATE;
+    connection->state = STATE_ESTABLISHING_FROM_UPDATE;
 #ifdef HIP_CONFIG_MIDAUTH
-    connection->pisa_state                        = PISA_STATE_DISALLOW;
+    connection->pisa_state = PISA_STATE_DISALLOW;
 #endif
 
     //original direction tuple
@@ -736,12 +735,12 @@
 
 
     //reply direction tuple
-    connection->reply.state                       = HIP_STATE_UNASSOCIATED;
-    connection->reply.direction                   = REPLY_DIR;
+    connection->reply.state     = HIP_STATE_UNASSOCIATED;
+    connection->reply.direction = REPLY_DIR;
 
-    connection->reply.esp_tuples                  = NULL;
-    connection->reply.esp_tuples                  = append_to_slist(connection->reply.esp_tuples,
-                                                                    esp_tuple);
+    connection->reply.esp_tuples = NULL;
+    connection->reply.esp_tuples = append_to_slist(connection->reply.esp_tuples,
+                                                   esp_tuple);
     insert_esp_tuple(esp_tuple);
 
     connection->reply.connection               = connection;
@@ -788,11 +787,11 @@
 static int hipfw_handle_relay_to_r2(const struct hip_common *common,
                                     const struct hip_fw_context *ctx)
 {
-    struct iphdr *iph = (struct iphdr *) ctx->ipq_packet->payload;
+    struct iphdr              *iph      = (struct iphdr *) ctx->ipq_packet->payload;
     const struct hip_relay_to *relay_to = NULL; /* same format as relay_from */
-    struct tuple *tuple, *reverse_tuple;
-    int err = 0;
-    uint32_t spi;
+    struct tuple              *tuple, *reverse_tuple;
+    int                        err = 0;
+    uint32_t                   spi;
     const struct hip_esp_info *esp_info;
 
     HIP_DEBUG_IN6ADDR("ctx->src", &ctx->src);
@@ -801,7 +800,7 @@
     HIP_ASSERT((hip_get_msg_type(common) == HIP_R2));
 
     HIP_IFEL(!(relay_to = hip_get_param(common, HIP_PARAM_RELAY_TO)), -1,
-            "No relay_to, skip\n");
+             "No relay_to, skip\n");
 
     HIP_DEBUG_IN6ADDR("relay_to_addr", &relay_to->address);
 
@@ -874,10 +873,10 @@
                      DBG int verify_responder,
                      UNUSED const struct hip_fw_context *ctx)
 {
-    struct in6_addr hit;
+    struct in6_addr           hit;
     const struct hip_host_id *host_id = NULL;
     // assume correct packet
-    int err = 1;
+    int         err = 1;
     hip_tlv_len len = 0;
 
     HIP_DEBUG("verify_responder: %i\n", verify_responder);
@@ -951,15 +950,15 @@
 static int handle_i2(struct hip_common *common, struct tuple *tuple,
                      const struct hip_fw_context *ctx)
 {
-    const struct hip_esp_info *spi     = NULL;
-    const struct slist *other_dir_esps = NULL;
-    const struct hip_host_id *host_id  = NULL;
-    struct tuple *other_dir            = NULL;
-    struct esp_tuple *esp_tuple        = NULL;
-    struct in6_addr hit;
+    const struct hip_esp_info *spi            = NULL;
+    const struct slist        *other_dir_esps = NULL;
+    const struct hip_host_id  *host_id        = NULL;
+    struct tuple              *other_dir      = NULL;
+    struct esp_tuple          *esp_tuple      = NULL;
+    struct in6_addr            hit;
     // assume correct packet
-    int err = 1;
-    hip_tlv_len len = 0;
+    int                    err     = 1;
+    hip_tlv_len            len     = 0;
     const struct in6_addr *ip6_src = &ctx->src;
 
     HIP_DEBUG("\n");
@@ -1032,9 +1031,9 @@
         esp_tuple->dst_addr_list = NULL;
         esp_tuple->dst_addr_list = update_esp_address(esp_tuple->dst_addr_list,
                                                       ip6_src, NULL);
-        esp_tuple->tuple         = other_dir;
+        esp_tuple->tuple = other_dir;
 
-        other_dir->esp_tuples    = append_to_slist(other_dir->esp_tuples, esp_tuple);
+        other_dir->esp_tuples = append_to_slist(other_dir->esp_tuples, esp_tuple);
 
         insert_esp_tuple(esp_tuple);
     }
@@ -1065,12 +1064,12 @@
 static int handle_r2(const struct hip_common *common, struct tuple *tuple,
                      const struct hip_fw_context *ctx)
 {
-    const struct hip_esp_info *spi    = NULL;
-    struct tuple *other_dir           = NULL;
-    struct slist *other_dir_esps      = NULL;
-    struct esp_tuple *esp_tuple       = NULL;
-    const struct in6_addr *ip6_src = &ctx->src;
-    int err                     = 1;
+    const struct hip_esp_info *spi            = NULL;
+    struct tuple              *other_dir      = NULL;
+    struct slist              *other_dir_esps = NULL;
+    struct esp_tuple          *esp_tuple      = NULL;
+    const struct in6_addr     *ip6_src        = &ctx->src;
+    int                        err            = 1;
 
     HIP_IFEL(!(spi = hip_get_param(common, HIP_PARAM_ESP_INFO)),
              0, "no spi found\n");
@@ -1103,7 +1102,7 @@
         esp_tuple->dst_addr_list = NULL;
         esp_tuple->dst_addr_list = update_esp_address(esp_tuple->dst_addr_list,
                                                       ip6_src, NULL);
-        esp_tuple->tuple         = other_dir;
+        esp_tuple->tuple = other_dir;
 
         insert_esp_tuple(esp_tuple);
 
@@ -1144,8 +1143,8 @@
                             struct esp_tuple *esp_tuple)
 {
     const struct hip_locator_info_addr_item *locator_addr = NULL;
-    int err                                               = 1;
-    int n                                                 = 0;
+    int                                      err          = 1;
+    int                                      n            = 0;
 
     HIP_DEBUG("\n");
 
@@ -1164,8 +1163,8 @@
         esp_tuple->new_spi       = ntohl(esp_info->new_spi);
         esp_tuple->spi_update_id = seq->update_id;
 
-        n                        = (hip_get_param_total_len(locator) - sizeof(struct hip_locator))
-                                   / sizeof(struct hip_locator_info_addr_item);
+        n = (hip_get_param_total_len(locator) - sizeof(struct hip_locator))
+            / sizeof(struct hip_locator_info_addr_item);
 
         if (n < 1) {
             HIP_DEBUG("no locator param found\n");
@@ -1212,7 +1211,7 @@
         }
 
         n = (hip_get_param_total_len(locator) - sizeof(struct hip_locator))
-                / sizeof(struct hip_locator_info_addr_item);
+            / sizeof(struct hip_locator_info_addr_item);
         HIP_DEBUG(" %d locator addresses\n", n);
 
         locator_addr = (const struct hip_locator_info_addr_item *)
@@ -1256,14 +1255,14 @@
                          struct tuple *tuple,
                          const struct hip_fw_context *ctx)
 {
-    const struct hip_seq *seq                = NULL;
-    const struct hip_esp_info *esp_info      = NULL;
-    const struct hip_ack *ack                = NULL;
-    const struct hip_locator *locator        = NULL;
-    const struct hip_spi *spi                = NULL;
-    struct tuple *other_dir_tuple            = NULL;
-    const struct in6_addr *ip6_src           = &ctx->src;
-    int err                                  = 1;
+    const struct hip_seq      *seq             = NULL;
+    const struct hip_esp_info *esp_info        = NULL;
+    const struct hip_ack      *ack             = NULL;
+    const struct hip_locator  *locator         = NULL;
+    const struct hip_spi      *spi             = NULL;
+    struct tuple              *other_dir_tuple = NULL;
+    const struct in6_addr     *ip6_src         = &ctx->src;
+    int                        err             = 1;
 
     /* get params from UPDATE message */
     seq      = hip_get_param(common, HIP_PARAM_SEQ);
@@ -1316,7 +1315,7 @@
             }
 
             /* we have to consider the src ip address in case of cascading NATs (see above FIXME) */
-            esp_tuple                   = esp_tuple_from_esp_info(esp_info, ip6_src, other_dir_tuple);
+            esp_tuple = esp_tuple_from_esp_info(esp_info, ip6_src, other_dir_tuple);
 
             other_dir_tuple->esp_tuples = append_to_slist(other_dir_esps,
                                                           esp_tuple);
@@ -1334,8 +1333,8 @@
         }
     } else {
         /* we already know this connection */
-        struct slist *other_dir_esps = NULL;
-        struct esp_tuple *esp_tuple  = NULL;
+        struct slist     *other_dir_esps = NULL;
+        struct esp_tuple *esp_tuple      = NULL;
 
         if (tuple->direction == ORIGINAL_DIR) {
             other_dir_tuple = &tuple->connection->reply;
@@ -1523,11 +1522,11 @@
                         struct hip_fw_context *ctx)
 {
 #ifdef CONFIG_HIP_OPPORTUNISTIC
-    hip_hit_t phit;
+    hip_hit_t       phit;
     struct in6_addr all_zero_addr;
 #endif
     struct in6_addr hit;
-    int err = 1;
+    int             err = 1;
 
     HIP_DEBUG("check packet: type %d \n", common->type_hdr);
 
@@ -1567,7 +1566,6 @@
         HIP_DEBUG("verifying signature...\n");
         if (tuple->hip_tuple->data->verify(tuple->hip_tuple->data->src_pub_key,
                                            common)) {
-
             HIP_INFO("Signature verification failed\n");
 
             err = 0;
@@ -1684,14 +1682,14 @@
  */
 int hipfw_relay_esp(const struct hip_fw_context *ctx)
 {
-    struct iphdr *iph = (struct iphdr *) ctx->ipq_packet->payload;
-    struct udphdr *udph = (struct udphdr *) ((uint8_t *) iph + iph->ihl * 4);
-    int len = ctx->ipq_packet->data_len - iph->ihl * 4;
-    struct slist *list = (struct slist *) esp_list;
-    struct tuple *tuple = NULL;
-    struct hip_esp *esp = ctx->transport_hdr.esp;
-    int err = 0;
-    uint32_t spi;
+    struct iphdr   *iph   = (struct iphdr *) ctx->ipq_packet->payload;
+    struct udphdr  *udph  = (struct udphdr *) ((uint8_t *) iph + iph->ihl * 4);
+    int             len   = ctx->ipq_packet->data_len - iph->ihl * 4;
+    struct slist   *list  = (struct slist *) esp_list;
+    struct tuple   *tuple = NULL;
+    struct hip_esp *esp   = ctx->transport_hdr.esp;
+    int             err   = 0;
+    uint32_t        spi;
 
     HIP_IFEL(!list, -1, "List is empty\n");
     HIP_IFEL((iph->protocol != IPPROTO_UDP), -1,
@@ -1734,7 +1732,7 @@
     HIP_DEBUG_IN6ADDR("esp_relay_addr", &tuple->esp_relay_daddr);
 
     udph->source = htons(HIP_NAT_UDP_PORT);
-    udph->dest = htons(tuple->esp_relay_dport);
+    udph->dest   = htons(tuple->esp_relay_dport);
     udph->check  = 0;
 
     HIP_DEBUG("Relaying packet\n");
@@ -1759,13 +1757,13 @@
  */
 int filter_esp_state(const struct hip_fw_context *ctx)
 {
-    const struct in6_addr *dst_addr = NULL;
-    const struct in6_addr *src_addr = NULL;
-    struct hip_esp *esp             = NULL;
-    struct tuple *tuple             = NULL;
-    struct esp_tuple *esp_tuple     = NULL;
+    const struct in6_addr *dst_addr  = NULL;
+    const struct in6_addr *src_addr  = NULL;
+    struct hip_esp        *esp       = NULL;
+    struct tuple          *tuple     = NULL;
+    struct esp_tuple      *esp_tuple = NULL;
     // don't accept packet with this rule by default
-    int err                         = 0;
+    int      err = 0;
     uint32_t spi;
 
     dst_addr = &ctx->dst;
@@ -1773,7 +1771,7 @@
     esp      = ctx->transport_hdr.esp;
 
     // needed to de-multiplex ESP traffic
-    spi      = ntohl(esp->esp_spi);
+    spi = ntohl(esp->esp_spi);
 
     // match packet against known connections
     HIP_DEBUG("filtering ESP packet against known connections...\n");
@@ -1839,13 +1837,13 @@
                  struct hip_common *buf, const struct state_option *option,
                  const int must_accept, struct hip_fw_context *ctx)
 {
-    struct hip_data *data = NULL;
-    struct tuple *tuple   = NULL;
+    struct hip_data *data  = NULL;
+    struct tuple    *tuple = NULL;
     // FIXME results in unsafe use in filter_hip()
-    int return_value      = -1; //invalid value
+    int return_value = -1;      //invalid value
 
     // get data form the buffer and put it in a new data structure
-    data  = get_hip_data(buf);
+    data = get_hip_data(buf);
     // look up the tuple in the database
     tuple = get_tuple_by_hip(data, buf->type_hdr, ip6_src);
     free(data);
@@ -1882,11 +1880,11 @@
     } else {
         if ((option->int_opt.value == CONN_ESTABLISHED && option->int_opt.boolean
              && !must_accept) || (option->int_opt.value == CONN_NEW &&
-                                 !option->int_opt.boolean && !must_accept)) {
+                                  !option->int_opt.boolean && !must_accept)) {
             remove_connection(tuple->connection);
             tuple->connection = NULL;
 
-            return_value      = 1;
+            return_value = 1;
             goto out_err;
         }
     }
@@ -1913,12 +1911,12 @@
               struct hip_common *buf,
               struct hip_fw_context *ctx)
 {
-    struct hip_data *data = NULL;
-    struct tuple *tuple   = NULL;
-    int verdict = 0;
+    struct hip_data *data    = NULL;
+    struct tuple    *tuple   = NULL;
+    int              verdict = 0;
 
     // convert to new data type
-    data  = get_hip_data(buf);
+    data = get_hip_data(buf);
     // look up tuple in the db
     tuple = get_tuple_by_hip(data, buf->type_hdr, ip6_src);
 

=== modified file 'firewall/dlist.c'
--- firewall/dlist.c	2011-01-06 17:03:31 +0000
+++ firewall/dlist.c	2011-01-11 14:04:40 +0000
@@ -108,6 +108,7 @@
     }
     return length;
 }
+
 #endif /* CONFIG_HIP_DEBUG */
 
 /**

=== modified file 'firewall/esp_prot_api.c'
--- firewall/esp_prot_api.c	2011-01-04 14:23:17 +0000
+++ firewall/esp_prot_api.c	2011-01-11 14:04:40 +0000
@@ -100,7 +100,7 @@
 // used hash lengths
 int hash_lengths[NUM_HASH_FUNCTIONS][NUM_HASH_LENGTHS];
 /* is used for hash chains and trees simultaneously used hash functions */
-hash_function hash_functions[NUM_HASH_FUNCTIONS] = {(hash_function) SHA1};
+hash_function hash_functions[NUM_HASH_FUNCTIONS] = { (hash_function) SHA1 };
 
 /********* internal settings (derived from config-file) *********/
 // lengths of the hash structures in the stores
@@ -127,12 +127,12 @@
                                       int *out_length,
                                       const struct hip_sa_entry *entry)
 {
-    int err          = 0, i, j;
-    int repeat       = 1;
-    int hash_length  = 0;
+    int      err         = 0, i, j;
+    int      repeat      = 1;
+    int      hash_length = 0;
     uint32_t chosen_el[num_linear_elements + num_random_elements];
-    uint32_t rand_el = 0;
-    int item_length  = 0;
+    uint32_t rand_el     = 0;
+    int      item_length = 0;
 
     HIP_ASSERT(ring_buffer_size >= num_linear_elements + num_random_elements);
 
@@ -159,7 +159,7 @@
         // then add randomly
         for (i = 0; i < num_random_elements; i++) {
             while (repeat) {
-                repeat  = 0;
+                repeat = 0;
 
                 // draw random element
                 RAND_bytes((unsigned char *) &rand_el, sizeof(uint32_t));
@@ -199,8 +199,8 @@
                                              const uint8_t transform)
 {
     struct esp_prot_tfm *prot_transform = NULL;
-    void *return_item                   = NULL;
-    int use_hash_trees = 0, err = 0;
+    void                *return_item    = NULL;
+    int                  use_hash_trees = 0, err = 0;
 
     HIP_ASSERT(item_anchor != NULL);
 
@@ -212,13 +212,13 @@
     }
 
     HIP_IFEL(!(return_item =
-            hcstore_get_item_by_anchor(&bex_store,
-                                       prot_transform->hash_func_id,
-                                       prot_transform->hash_length_id,
-                                       NUM_BEX_HIERARCHIES - 1,
-                                       item_anchor, use_hash_trees)),
-                                       -1,
-                                       "unable to retrieve hchain from bex store\n");
+                   hcstore_get_item_by_anchor(&bex_store,
+                                              prot_transform->hash_func_id,
+                                              prot_transform->hash_length_id,
+                                              NUM_BEX_HIERARCHIES - 1,
+                                              item_anchor, use_hash_trees)),
+             -1,
+             "unable to retrieve hchain from bex store\n");
 
     // refill bex-store if necessary
     HIP_IFEL((err = hcstore_refill(&bex_store, use_hash_trees)) < 0, -1,
@@ -247,12 +247,12 @@
  */
 int esp_prot_init(void)
 {
-    int bex_function_id    = 0, update_function_id = 0;
-    int bex_hash_length_id = 0, update_hash_length_id = 0;
-    int use_hash_trees     = 0;
-    int err                = 0, i, j, g;
-    int activate           = 1;
-    config_t *config       = NULL;
+    int       bex_function_id    = 0, update_function_id = 0;
+    int       bex_hash_length_id = 0, update_hash_length_id = 0;
+    int       use_hash_trees     = 0;
+    int       err                = 0, i, j, g;
+    int       activate           = 1;
+    config_t *config             = NULL;
 
     HIP_DEBUG("Initializing the esp protection extension...\n");
 
@@ -266,8 +266,8 @@
      * NOTE internal structure partially more flexible than interface provided by
      *      config-file */
     hash_lengths[NUM_HASH_FUNCTIONS - 1][NUM_HASH_LENGTHS - 1] = hash_length_g;
-    bex_hchain_length                                    = hash_structure_length;
-    update_hchain_lengths[NUM_UPDATE_HCHAIN_LENGTHS - 1] = hash_structure_length;
+    bex_hchain_length                                          = hash_structure_length;
+    update_hchain_lengths[NUM_UPDATE_HCHAIN_LENGTHS - 1]       = hash_structure_length;
 
     /* activate the extension in hipd
      *
@@ -280,10 +280,10 @@
     /* init the hash-chain stores */
     HIP_IFEL(hcstore_init(&bex_store, num_hchains_per_item,
                           refill_threshold), -1,
-                          "failed to initialize the bex-store\n");
+             "failed to initialize the bex-store\n");
     HIP_IFEL(hcstore_init(&update_store, num_hchains_per_item,
                           refill_threshold), -1,
-                          "failed to initialize the update-store\n");
+             "failed to initialize the update-store\n");
 
     HIP_DEBUG("setting up esp_prot_transforms...\n");
 
@@ -303,15 +303,15 @@
     for (i = 0; i < NUM_HASH_FUNCTIONS; i++) {
         // first we have to register the function
         HIP_IFEL((bex_function_id =
-                hcstore_register_function(&bex_store,
-                                          hash_functions[i])) < 0,
-                                          -1,
-                                          "failed to register hash-function in bex-store\n");
+                      hcstore_register_function(&bex_store,
+                                                hash_functions[i])) < 0,
+                 -1,
+                 "failed to register hash-function in bex-store\n");
         HIP_IFEL((update_function_id =
-                hcstore_register_function(&update_store,
-                                          hash_functions[i])) < 0,
-                                          -1,
-                                          "failed to register hash-function in update-store\n");
+                      hcstore_register_function(&update_store,
+                                                hash_functions[i])) < 0,
+                 -1,
+                 "failed to register hash-function in update-store\n");
 
         // ensure the 2 stores are in sync
         HIP_ASSERT(bex_function_id == update_function_id);
@@ -320,15 +320,15 @@
             if (hash_lengths[i][j] > 0) {
                 // now we can register the hash lengths for this function
                 HIP_IFEL((bex_hash_length_id =
-                        hcstore_register_hash_length(&bex_store,
-                                                     bex_function_id,
-                                                     hash_lengths[i][j])) < 0,
-                                                     -1,
-                                                     "failed to register hash-length in bex-store\n");
+                              hcstore_register_hash_length(&bex_store,
+                                                           bex_function_id,
+                                                           hash_lengths[i][j])) < 0,
+                         -1,
+                         "failed to register hash-length in bex-store\n");
                 HIP_IFEL((update_hash_length_id = hcstore_register_hash_length(
                               &update_store, update_function_id,
                               hash_lengths[i][j])) < 0, -1,
-                              "failed to register hash-length in update-store\n");
+                         "failed to register hash-length in update-store\n");
 
                 // ensure the 2 stores are in sync
                 HIP_ASSERT(bex_hash_length_id == update_hash_length_id);
@@ -336,36 +336,36 @@
                 // store these IDs in the transforms array
                 if (esp_prot_transforms[token_transform].is_used) {
                     esp_prot_transforms[token_transform].hash_func_id =
-                            bex_function_id;
+                        bex_function_id;
                     esp_prot_transforms[token_transform].hash_length_id =
-                            bex_hash_length_id;
+                        bex_hash_length_id;
                 }
 
                 /* also register the the hchain lengths for this function and this
                  * hash length */
                 HIP_IFEL(hcstore_register_hash_item_length(
-                        &bex_store, bex_function_id, bex_hash_length_id,
-                        bex_hchain_length) < 0, -1,
-                        "failed to register hchain-length in bex-store\n");
+                             &bex_store, bex_function_id, bex_hash_length_id,
+                             bex_hchain_length) < 0, -1,
+                         "failed to register hchain-length in bex-store\n");
 
                 /* register number of hierarchies in BEX-store */
                 HIP_IFEL(hcstore_register_hash_item_hierarchy(
-                        &bex_store, bex_function_id, bex_hash_length_id,
-                        bex_hchain_length, NUM_BEX_HIERARCHIES) < 0, -1,
-                        "failed to register hchain-hierarchy in bex-store\n");
+                             &bex_store, bex_function_id, bex_hash_length_id,
+                             bex_hchain_length, NUM_BEX_HIERARCHIES) < 0, -1,
+                         "failed to register hchain-hierarchy in bex-store\n");
 
                 for (g = 0; g < NUM_UPDATE_HCHAIN_LENGTHS; g++) {
                     HIP_IFEL(hcstore_register_hash_item_length(
-                            &update_store, update_function_id,
-                            update_hash_length_id,
-                            update_hchain_lengths[g]) < 0, -1,
-                            "failed to register hchain-length in update-store\n");
+                                 &update_store, update_function_id,
+                                 update_hash_length_id,
+                                 update_hchain_lengths[g]) < 0, -1,
+                             "failed to register hchain-length in update-store\n");
 
                     HIP_IFEL(hcstore_register_hash_item_hierarchy(
-                            &update_store, update_function_id,
-                            update_hash_length_id, update_hchain_lengths[g],
-                            num_hierarchies) < 0, -1,
-                            "failed to register hchain-hierarchy in update-store\n");
+                                 &update_store, update_function_id,
+                                 update_hash_length_id, update_hchain_lengths[g],
+                                 num_hierarchies) < 0, -1,
+                             "failed to register hchain-hierarchy in update-store\n");
                 }
             } else {
                 // for this hash-function we have already processed all hash-lengths
@@ -441,11 +441,11 @@
                           unsigned char (*esp_prot_anchors)[MAX_HASH_LENGTH],
                           const int update)
 {
-    int hash_length      = 0, err = 0;
-    int use_hash_trees   = 0;
-    struct hash_chain *hchain = NULL;
-    struct hash_tree  *htree  = NULL;
-    uint16_t i;
+    int                hash_length    = 0, err = 0;
+    int                use_hash_trees = 0;
+    struct hash_chain *hchain         = NULL;
+    struct hash_tree  *htree          = NULL;
+    uint16_t           i;
 
     HIP_ASSERT(entry != 0);
     HIP_ASSERT(entry->direction == 1 || entry->direction == 2);
@@ -470,7 +470,7 @@
             HIP_DEBUG("found matching esp prot transforms\n");
 
             // we have to get the hash_length
-            hash_length               = esp_prot_get_hash_length(esp_prot_transform);
+            hash_length = esp_prot_get_hash_length(esp_prot_transform);
 
             entry->update_item_length = hash_item_length;
 
@@ -486,14 +486,14 @@
 
                             HIP_IFEL(memcmp(&esp_prot_anchors[i][0],
                                             htree->root, hash_length), -1,
-                                            "received a non-matching root from hipd for next_hchain\n");
+                                     "received a non-matching root from hipd for next_hchain\n");
                         } else {
                             hchain = entry->next_hash_items[i];
 
                             HIP_IFEL(memcmp(&esp_prot_anchors[i][0],
                                             hchain_get_anchor(hchain),
                                             hash_length), -1,
-                                            "received a non-matching anchor from hipd for next_hchain\n");
+                                     "received a non-matching anchor from hipd for next_hchain\n");
                         }
 
                         entry->update_item_acked[i] = 1;
@@ -519,9 +519,9 @@
                     if (i < esp_num_anchors) {
                         HIP_IFEL(!(entry->active_hash_items[i] =
                                        esp_prot_get_bex_item_by_anchor(
-                                               &esp_prot_anchors[i][0],
-                                               esp_prot_transform)),
-                                       -1, "corresponding hchain not found\n");
+                                           &esp_prot_anchors[i][0],
+                                           esp_prot_transform)),
+                                 -1, "corresponding hchain not found\n");
                     } else {
                         entry->active_hash_items[i] = NULL;
                     }
@@ -579,7 +579,7 @@
 {
     struct esp_prot_tfm *prot_transform = NULL;
     hash_function        hash_func      = NULL;
-    int err                             = 0;
+    int                  err            = 0;
 
     HIP_IFEL(!(prot_transform = esp_prot_resolve_transform(transform)), 1,
              "tried to resolve UNUSED or UNKNOWN transform\n");
@@ -604,7 +604,7 @@
 int esp_prot_get_hash_length(const uint8_t transform)
 {
     struct esp_prot_tfm *prot_transform = NULL;
-    int err                             = 0;
+    int                  err            = 0;
 
     // return length 0 for UNUSED transform
     HIP_IFEL(!(prot_transform = esp_prot_resolve_transform(transform)), 0,
@@ -628,13 +628,13 @@
                                const uint16_t esp_length,
                                struct hip_sa_entry *entry)
 {
-    int err                 = 0;
-    hash_function hash_func = NULL;
-    int hash_length         = 0;
+    int           err         = 0;
+    hash_function hash_func   = NULL;
+    int           hash_length = 0;
 
     // check whether cumulative authentication is active
     if (entry->esp_prot_transform == ESP_PROT_TFM_CUMULATIVE ||
-            entry->esp_prot_transform == ESP_PROT_TFM_PARA_CUMUL) {
+        entry->esp_prot_transform == ESP_PROT_TFM_PARA_CUMUL) {
         hash_length = esp_prot_get_hash_length(entry->esp_prot_transform);
         hash_func   = esp_prot_get_hash_function(entry->esp_prot_transform);
 
@@ -665,13 +665,13 @@
 int esp_prot_add_hash(unsigned char *esp_packet, int *out_length,
                       struct hip_sa_entry *entry)
 {
-    const unsigned char *tmp_hash = NULL;
-    int err                       = 0;
-    uint32_t htree_index          = 0;
-    uint32_t htree_index_net      = 0;
-    struct hash_chain *hchain     = NULL;
-    struct hash_tree  *htree      = NULL;
-    int branch_length             = 0;
+    const unsigned char *tmp_hash        = NULL;
+    int                  err             = 0;
+    uint32_t             htree_index     = 0;
+    uint32_t             htree_index_net = 0;
+    struct hash_chain   *hchain          = NULL;
+    struct hash_tree    *htree           = NULL;
+    int                  branch_length   = 0;
 
     HIP_ASSERT(esp_packet != NULL);
     HIP_ASSERT(*out_length == 0);
@@ -693,39 +693,36 @@
                 memcpy(esp_packet, &htree_index_net, sizeof(uint32_t));
 
                 // get hash token and add it - only returns a reference into the array
-                tmp_hash        = htree_get_data(htree, htree_index,
-                                                 out_length);
+                tmp_hash = htree_get_data(htree, htree_index,
+                                          out_length);
                 memcpy(esp_packet + sizeof(uint32_t), tmp_hash, *out_length);
 
-                *out_length    += sizeof(uint32_t);
+                *out_length += sizeof(uint32_t);
 
                 // add the verification branch - directly memcpy elements into packet
                 HIP_IFEL(!htree_get_branch(htree, htree_index,
                                            esp_packet + *out_length,
                                            &branch_length), -1,
-                                           "failed to get verification branch\n");
+                         "failed to get verification branch\n");
 
                 *out_length += branch_length;
 
                 HIP_DEBUG("htree_index: %u\n", htree_index);
                 HIP_DEBUG("htree_index (packet): %u\n",
                           *(uint32_t *) esp_packet);
-
             } else {
                 HIP_DEBUG("htree depleted, dropping packet\n");
 
                 err = 1;
             }
-
         } else {
-
             if (token_transform == ESP_PROT_TFM_PARALLEL) {
                 hchain = entry->active_hash_items[entry->last_used_chain];
 
                 HIP_DEBUG("entry->last_used_chain: %i\n", entry->last_used_chain);
 
                 entry->last_used_chain =
-                        (entry->last_used_chain + 1) % num_parallel_hchains;
+                    (entry->last_used_chain + 1) % num_parallel_hchains;
             } else {
                 hchain = entry->active_hash_items[0];
             }
@@ -797,7 +794,7 @@
                                    const int next_root_length)
 {
     uint32_t tmp_distance = 0;
-    int err               = 0;
+    int      err          = 0;
 
     HIP_ASSERT(hash_func != NULL);
     HIP_ASSERT(hash_length > 0);
@@ -891,7 +888,7 @@
                                   const int next_uroot_length,
                                   const unsigned char *hash_value)
 {
-    int err             = 0;
+    int      err        = 0;
     uint32_t data_index = 0;
 
     HIP_ASSERT(hash_func != NULL);
@@ -968,7 +965,7 @@
     HIP_DEBUG("resolving transform: %u\n", transform);
 
     if (transform > ESP_PROT_TFM_UNUSED &&
-            esp_prot_transforms[transform].is_used) {
+        esp_prot_transforms[transform].is_used) {
         return &esp_prot_transforms[transform];
     } else {
         return NULL;
@@ -995,7 +992,7 @@
         offset += esp_prot_get_hash_length(entry->esp_prot_transform);
 
         if (entry->esp_prot_transform == ESP_PROT_TFM_CUMULATIVE
-                || entry->esp_prot_transform == ESP_PROT_TFM_PARA_CUMUL) {
+            || entry->esp_prot_transform == ESP_PROT_TFM_PARA_CUMUL) {
             offset += ((esp_prot_get_hash_length(entry->esp_prot_transform) + sizeof(uint32_t))
                        * (num_linear_elements + num_random_elements));
         }
@@ -1015,20 +1012,20 @@
  */
 int esp_prot_sadb_maintenance(struct hip_sa_entry *entry)
 {
-    int has_linked_anchor          = 0, soft_update = 1;
-    int err                        = 0;
-    int anchor_length              = 0;
-    int anchor_offset[MAX_NUM_PARALLEL_HCHAINS];
+    int                  has_linked_anchor = 0, soft_update = 1;
+    int                  err               = 0;
+    int                  anchor_length     = 0;
+    int                  anchor_offset[MAX_NUM_PARALLEL_HCHAINS];
     const unsigned char *anchors[MAX_NUM_PARALLEL_HCHAINS];
     struct esp_prot_tfm *prot_transform = NULL;
     struct hash_tree    *htree          = NULL;
     struct hash_chain   *hchain         = NULL;
-    struct hash_tree *link_trees[MAX_NUM_PARALLEL_HCHAINS];
-    int hash_item_length           = 0;
-    int remaining                  = 0, i, j;
-    int threshold                  = 0;
-    int use_hash_trees             = 0;
-    int hierarchy_level            = 0;
+    struct hash_tree    *link_trees[MAX_NUM_PARALLEL_HCHAINS];
+    int                  hash_item_length = 0;
+    int                  remaining        = 0, i, j;
+    int                  threshold        = 0;
+    int                  use_hash_trees   = 0;
+    int                  hierarchy_level  = 0;
 
     HIP_ASSERT(entry != NULL);
 
@@ -1041,14 +1038,14 @@
             htree            = entry->active_hash_items[0];
             hash_item_length = htree->num_data_blocks;
 
-            remaining        = htree_get_num_remaining(htree);
-            threshold        = htree->num_data_blocks * update_threshold;
+            remaining = htree_get_num_remaining(htree);
+            threshold = htree->num_data_blocks * update_threshold;
         } else {
             hchain           = entry->active_hash_items[0];
             hash_item_length = hchain->hchain_length;
 
-            remaining        = hchain_get_num_remaining(hchain);
-            threshold        = hchain->hchain_length * update_threshold;
+            remaining = hchain_get_num_remaining(hchain);
+            threshold = hchain->hchain_length * update_threshold;
         }
 
         /* ensure that the next hash-items are set up before the active ones
@@ -1074,8 +1071,8 @@
                 }
 
                 HIP_IFEL(!(prot_transform =
-                        esp_prot_resolve_transform(entry->esp_prot_transform)),
-                        1, "tried to resolve UNUSED transform\n");
+                               esp_prot_resolve_transform(entry->esp_prot_transform)),
+                         1, "tried to resolve UNUSED transform\n");
 
                 /* soft-update vs. PK-update
                  * -> do a soft-update */
@@ -1087,19 +1084,19 @@
                     while (htree_has_more_data(link_trees[i])) {
                         // get the next hchain from the link_tree
                         anchor_offset[i] =
-                                htree_get_next_data_offset(link_trees[i]);
-                        anchors[i]       =
-                                htree_get_data(link_trees[i], anchor_offset[i],
-                                               &anchor_length);
+                            htree_get_next_data_offset(link_trees[i]);
+                        anchors[i] =
+                            htree_get_data(link_trees[i], anchor_offset[i],
+                                           &anchor_length);
 
                         // set next_hash_item, if linked one is available
-                        if ((entry->next_hash_items[i]=
-                                hcstore_get_item_by_anchor(&update_store,
-                                                           prot_transform->hash_func_id,
-                                                           prot_transform->hash_length_id,
-                                                           hierarchy_level - 1,
-                                                           anchors[i],
-                                                           use_hash_trees))) {
+                        if ((entry->next_hash_items[i] =
+                                 hcstore_get_item_by_anchor(&update_store,
+                                                            prot_transform->hash_func_id,
+                                                            prot_transform->hash_length_id,
+                                                            hierarchy_level - 1,
+                                                            anchors[i],
+                                                            use_hash_trees))) {
                             HIP_DEBUG("linked hchain found in store, soft-update\n");
 
                             has_linked_anchor = 1;
@@ -1130,7 +1127,7 @@
 
                             /* and restart the loop
                              * NOTE continues results in i++ */
-                            i                = -1;
+                            i = -1;
 
                             continue;
                         }
@@ -1145,10 +1142,10 @@
                      *       hchain lengths
                      */
                     HIP_IFEL(!(entry->next_hash_items[i] =
-                            hcstore_get_hash_item(&update_store,
-                                                  prot_transform->hash_func_id,
-                                                  prot_transform->hash_length_id,
-                                                  update_hchain_lengths[DEFAULT_HCHAIN_LENGTH_ID])),
+                                   hcstore_get_hash_item(&update_store,
+                                                         prot_transform->hash_func_id,
+                                                         prot_transform->hash_length_id,
+                                                         update_hchain_lengths[DEFAULT_HCHAIN_LENGTH_ID])),
                              -1, "unable to retrieve hchain from store\n");
 
                     if (use_hash_trees) {
@@ -1168,7 +1165,7 @@
             HIP_IFEL(send_trigger_update_to_hipd(entry, anchors,
                                                  hash_item_length, soft_update,
                                                  anchor_offset, link_trees), -1,
-                                                 "unable to trigger update at hipd\n");
+                     "unable to trigger update at hipd\n");
 
             // refill update-store
             HIP_IFEL((err = hcstore_refill(&update_store, use_hash_trees)) < 0, -1,
@@ -1177,7 +1174,7 @@
 
         /* activate next hchains if current ones are depleted and update has been acked
          * -> assume first hchain represents all parallel ones */
-        if (entry->next_hash_items[0] && entry->update_item_acked[0]&& remaining == 0) {
+        if (entry->next_hash_items[0] && entry->update_item_acked[0] && remaining == 0) {
             for (i = 0; i < num_parallel_hchains; i++) {
                 // this will free all linked elements in the hchain
                 if (use_hash_trees) {

=== modified file 'firewall/esp_prot_api.h'
--- firewall/esp_prot_api.h	2011-01-04 14:23:17 +0000
+++ firewall/esp_prot_api.h	2011-01-11 14:04:40 +0000
@@ -55,19 +55,19 @@
 };
 
 
-extern int token_transform;
-extern int num_parallel_hchains;
-extern int ring_buffer_size;
-extern int num_linear_elements;
-extern int num_random_elements;
-extern int hash_length_g;
-extern int hash_structure_length;
-extern int num_hchains_per_item;
-extern int num_hierarchies;
+extern int    token_transform;
+extern int    num_parallel_hchains;
+extern int    ring_buffer_size;
+extern int    num_linear_elements;
+extern int    num_random_elements;
+extern int    hash_length_g;
+extern int    hash_structure_length;
+extern int    num_hchains_per_item;
+extern int    num_hierarchies;
 extern double refill_threshold;
 extern double update_threshold;
 
-extern int hash_lengths[NUM_HASH_FUNCTIONS][NUM_HASH_LENGTHS];
+extern int           hash_lengths[NUM_HASH_FUNCTIONS][NUM_HASH_LENGTHS];
 extern hash_function hash_functions[NUM_HASH_FUNCTIONS];
 
 int esp_prot_init(void);

=== modified file 'firewall/esp_prot_config.c'
--- firewall/esp_prot_config.c	2010-10-15 15:29:14 +0000
+++ firewall/esp_prot_config.c	2011-01-11 14:04:40 +0000
@@ -46,23 +46,23 @@
 #include "config.h"
 
 
-const char *config_file                = HIPL_SYSCONFDIR "/esp_prot_config.cfg";
+const char *config_file = HIPL_SYSCONFDIR "/esp_prot_config.cfg";
 
 const char *path_hash_length           = "token_config.hash_length";
 const char *path_hash_structure_length = "token_config.hash_structure_length";
 const char *path_token_transform       = "token_config.token_transform";
 
-const char *path_num_parallel_hchains  = "token_config.token_modes.num_parallel_hchains";
-const char *path_ring_buffer_size      = "token_config.token_modes.ring_buffer_size";
-const char *path_num_linear_elements   = "token_config.token_modes.num_linear_elements";
-const char *path_num_random_elements   = "token_config.token_modes.num_random_elements";
-
-const char *path_num_hchains_per_item  = "sender.hcstore.num_hchains_per_item";
-const char *path_num_hierarchies       = "sender.hcstore.num_hierarchies";
-const char *path_refill_threshold      = "sender.hcstore.refill_threshold";
-const char *path_update_threshold      = "sender.update_threshold";
-
-const char *path_window_size           = "verifier.window_size";
+const char *path_num_parallel_hchains = "token_config.token_modes.num_parallel_hchains";
+const char *path_ring_buffer_size     = "token_config.token_modes.ring_buffer_size";
+const char *path_num_linear_elements  = "token_config.token_modes.num_linear_elements";
+const char *path_num_random_elements  = "token_config.token_modes.num_random_elements";
+
+const char *path_num_hchains_per_item = "sender.hcstore.num_hchains_per_item";
+const char *path_num_hierarchies      = "sender.hcstore.num_hierarchies";
+const char *path_refill_threshold     = "sender.hcstore.refill_threshold";
+const char *path_update_threshold     = "sender.update_threshold";
+
+const char *path_window_size = "verifier.window_size";
 
 #ifdef HAVE_LIBCONFIG
 /**
@@ -84,10 +84,10 @@
  * libconfig 1.4, remove the ugly workaround below accordingly. See #134. */
 #if defined LIBCONFIG_VER_MAJOR && defined LIBCONFIG_VER_MINOR && (((LIBCONFIG_VER_MAJOR == 1) && (LIBCONFIG_VER_MINOR >= 4)) || (LIBCONFIG_VER_MAJOR > 1))
     /* libconfig version 1.4 and later */
-    int value   = 0;
+    int value = 0;
 #else
     /* libconfig version before 1.4 */
-    long value  = 0;
+    long value = 0;
 #endif
 
     int success = config_lookup_int(cfg, name, &value);
@@ -97,6 +97,7 @@
     }
     return success;
 }
+
 #endif /* HAVE_LIBCONFIG */
 
 /**
@@ -112,7 +113,7 @@
  *
  * FIXME this should be removed once we go tiny */
 #ifdef HAVE_LIBCONFIG
-    int err       = 0;
+    int err = 0;
 
     HIP_IFEL(!(cfg = malloc(sizeof(config_t))), -1,
              "Unable to allocate memory!\n");
@@ -164,7 +165,6 @@
     int err = 0;
 
     if (cfg) {
-
 #ifdef HAVE_LIBCONFIG
         // process parallel hchains-related settings
         if (!esp_prot_wrap_config_lookup_int(cfg, path_token_transform,
@@ -198,9 +198,9 @@
                 num_parallel_hchains = 2;
             }
 
-            ring_buffer_size     = 0;
-            num_linear_elements  = 0;
-            num_random_elements  = 0;
+            ring_buffer_size    = 0;
+            num_linear_elements = 0;
+            num_random_elements = 0;
 
             break;
         case ESP_PROT_TFM_CUMULATIVE:
@@ -263,7 +263,6 @@
         err = -1;
         goto out_err;
 #endif /* HAVE_LIBCONFIG */
-
     } else {
         HIP_ERROR("no configuration file available\n");
 
@@ -306,7 +305,6 @@
     int err = 0;
 
     if (cfg) {
-
 #ifdef HAVE_LIBCONFIG
         // process hcstore-related settings
         if (!esp_prot_wrap_config_lookup_int(cfg, path_num_hchains_per_item,
@@ -335,7 +333,6 @@
         err = -1;
         goto out_err;
 #endif /* HAVE_LIBCONFIG */
-
     } else {
         HIP_ERROR("no configuration file available\n");
 
@@ -389,7 +386,6 @@
         err = -1;
         goto out_err;
 #endif /* HAVE_LIBCONFIG */
-
     } else {
         HIP_ERROR("no configuration file available\n");
 

=== modified file 'firewall/esp_prot_conntrack.c'
--- firewall/esp_prot_conntrack.c	2011-01-09 22:18:11 +0000
+++ firewall/esp_prot_conntrack.c	2011-01-11 14:04:40 +0000
@@ -59,9 +59,9 @@
 
 
 struct esp_prot_conntrack_tfm {
-    hash_function   hash_function;     /* pointer to the hash function */
-    int             hash_length; /* hash length for this transform */
-    int             is_used; /* needed as complete transform array is initialized */
+    hash_function hash_function;       /* pointer to the hash function */
+    int           hash_length;   /* hash length for this transform */
+    int           is_used;   /* needed as complete transform array is initialized */
 };
 
 /* cached anchor element updates */
@@ -108,7 +108,7 @@
 static void esp_prot_conntrack_free_cached_item(void *cache_item)
 {
     struct esp_anchor_item *anchor_item = NULL;
-    long i;
+    long                    i;
 
     if (cache_item) {
         anchor_item = cache_item;
@@ -137,7 +137,7 @@
 {
     struct esp_tuple *esp_tuple = NULL;
     struct slist     *list      = NULL;
-    int err                     = 0;
+    int               err       = 0;
 
     HIP_DEBUG("\n");
 
@@ -194,8 +194,8 @@
     struct esp_tuple              *esp_tuple     = NULL;
     struct esp_prot_conntrack_tfm *conntrack_tfm = NULL;
     unsigned char                 *cmp_value     = NULL;
-    int hash_length = 0, err = 0;
-    long i;
+    int                            hash_length   = 0, err = 0;
+    long                           i;
 
     HIP_DEBUG("\n");
 
@@ -208,10 +208,10 @@
     // needed for allocating and copying the anchors
     conntrack_tfm = esp_prot_conntrack_resolve_transform(
         esp_anchors[0]->transform);
-    hash_length   = conntrack_tfm->hash_length;
+    hash_length = conntrack_tfm->hash_length;
 
     HIP_IFEL(!(esp_tuple = esp_prot_conntrack_find_esp_tuple(
-            tuple, &esp_anchors[0]->anchors[0], hash_length)), -1,
+                   tuple, &esp_anchors[0]->anchors[0], hash_length)), -1,
              "failed to look up matching esp_tuple\n");
 
     HIP_IFEL(!(anchor_item = calloc(1, sizeof(struct esp_anchor_item))), -1,
@@ -297,12 +297,12 @@
     struct tuple                  *other_dir_tuple = NULL;
     struct esp_tuple              *esp_tuple       = NULL;
     struct esp_prot_conntrack_tfm *conntrack_tfm   = NULL;
-    int hash_length                         = 0;
+    int                            hash_length     = 0;
     // assume not found
-    int err                                 = 0;
-    unsigned  element_index                 = 0;
-    int found                               = 0;
-    long i;
+    int      err           = 0;
+    unsigned element_index = 0;
+    int      found         = 0;
+    long     i;
 
     HIP_DEBUG("\n");
 
@@ -327,9 +327,8 @@
     HIP_DEBUG("received ack: %u\n", ntohl(ack->peer_update_id));
 
     for (element_index = 0;
-            element_index < hip_ll_get_size(&esp_tuple->anchor_cache);
-            element_index++) {
-
+         element_index < hip_ll_get_size(&esp_tuple->anchor_cache);
+         element_index++) {
         HIP_IFEL(!(anchor_item = hip_ll_get(&esp_tuple->anchor_cache,
                                             element_index)),
                  -1, "failed to look up anchor_item\n");
@@ -348,7 +347,7 @@
         // needed for allocating and copying the anchors
         conntrack_tfm = esp_prot_conntrack_resolve_transform(
             esp_tuple->esp_prot_tfm);
-        hash_length = conntrack_tfm->hash_length;
+        hash_length                 = conntrack_tfm->hash_length;
         esp_tuple->hash_item_length = anchor_item->hash_item_length;
 
         for (i = 0; i < esp_tuple->num_hchains; i++) {
@@ -416,11 +415,11 @@
 {
     struct esp_prot_conntrack_tfm *conntrack_tfm = NULL;
     struct esp_tuple              *esp_tuple     = NULL;
-    int hash_length                         = 0;
-    int err                                 = 0;
-    int i                                   = 0;
-    uint32_t branch_length                  = 0;
-    uint32_t anchor_offset                  = 0;
+    int                            hash_length   = 0;
+    int                            err           = 0;
+    int                            i             = 0;
+    uint32_t                       branch_length = 0;
+    uint32_t                       anchor_offset = 0;
 
     HIP_DEBUG("\n");
 
@@ -431,13 +430,13 @@
 
     // needed for allocating and copying the anchors
     conntrack_tfm = esp_prot_conntrack_resolve_transform(
-            esp_anchors[0]->transform);
+        esp_anchors[0]->transform);
     hash_length = conntrack_tfm->hash_length;
 
     HIP_IFEL(!(esp_tuple = esp_prot_conntrack_find_esp_tuple(
-                                tuple, &esp_anchors[0]->anchors[0],
-                                hash_length)),
-            -1, "failed to look up matching esp_tuple\n");
+                   tuple, &esp_anchors[0]->anchors[0],
+                   hash_length)),
+             -1, "failed to look up matching esp_tuple\n");
 
     for (i = 0; i < esp_tuple->num_hchains; i++) {
         branch_length = ntohl(esp_branches[i]->branch_length);
@@ -457,7 +456,6 @@
                                  htree_node_generator,
                                  NULL)) {
             HIP_DEBUG("anchor verified\n");
-
         } else {
             HIP_DEBUG("failed to verify branch!\n");
 
@@ -477,7 +475,7 @@
 int esp_prot_conntrack_init(void)
 {
     config_t *config = NULL;
-    int err          = 0, i, j;
+    int       err    = 0, i, j;
 
     HIP_DEBUG("Initializing conntracking of esp protection extension...\n");
 
@@ -511,9 +509,9 @@
 
                 if (esp_prot_conntrack_tfms[token_transform].is_used) {
                     esp_prot_conntrack_tfms[token_transform].hash_function =
-                            hash_functions[i];
+                        hash_functions[i];
                     esp_prot_conntrack_tfms[token_transform].hash_length =
-                            hash_lengths[i][j];
+                        hash_lengths[i][j];
                 }
             }
         }
@@ -550,7 +548,7 @@
                                const struct tuple *tuple)
 {
     const struct esp_prot_preferred_tfms *prot_transforms = NULL;
-    int err                                               = 0, i;
+    int                                   err             = 0, i;
 
     if (hip_esp_protection) {
         // initialize the ESP protection params in the connection
@@ -610,9 +608,9 @@
     const struct esp_prot_anchor  *prot_anchor   = NULL;
     struct esp_tuple              *esp_tuple     = NULL;
     struct esp_prot_conntrack_tfm *conntrack_tfm = NULL;
-    long i                                    = 0;
-    int hash_length                           = 0;
-    int err                                   = 0;
+    long                           i             = 0;
+    int                            hash_length   = 0;
+    int                            err           = 0;
 
     if (hip_esp_protection) {
         HIP_ASSERT(common != NULL);
@@ -646,7 +644,7 @@
                 HIP_DEBUG("using esp prot transform: %u\n", esp_tuple->esp_prot_tfm);
 
                 if (esp_tuple->esp_prot_tfm > ESP_PROT_TFM_UNUSED) {
-                    conntrack_tfm               = esp_prot_conntrack_resolve_transform(
+                    conntrack_tfm = esp_prot_conntrack_resolve_transform(
                         esp_tuple->esp_prot_tfm);
                     hash_length                 = conntrack_tfm->hash_length;
                     esp_tuple->hash_item_length = ntohl(prot_anchor->hash_item_length);
@@ -726,7 +724,7 @@
 struct esp_tuple *esp_prot_conntrack_R2_esp_tuple(const struct slist *other_dir_esps)
 {
     struct esp_tuple *esp_tuple = NULL;
-    int err                     = 0;
+    int               err       = 0;
 
     if (hip_esp_protection) {
         /* normally there should NOT be any esp_tuple for the other direction yet,
@@ -767,9 +765,9 @@
     const struct esp_prot_anchor  *prot_anchor   = NULL;
     struct esp_tuple              *esp_tuple     = NULL;
     struct esp_prot_conntrack_tfm *conntrack_tfm = NULL;
-    long i                                    = 0;
-    int hash_length                           = 0;
-    int err                                   = 0;
+    long                           i             = 0;
+    int                            hash_length   = 0;
+    int                            err           = 0;
 
     if (hip_esp_protection) {
         HIP_ASSERT(common != NULL);
@@ -794,9 +792,9 @@
                 HIP_DEBUG("using esp prot transform: %u\n", esp_tuple->esp_prot_tfm);
 
                 if (esp_tuple->esp_prot_tfm > ESP_PROT_TFM_UNUSED) {
-                    conntrack_tfm               = esp_prot_conntrack_resolve_transform(
+                    conntrack_tfm = esp_prot_conntrack_resolve_transform(
                         esp_tuple->esp_prot_tfm);
-                    hash_length                 = conntrack_tfm->hash_length;
+                    hash_length = conntrack_tfm->hash_length;
 
                     esp_tuple->hash_item_length = ntohl(prot_anchor->hash_item_length);
 
@@ -867,14 +865,14 @@
 int esp_prot_conntrack_update(const struct hip_common *update,
                               const struct tuple *tuple)
 {
-    const struct hip_tlv_common *param  = NULL;
-    const struct hip_seq *seq           = NULL;
-    const struct hip_ack *ack           = NULL;
-    const struct hip_esp_info *esp_info = NULL;
+    const struct hip_tlv_common  *param    = NULL;
+    const struct hip_seq         *seq      = NULL;
+    const struct hip_ack         *ack      = NULL;
+    const struct hip_esp_info    *esp_info = NULL;
     const struct esp_prot_anchor *esp_anchors[MAX_NUM_PARALLEL_HCHAINS];
-    const struct esp_prot_root *esp_roots[MAX_NUM_PARALLEL_HCHAINS];
-    int err                       = 0;
-    long i                        = 0;
+    const struct esp_prot_root   *esp_roots[MAX_NUM_PARALLEL_HCHAINS];
+    int                           err = 0;
+    long                          i   = 0;
 
     if (hip_esp_protection) {
         HIP_ASSERT(update != NULL);
@@ -887,7 +885,7 @@
         esp_info = hip_get_param(update, HIP_PARAM_ESP_INFO);
         ack      = hip_get_param(update, HIP_PARAM_ACK);
         // there might be several anchor elements
-        param    = hip_get_param(update, HIP_PARAM_ESP_PROT_ANCHOR);
+        param = hip_get_param(update, HIP_PARAM_ESP_PROT_ANCHOR);
 
         // distinguish packet types and process accordingly
         if (seq && !ack && !esp_info && param) {
@@ -897,7 +895,7 @@
             for (i = 0; i < num_parallel_hchains; i++) {
                 esp_anchors[i] = (const struct esp_prot_anchor *) param;
 
-                param          = hip_get_next_param(update, param);
+                param = hip_get_next_param(update, param);
             }
 
             param = hip_get_param(update, HIP_PARAM_ESP_PROT_ROOT);
@@ -906,7 +904,7 @@
                 for (i = 0; i < num_parallel_hchains; i++) {
                     esp_roots[i] = (const struct esp_prot_root *) param;
 
-                    param        = hip_get_next_param(update, param);
+                    param = hip_get_next_param(update, param);
                 }
             }
 
@@ -974,18 +972,18 @@
                                struct tuple *tuple,
                                const struct hip_fw_context *ctx)
 {
-    const struct hip_seq *seq          = NULL;
-    const struct hip_tlv_common *param = NULL;
+    const struct hip_seq         *seq   = NULL;
+    const struct hip_tlv_common  *param = NULL;
     const struct esp_prot_anchor *esp_anchors[MAX_NUM_PARALLEL_HCHAINS];
     const struct esp_prot_branch *esp_branches[MAX_NUM_PARALLEL_HCHAINS];
     const struct esp_prot_secret *esp_secrets[MAX_NUM_PARALLEL_HCHAINS];
-    const struct esp_prot_root *esp_roots[MAX_NUM_PARALLEL_HCHAINS];
-    const struct hip_ack *ack           = NULL;
-    const struct hip_esp_info *esp_info = NULL;
-    const struct in6_addr *ip6_src = &ctx->src;
-    const struct in6_addr *ip6_dst = &ctx->dst;
-    int err                       = 0;
-    long i;
+    const struct esp_prot_root   *esp_roots[MAX_NUM_PARALLEL_HCHAINS];
+    const struct hip_ack         *ack      = NULL;
+    const struct hip_esp_info    *esp_info = NULL;
+    const struct in6_addr        *ip6_src  = &ctx->src;
+    const struct in6_addr        *ip6_dst  = &ctx->dst;
+    int                           err      = 0;
+    long                          i;
 
     if (hip_esp_protection) {
         HIP_ASSERT(ip6_src != NULL);
@@ -1006,21 +1004,21 @@
             for (i = 0; i < num_parallel_hchains; i++) {
                 esp_anchors[i] = (const struct esp_prot_anchor *) param;
 
-                param          = hip_get_next_param(common, param);
+                param = hip_get_next_param(common, param);
             }
 
             param = hip_get_param(common, HIP_PARAM_ESP_PROT_BRANCH);
             for (i = 0; i < num_parallel_hchains; i++) {
                 esp_branches[i] = (const struct esp_prot_branch *) param;
 
-                param           = hip_get_next_param(common, param);
+                param = hip_get_next_param(common, param);
             }
 
             param = hip_get_param(common, HIP_PARAM_ESP_PROT_SECRET);
             for (i = 0; i < num_parallel_hchains; i++) {
                 esp_secrets[i] = (const struct esp_prot_secret *) param;
 
-                param          = hip_get_next_param(common, param);
+                param = hip_get_next_param(common, param);
             }
 
             param = hip_get_param(common, HIP_PARAM_ESP_PROT_ROOT);
@@ -1028,7 +1026,7 @@
                 for (i = 0; i < num_parallel_hchains; i++) {
                     esp_roots[i] = (const struct esp_prot_root *) param;
 
-                    param        = hip_get_next_param(common, param);
+                    param = hip_get_next_param(common, param);
                 }
             } else {
                 memset(esp_roots, 0, MAX_NUM_PARALLEL_HCHAINS * sizeof(struct esp_prot_root *));
@@ -1052,7 +1050,7 @@
             // verify tree
             HIP_IFEL(esp_prot_conntrack_verify_branch(tuple, esp_anchors, esp_branches,
                                                       esp_secrets), -1,
-                                                      "failed to verify branch\n");
+                     "failed to verify branch\n");
 
             // cache update_anchor and root
             HIP_IFEL(esp_prot_conntrack_cache_anchor(tuple, seq, esp_anchors, esp_roots), -1,
@@ -1090,17 +1088,17 @@
     struct hip_esp                *esp            = NULL;
     struct esp_cumulative_item    *cached_element = NULL;
     struct esp_cumulative_item    *cumulative_ptr = NULL;
-    unsigned char packet_hash[MAX_HASH_LENGTH];
-    int esp_len = 0, use_hash_trees = 0, active_hchain = 0, err = 0, i;
-    uint32_t num_verify = 0, current_seq = 0;
+    unsigned char                  packet_hash[MAX_HASH_LENGTH];
+    int                            esp_len    = 0, use_hash_trees = 0, active_hchain = 0, err = 0, i;
+    uint32_t                       num_verify = 0, current_seq = 0;
 
     if (hip_esp_protection) {
         if (esp_tuple->esp_prot_tfm > ESP_PROT_TFM_UNUSED) {
             conntrack_tfm = esp_prot_conntrack_resolve_transform(
                 esp_tuple->esp_prot_tfm);
 
-            esp           = ctx->transport_hdr.esp;
-            esp_len       = ctx->ipq_packet->data_len - ctx->ip_hdr_len;
+            esp     = ctx->transport_hdr.esp;
+            esp_len = ctx->ipq_packet->data_len - ctx->ip_hdr_len;
             if (ctx->udp_encap_hdr) {
                 esp_len -= sizeof(struct udphdr);
             }
@@ -1136,7 +1134,7 @@
                 /* calculate difference of SEQ no in order to determine how many hashes
                  * we have to calculate */
                 if (ntohl(esp->esp_seq) - esp_tuple->seq_no > 0 &&
-                    ntohl(esp->esp_seq) - esp_tuple->seq_no <= (unsigned)window_size) {
+                    ntohl(esp->esp_seq) - esp_tuple->seq_no <= (unsigned) window_size) {
                     HIP_DEBUG("seq number within verification window\n");
 
                     num_verify = ntohl(esp->esp_seq) - esp_tuple->seq_no;
@@ -1224,10 +1222,10 @@
                            conntrack_tfm->hash_length);
                 } else {
                     // don't copy the next anchor, but the already verified hash
-                    memcpy( &esp_tuple->active_anchors[active_hchain][0], ((unsigned char *) esp) + sizeof(struct hip_esp),
-                            conntrack_tfm->hash_length);
-                    memcpy( &esp_tuple->first_active_anchors[active_hchain][0],  &esp_tuple->next_anchors[active_hchain][0],
-                            conntrack_tfm->hash_length);
+                    memcpy(&esp_tuple->active_anchors[active_hchain][0], ((unsigned char *) esp) + sizeof(struct hip_esp),
+                           conntrack_tfm->hash_length);
+                    memcpy(&esp_tuple->first_active_anchors[active_hchain][0],  &esp_tuple->next_anchors[active_hchain][0],
+                           conntrack_tfm->hash_length);
                 }
 
                 // change roots

=== modified file 'firewall/esp_prot_fw_msg.c'
--- firewall/esp_prot_fw_msg.c	2011-01-06 17:05:42 +0000
+++ firewall/esp_prot_fw_msg.c	2011-01-11 14:04:40 +0000
@@ -68,14 +68,14 @@
 static struct hip_common *create_bex_store_update_msg(struct hchain_store *hcstore,
                                                       const int use_hash_trees)
 {
-    struct hip_common   *msg       = NULL;
-    struct esp_prot_tfm *transform = NULL;
-    struct hash_chain   *hchain    = NULL;
-    struct hash_tree    *htree     = NULL;
-    unsigned char *anchor     = NULL;
-    unsigned  j               = 0;
-    uint8_t i                 = 0;
-    int hash_length = 0, num_hchains = 0, err = 0, hash_item_length = 0;
+    struct hip_common   *msg         = NULL;
+    struct esp_prot_tfm *transform   = NULL;
+    struct hash_chain   *hchain      = NULL;
+    struct hash_tree    *htree       = NULL;
+    unsigned char       *anchor      = NULL;
+    unsigned             j           = 0;
+    uint8_t              i           = 0;
+    int                  hash_length = 0, num_hchains = 0, err = 0, hash_item_length = 0;
 
     HIP_ASSERT(hcstore != NULL);
 
@@ -185,10 +185,10 @@
  */
 int send_esp_prot_to_hipd(const int activate)
 {
-    struct hip_common *msg = NULL;
-    int num_transforms     = 0;
-    int err                = 0, i;
-    uint8_t transform      = 0;
+    struct hip_common *msg            = NULL;
+    int                num_transforms = 0;
+    int                err            = 0, i;
+    uint8_t            transform      = 0;
 
     HIP_ASSERT(activate >= 0);
 
@@ -285,7 +285,7 @@
                                   const int use_hash_trees)
 {
     struct hip_common *msg = NULL;
-    int err                = 0;
+    int                err = 0;
 
     HIP_ASSERT(hcstore != NULL);
 
@@ -328,19 +328,19 @@
                                 const int *anchor_offset,
                                 struct hash_tree *link_trees[MAX_NUM_PARALLEL_HCHAINS])
 {
-    int err                     = 0;
-    int i                       = 0;
-    struct hip_common *msg      = NULL;
-    int hash_length             = 0;
-    struct hash_chain *hchain   = NULL;
-    struct hash_tree *htree     = NULL;
-    struct hash_tree *link_tree = NULL;
-    int secret_length           = 0;
-    int branch_length           = 0;
-    int root_length             = 0;
-    const unsigned char *secret = NULL;
-    unsigned char *branch_nodes = NULL;
-    const unsigned char *root   = NULL;
+    int                  err           = 0;
+    int                  i             = 0;
+    struct hip_common   *msg           = NULL;
+    int                  hash_length   = 0;
+    struct hash_chain   *hchain        = NULL;
+    struct hash_tree    *htree         = NULL;
+    struct hash_tree    *link_tree     = NULL;
+    int                  secret_length = 0;
+    int                  branch_length = 0;
+    int                  root_length   = 0;
+    const unsigned char *secret        = NULL;
+    unsigned char       *branch_nodes  = NULL;
+    const unsigned char *root          = NULL;
 
     HIP_ASSERT(entry != NULL);
 
@@ -358,17 +358,17 @@
     HIP_DEBUG_HIT("src_hit", &entry->inner_src_addr);
     HIP_IFEL(hip_build_param_contents(msg, &entry->inner_src_addr,
                                       HIP_PARAM_HIT, sizeof(struct in6_addr)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     HIP_DEBUG_HIT("dst_hit", &entry->inner_dst_addr);
     HIP_IFEL(hip_build_param_contents(msg, &entry->inner_dst_addr,
                                       HIP_PARAM_HIT, sizeof(struct in6_addr)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     HIP_DEBUG("esp_prot_transform: %u\n", entry->esp_prot_transform);
     HIP_IFEL(hip_build_param_contents(msg, &entry->esp_prot_transform,
                                       HIP_PARAM_ESP_PROT_TFM, sizeof(uint8_t)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     // also send the hchain/htree length for all update items
     HIP_IFEL(hip_build_param_contents(msg, &hash_item_length, HIP_PARAM_INT,
@@ -386,7 +386,7 @@
         HIP_IFEL(hip_build_param_contents(msg, anchors[i],
                                           HIP_PARAM_HCHAIN_ANCHOR,
                                           hash_length), -1,
-                                          "build param contents failed\n");
+                 "build param contents failed\n");
     }
 
     // now transmit root for each next hash item for tree-based updates, if available
@@ -411,7 +411,7 @@
             HIP_IFEL(hip_build_param_contents(msg, &root_length,
                                               HIP_PARAM_INT,
                                               sizeof(int)), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
         }
 
         if (root) {
@@ -425,7 +425,7 @@
     HIP_DEBUG("soft_update: %i\n", soft_update);
     HIP_IFEL(hip_build_param_contents(msg, &soft_update, HIP_PARAM_INT,
                                       sizeof(int)), -1,
-                                      "build param contents failed\n");
+             "build param contents failed\n");
 
     if (soft_update) {
         for (i = 0; i < num_parallel_hchains; i++) {
@@ -434,37 +434,37 @@
             HIP_IFEL(!(branch_nodes = htree_get_branch(link_trees[i],
                                                        anchor_offset[i], NULL,
                                                        &branch_length)), -1,
-                                                       "failed to get branch nodes\n");
+                     "failed to get branch nodes\n");
 
             HIP_DEBUG("anchor_offset: %i\n", anchor_offset[i]);
             HIP_IFEL(hip_build_param_contents(msg, &anchor_offset[i],
                                               HIP_PARAM_INT,
                                               sizeof(int)), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
 
             HIP_DEBUG("secret_length: %i\n", secret_length);
             HIP_IFEL(hip_build_param_contents(msg, &secret_length,
                                               HIP_PARAM_INT,
                                               sizeof(int)), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
 
             HIP_DEBUG("branch_length: %i\n", branch_length);
             HIP_IFEL(hip_build_param_contents(msg, &branch_length,
                                               HIP_PARAM_INT,
                                               sizeof(int)), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
 
             HIP_HEXDUMP("secret: ", secret, secret_length);
             HIP_IFEL(hip_build_param_contents(msg, secret,
                                               HIP_PARAM_SECRET,
                                               secret_length), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
 
             HIP_HEXDUMP("branch_nodes: ", branch_nodes, branch_length);
             HIP_IFEL(hip_build_param_contents(msg, branch_nodes,
                                               HIP_PARAM_BRANCH_NODES,
                                               branch_length), -1,
-                                              "build param contents failed\n");
+                     "build param contents failed\n");
         }
     }
 
@@ -493,13 +493,13 @@
  */
 int send_anchor_change_to_hipd(const struct hip_sa_entry *entry)
 {
-    int err                = 0;
-    int hash_length        = 0;
-    long i                 = 0;
-    unsigned char *anchor  = NULL;
-    struct hip_common *msg    = NULL;
-    struct hash_chain *hchain = NULL;
-    struct hash_tree  *htree  = NULL;
+    int                err         = 0;
+    int                hash_length = 0;
+    long               i           = 0;
+    unsigned char     *anchor      = NULL;
+    struct hip_common *msg         = NULL;
+    struct hash_chain *hchain      = NULL;
+    struct hash_tree  *htree       = NULL;
 
     HIP_ASSERT(entry != NULL);
     HIP_ASSERT(entry->direction == HIP_SPI_DIRECTION_OUT);
@@ -518,22 +518,22 @@
     HIP_DEBUG_HIT("src_hit", &entry->inner_src_addr);
     HIP_IFEL(hip_build_param_contents(msg, &entry->inner_src_addr,
                                       HIP_PARAM_HIT, sizeof(struct in6_addr)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     HIP_DEBUG_HIT("dst_hit", &entry->inner_dst_addr);
     HIP_IFEL(hip_build_param_contents(msg, &entry->inner_dst_addr,
                                       HIP_PARAM_HIT, sizeof(struct in6_addr)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     HIP_DEBUG("direction: %i\n", entry->direction);
     HIP_IFEL(hip_build_param_contents(msg, &entry->direction,
                                       HIP_PARAM_INT, sizeof(int)), -1,
-                                      "build param contents failed\n");
+             "build param contents failed\n");
 
     HIP_DEBUG("esp_prot_transform: %u\n", entry->esp_prot_transform);
     HIP_IFEL(hip_build_param_contents(msg, &entry->esp_prot_transform,
                                       HIP_PARAM_ESP_PROT_TFM, sizeof(uint8_t)),
-                                      -1, "build param contents failed\n");
+             -1, "build param contents failed\n");
 
     HIP_DEBUG("esp_prot_num_parallel_hchains: %i\n", num_parallel_hchains);
     HIP_IFEL(hip_build_param_contents(msg, &num_parallel_hchains,
@@ -553,7 +553,7 @@
         HIP_HEXDUMP("anchor: ", anchor, hash_length);
         HIP_IFEL(hip_build_param_contents(msg, anchor,
                                           HIP_PARAM_HCHAIN_ANCHOR, hash_length),
-                                          -1, "build param contents failed\n");
+                 -1, "build param contents failed\n");
     }
 
     HIP_DUMP_MSG(msg);
@@ -582,15 +582,15 @@
  * @return  0 on success, -1 on error
  */
 int esp_prot_handle_sa_add_request(const struct hip_common *msg,
-                           uint8_t *esp_prot_transform,
-                           uint16_t *num_anchors,
-                           unsigned char (*esp_prot_anchors)[MAX_HASH_LENGTH],
-                           uint32_t *hash_item_length)
+                                   uint8_t *esp_prot_transform,
+                                   uint16_t *num_anchors,
+                                   unsigned char (*esp_prot_anchors)[MAX_HASH_LENGTH],
+                                   uint32_t *hash_item_length)
 {
-    const struct hip_tlv_common *param = NULL;
-    int hash_length                    = 0, err = 0;
-    const unsigned char *anchor        = NULL;
-    uint16_t i;
+    const struct hip_tlv_common *param       = NULL;
+    int                          hash_length = 0, err = 0;
+    const unsigned char         *anchor      = NULL;
+    uint16_t                     i;
     *num_anchors        = 0;
     *esp_prot_transform = 0;
 

=== modified file 'firewall/esp_prot_fw_msg.h'
--- firewall/esp_prot_fw_msg.h	2011-01-04 14:23:17 +0000
+++ firewall/esp_prot_fw_msg.h	2011-01-11 14:04:40 +0000
@@ -53,9 +53,9 @@
                                 struct hash_tree *link_trees[MAX_NUM_PARALLEL_HCHAINS]);
 int send_anchor_change_to_hipd(const struct hip_sa_entry *entry);
 int esp_prot_handle_sa_add_request(const struct hip_common *msg,
-                                   uint8_t *esp_prot_transform,
-                                   uint16_t *num_anchors,
+                                   uint8_t * esp_prot_transform,
+                                   uint16_t * num_anchors,
                                    unsigned char (*esp_prot_anchors)[MAX_HASH_LENGTH],
-                                   uint32_t *hash_item_length);
+                                   uint32_t * hash_item_length);
 
 #endif /* HIP_FIREWALL_ESP_PROT_FW_MSG_H */

=== modified file 'firewall/file_buffer.c'
--- firewall/file_buffer.c	2010-11-12 17:49:42 +0000
+++ firewall/file_buffer.c	2011-01-11 14:04:40 +0000
@@ -80,8 +80,8 @@
         /* First, we try to determine the current file size for the new buffer size.
          * If that fails (it does, e.g., for proc files), we just increase the
          * current buffer size. */
-        errno       = 0;
-        file_size   = lseek(fb->fd, 0, SEEK_END);
+        errno     = 0;
+        file_size = lseek(fb->fd, 0, SEEK_END);
         if (file_size != -1 || EINVAL == errno) {
             if (file_size != -1) {
                 fb->buffer_size = file_size + HIP_FB_HEADROOM; // add a little head room
@@ -191,8 +191,8 @@
             fb->fd = -1;
         }
         free(fb->ma.start);
-        fb->ma.start    = NULL;
-        fb->ma.end      = NULL;
+        fb->ma.start = NULL;
+        fb->ma.end   = NULL;
     }
 }
 
@@ -217,7 +217,7 @@
 
     while (1) {
         ssize_t bytes;
-        off_t seek_offset;
+        off_t   seek_offset;
 
         // can we re-read the whole file into the memory buffer?
         seek_offset = lseek(fb->fd, 0, SEEK_SET);
@@ -232,7 +232,7 @@
             HIP_ERROR("Reading the contents of the file descriptor %d via read() into a memory buffer of size %d failed with the error %s\n",
                       fb->fd, fb->buffer_size, strerror(errno));
             break;
-        } else if ((size_t)bytes == fb->buffer_size) {
+        } else if ((size_t) bytes == fb->buffer_size) {
             // we can't fit the file into the memory buffer -> resize it
             if (hip_fb_resize(fb) == 0) {
                 // successful resize -> retry reading

=== modified file 'firewall/firewall.c'
--- firewall/firewall.c	2011-01-10 10:14:22 +0000
+++ firewall/firewall.c	2011-01-11 14:04:40 +0000
@@ -142,14 +142,14 @@
 
 /* externally used state */
 // TODO try to decrease number of globally used variables
-int filter_traffic                        = HIP_FW_FILTER_TRAFFIC_BY_DEFAULT;
-int hip_kernel_ipsec_fallback             = 0;
-int hip_lsi_support                       = 0;
-int system_based_opp_mode                 = 0;
-int esp_relay                             = 0;
-int hip_esp_protection                    = 0;
+int filter_traffic            = HIP_FW_FILTER_TRAFFIC_BY_DEFAULT;
+int hip_kernel_ipsec_fallback = 0;
+int hip_lsi_support           = 0;
+int system_based_opp_mode     = 0;
+int esp_relay                 = 0;
+int hip_esp_protection        = 0;
 #ifdef CONFIG_HIP_MIDAUTH
-int use_midauth                           = 0;
+int use_midauth = 0;
 #endif
 
 /** Use this to send and receive responses to hipd. Notice that
@@ -162,12 +162,12 @@
  *
  * @todo make accessible through send function, no-one should read on that
  */
-int hip_fw_sock                           = 0;
+int hip_fw_sock = 0;
 /**
  * Use this socket *only* for receiving async messages from hipd
  * @todo make static, no-one should read on that
  */
-int hip_fw_async_sock                     = 0;
+int hip_fw_async_sock = 0;
 
 /**
  * display usage of firewall to stdout
@@ -213,8 +213,8 @@
  */
 static int hip_fw_init_userspace_ipsec(void)
 {
-    int err = 0;
-    int ver_c;
+    int            err = 0;
+    int            ver_c;
     struct utsname name;
 
     HIP_IFEL(uname(&name), -1, "Failed to retrieve kernel information: %s\n",
@@ -301,7 +301,7 @@
 
     // userspace ipsec is a prerequisite for esp protection
     if (hip_esp_protection && hip_userspace_ipsec) {
-            HIP_IFEL(esp_prot_init(), -1, "failed to init esp protection\n");
+        HIP_IFEL(esp_prot_init(), -1, "failed to init esp protection\n");
     } else {
         HIP_ERROR("userspace ipsec needs to be turned on for this to work\n");
 
@@ -435,7 +435,6 @@
     return err;
 }
 
-
 /*
  * Initialize rules for filtering traffic
  *
@@ -551,7 +550,7 @@
         /* Still accept HIP traffic as if the -A flag had been given
          * instead of -F */
         accept_hip_esp_traffic_by_default = 1;
-        restore_accept_hip_esp_traffic = 1;
+        restore_accept_hip_esp_traffic    = 1;
 
         firewall_init_filter_traffic();
     }
@@ -604,11 +603,11 @@
  */
 static int hip_query_default_local_hit_from_hipd(void)
 {
-    int err                            = 0;
-    struct hip_common *msg             = NULL;
+    int                          err   = 0;
+    struct hip_common           *msg   = NULL;
     const struct hip_tlv_common *param = NULL;
-    const hip_hit_t *hit               = NULL;
-    const hip_lsi_t *lsi               = NULL;
+    const hip_hit_t             *hit   = NULL;
+    const hip_lsi_t             *lsi   = NULL;
 
     HIP_IFE(!(msg = hip_msg_alloc()), -1);
     HIP_IFEL(hip_build_user_hdr(msg, HIP_MSG_DEFAULT_HIT, 0), -1,
@@ -742,9 +741,9 @@
  */
 static void firewall_probe_kernel_modules(void)
 {
-    int count, err, status;
-    char cmd[40];
-    int mod_total;
+    int         count, err, status;
+    char        cmd[40];
+    int         mod_total;
     const char *mod_name[] =
     { "ip_queue", "ip6_queue", "iptable_filter", "ip6table_filter" };
 
@@ -855,9 +854,9 @@
 
     if (esp_relay && ctx->udp_encap_hdr &&
         ((ret = hipfw_relay_esp(ctx)) <= 0)) {
-         /* 0: drop original and reinject new packet
-            -1: accept reinject packet and avoid filter_esp_state
-            1: just let it pass => proceed to filter */
+        /* 0: drop original and reinject new packet
+         * -1: accept reinject packet and avoid filter_esp_state
+         * 1: just let it pass => proceed to filter */
         if (ret == 0) {
             HIP_DEBUG("Drop original and reinject relayed ESP packet\n");
             verdict = 0;
@@ -865,7 +864,7 @@
             HIP_DEBUG("Accept reinjected packet\n");
             verdict = 1;
         } else {
-             HIP_ASSERT(0);
+            HIP_ASSERT(0);
         }
     } else if (filter_esp_state(ctx) > 0) {
         verdict = 1;
@@ -900,14 +899,14 @@
                       struct hip_fw_context *ctx)
 {
     // complete rule list for hook (== IN / OUT / FORWARD)
-    struct dlist *list  = get_rule_list(hook);
-    struct rule *rule   = NULL;
+    struct dlist *list = get_rule_list(hook);
+    struct rule  *rule = NULL;
     // assume match for current rule
-    int match           = 1, print_addr = 0;
+    int match = 1, print_addr = 0;
     // assume packet has not yet passed connection tracking
-    int conntracked     = 0;
+    int conntracked = 0;
     // block traffic by default
-    int verdict         = 0;
+    int verdict = 0;
 
     HIP_DEBUG("\n");
 
@@ -922,25 +921,25 @@
     if (buf->type_hdr == HIP_I1) {
         HIP_INFO("received packet type: I1\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_R1)   {
+    } else if (buf->type_hdr == HIP_R1) {
         HIP_INFO("received packet type: R1\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_I2)   {
+    } else if (buf->type_hdr == HIP_I2) {
         HIP_INFO("received packet type: I2\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_R2)   {
+    } else if (buf->type_hdr == HIP_R2) {
         HIP_INFO("received packet type: R2\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_UPDATE)   {
+    } else if (buf->type_hdr == HIP_UPDATE) {
         HIP_INFO("received packet type: UPDATE\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_CLOSE)   {
+    } else if (buf->type_hdr == HIP_CLOSE) {
         HIP_INFO("received packet type: CLOSE\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_CLOSE_ACK)   {
+    } else if (buf->type_hdr == HIP_CLOSE_ACK) {
         HIP_INFO("received packet type: CLOSE_ACK\n");
         print_addr = 1;
-    } else if (buf->type_hdr == HIP_NOTIFY)   {
+    } else if (buf->type_hdr == HIP_NOTIFY) {
         HIP_DEBUG("received packet type: NOTIFY\n");
     } else if (buf->type_hdr == HIP_LUPDATE) {
         HIP_DEBUG("received packet type: LIGHT UPDATE\n");
@@ -1039,7 +1038,6 @@
             if (!filter_state(ip6_src, ip6_dst, buf, rule->state, rule->accept,
                               ctx)) {
                 match = 0;
-
             } else {
                 // if it is a valid packet, this also tracked the packet
                 conntracked = 1;
@@ -1140,7 +1138,8 @@
  *
  * @return the verdict (1 for pass and 0 for drop)
  */
-static int hip_fw_handle_hip_output(struct hip_fw_context *ctx){
+static int hip_fw_handle_hip_output(struct hip_fw_context *ctx)
+{
     int verdict = accept_hip_esp_traffic_by_default;
 
     HIP_DEBUG("hip_fw_handle_hip_output \n");
@@ -1198,7 +1197,6 @@
               accept_normal_traffic_by_default);
 
     if (ctx->ip_version == 6 && hip_userspace_ipsec) {
-
         hip_hit_t *def_hit = hip_fw_get_default_hit();
         HIP_DEBUG_HIT("destination hit: ", &ctx->dst);
 
@@ -1229,7 +1227,7 @@
             }
         } else if (system_based_opp_mode) {
             verdict = hip_fw_handle_outgoing_system_based_opp(ctx,
-                                             accept_normal_traffic_by_default);
+                                                              accept_normal_traffic_by_default);
         }
     }
 
@@ -1428,10 +1426,10 @@
               NF_IP_FORWARD);
 
     // funtion pointers for the respective packet handlers
-    fw_handlers[NF_IP_LOCAL_IN][OTHER_PACKET]  = hip_fw_handle_other_input;
-    fw_handlers[NF_IP_LOCAL_IN][HIP_PACKET]    = hip_fw_handle_hip_input;
-    fw_handlers[NF_IP_LOCAL_IN][ESP_PACKET]    = hip_fw_handle_esp_input;
-    fw_handlers[NF_IP_LOCAL_IN][TCP_PACKET]    = hip_fw_handle_tcp_input;
+    fw_handlers[NF_IP_LOCAL_IN][OTHER_PACKET] = hip_fw_handle_other_input;
+    fw_handlers[NF_IP_LOCAL_IN][HIP_PACKET]   = hip_fw_handle_hip_input;
+    fw_handlers[NF_IP_LOCAL_IN][ESP_PACKET]   = hip_fw_handle_esp_input;
+    fw_handlers[NF_IP_LOCAL_IN][TCP_PACKET]   = hip_fw_handle_tcp_input;
 
     fw_handlers[NF_IP_LOCAL_OUT][OTHER_PACKET] = hip_fw_handle_other_output;
     fw_handlers[NF_IP_LOCAL_OUT][HIP_PACKET]   = hip_fw_handle_hip_output;
@@ -1439,10 +1437,10 @@
     fw_handlers[NF_IP_LOCAL_OUT][TCP_PACKET]   = hip_fw_handle_tcp_output;
 
     //apply rules for forwarded hip and esp traffic
-    fw_handlers[NF_IP_FORWARD][HIP_PACKET]     = hip_fw_handle_hip_forward;
-    fw_handlers[NF_IP_FORWARD][ESP_PACKET]     = hip_fw_handle_esp_forward;
+    fw_handlers[NF_IP_FORWARD][HIP_PACKET] = hip_fw_handle_hip_forward;
+    fw_handlers[NF_IP_FORWARD][ESP_PACKET] = hip_fw_handle_esp_forward;
     //do not drop those files by default
-    fw_handlers[NF_IP_FORWARD][TCP_PACKET]     = hip_fw_handle_tcp_forward;
+    fw_handlers[NF_IP_FORWARD][TCP_PACKET] = hip_fw_handle_tcp_forward;
 
     HIP_DEBUG("Enabling forwarding for IPv4 and IPv6\n");
     system_print("echo 1 >/proc/sys/net/ipv4/conf/all/forwarding");
@@ -1498,9 +1496,9 @@
 {
     int ip_hdr_len, err = 0;
     // length of packet starting at udp header
-    uint16_t udp_len         = 0;
-    struct udphdr *udphdr    = NULL;
-    int udp_encap_zero_bytes = 0;
+    uint16_t       udp_len              = 0;
+    struct udphdr *udphdr               = NULL;
+    int            udp_encap_zero_bytes = 0;
 
     // default assumption
     ctx->packet_type = OTHER_PACKET;
@@ -1529,9 +1527,9 @@
         /* ip_hl is given in multiple of 4 bytes
          *
          * NOTE: not sizeof(struct ip) as we might have options */
-        ip_hdr_len       = (iphdr->ip_hl * 4);
+        ip_hdr_len = (iphdr->ip_hl * 4);
         // needed for opportunistic TCP
-        ctx->ip_hdr_len  = ip_hdr_len;
+        ctx->ip_hdr_len = ip_hdr_len;
         HIP_DEBUG("ip_hdr_len is: %d\n", ip_hdr_len);
         HIP_DEBUG("total length: %u\n", ntohs(iphdr->ip_len));
         HIP_DEBUG("ttl: %u\n", iphdr->ip_ttl);
@@ -1553,7 +1551,7 @@
 
             ctx->packet_type       = HIP_PACKET;
             ctx->transport_hdr.hip = (struct hip_common *)
-                    (((char *) iphdr) + ip_hdr_len);
+                                     (((char *) iphdr) + ip_hdr_len);
 
             goto end_init;
         } else if (iphdr->ip_p == IPPROTO_ESP) {
@@ -1562,7 +1560,7 @@
 
             ctx->packet_type       = ESP_PACKET;
             ctx->transport_hdr.esp = (struct hip_esp *)
-                    (((char *) iphdr) + ip_hdr_len);
+                                     (((char *) iphdr) + ip_hdr_len);
 
             goto end_init;
         } else if (iphdr->ip_p == IPPROTO_TCP) {
@@ -1570,7 +1568,7 @@
             HIP_DEBUG("plain TCP packet\n");
 
             ctx->packet_type       = TCP_PACKET;
-            ctx->transport_hdr.tcp = (struct tcphdr*)
+            ctx->transport_hdr.tcp = (struct tcphdr *)
                                      (((char *) iphdr) + ip_hdr_len);
 
             HIP_DEBUG("src port: %u\n", ntohs(ctx->transport_hdr.tcp->source));
@@ -1585,9 +1583,9 @@
         }
 
         // need UDP header to look for encapsulated ESP
-        udp_len            = ntohs(iphdr->ip_len);
-        udphdr             = ((struct udphdr *)
-                (((char *) iphdr) + ip_hdr_len));
+        udp_len = ntohs(iphdr->ip_len);
+        udphdr  = ((struct udphdr *)
+                   (((char *) iphdr) + ip_hdr_len));
 
         // add UDP header to context
         ctx->udp_encap_hdr = udphdr;
@@ -1597,9 +1595,9 @@
         ctx->ip_hdr.ipv6 = ip6_hdr;
 
         // Ipv6 has fixed header length
-        ip_hdr_len       = sizeof(struct ip6_hdr);
+        ip_hdr_len = sizeof(struct ip6_hdr);
         // needed for opportunistic TCP
-        ctx->ip_hdr_len  = ip_hdr_len;
+        ctx->ip_hdr_len = ip_hdr_len;
         HIP_DEBUG("ip_hdr_len is: %d\n", ip_hdr_len);
         HIP_DEBUG("payload length: %u\n", ntohs(ip6_hdr->ip6_plen));
         HIP_DEBUG("ttl: %u\n", ip6_hdr->ip6_hlim);
@@ -1622,7 +1620,7 @@
 
             ctx->packet_type       = HIP_PACKET;
             ctx->transport_hdr.hip = (struct hip_common *)
-                    (((char *) ip6_hdr) + sizeof(struct ip6_hdr));
+                                     (((char *) ip6_hdr) + sizeof(struct ip6_hdr));
 
             goto end_init;
         } else if (ip6_hdr->ip6_nxt == IPPROTO_ESP) {
@@ -1631,7 +1629,7 @@
 
             ctx->packet_type       = ESP_PACKET;
             ctx->transport_hdr.esp = (struct hip_esp *)
-                    (((char *) ip6_hdr) + sizeof(struct ip6_hdr));
+                                     (((char *) ip6_hdr) + sizeof(struct ip6_hdr));
 
             goto end_init;
         } else if (ip6_hdr->ip6_nxt == IPPROTO_TCP) {
@@ -1639,7 +1637,7 @@
             HIP_DEBUG("plain TCP packet\n");
 
             ctx->packet_type       = TCP_PACKET;
-            ctx->transport_hdr.tcp = (struct tcphdr*)
+            ctx->transport_hdr.tcp = (struct tcphdr *)
                                      (((char *) ip6_hdr) + sizeof(struct ip6_hdr));
 
             HIP_DEBUG("src port: %u\n", ntohs(ctx->transport_hdr.tcp->source));
@@ -1661,9 +1659,9 @@
          *
          * NOTE: the length will include optional extension headers
          * -> handle this */
-        udp_len            = ntohs(ip6_hdr->ip6_plen);
-        udphdr             = ((struct udphdr *)
-                (((char *) ip6_hdr) + ip_hdr_len));
+        udp_len = ntohs(ip6_hdr->ip6_plen);
+        udphdr  = ((struct udphdr *)
+                   (((char *) ip6_hdr) + ip_hdr_len));
 
         // add udp header to context
         ctx->udp_encap_hdr = udphdr;
@@ -1682,7 +1680,6 @@
     if (ctx->ip_version == 4) {
         // we might have only received a UDP packet with headers only
         if (udp_len >= sizeof(struct ip) + sizeof(struct udphdr) + HIP_UDP_ZERO_BYTES_LEN) {
-
             uint32_t *zero_bytes = NULL;
 
             // we can distinguish UDP encapsulated control and data traffic with 32 zero bits
@@ -1715,16 +1712,16 @@
         /* check if zero byte hint is correct and we are processing a
          * HIP control message */
         if (!hip_check_network_msg((struct hip_common *) (((char *) udphdr)
-                                                + sizeof(struct udphdr)
-                                                + HIP_UDP_ZERO_BYTES_LEN))) {
+                                                          + sizeof(struct udphdr)
+                                                          + HIP_UDP_ZERO_BYTES_LEN))) {
             // we found an UDP encapsulated HIP control packet
             HIP_DEBUG("UDP encapsulated HIP control packet\n");
 
             // add to context
             ctx->packet_type       = HIP_PACKET;
             ctx->transport_hdr.hip = (struct hip_common *) (((char *) udphdr)
-                                                    + sizeof(struct udphdr)
-                                                    + HIP_UDP_ZERO_BYTES_LEN);
+                                                            + sizeof(struct udphdr)
+                                                            + HIP_UDP_ZERO_BYTES_LEN);
 
             goto end_init;
         }
@@ -1932,21 +1929,21 @@
  */
 int main(int argc, char **argv)
 {
-    int err                = 0, highest_descriptor, i;
-    int n, len;
-    struct ipq_handle *h4  = NULL, *h6 = NULL;
-    int ch;
-    char *rule_file        = NULL;
-    int errflg             = 0, killold = 0;
-    struct hip_common *msg = NULL;
-    struct sockaddr_in6 sock_addr;
-    socklen_t alen;
-    fd_set read_fdset;
-    struct timeval timeout;
-    unsigned char buf[HIP_MAX_PACKET];
+    int                   err = 0, highest_descriptor, i;
+    int                   n, len;
+    struct ipq_handle    *h4 = NULL, *h6 = NULL;
+    int                   ch;
+    char                 *rule_file = NULL;
+    int                   errflg    = 0, killold = 0;
+    struct hip_common    *msg       = NULL;
+    struct sockaddr_in6   sock_addr;
+    socklen_t             alen;
+    fd_set                read_fdset;
+    struct timeval        timeout;
+    unsigned char         buf[HIP_MAX_PACKET];
     struct hip_fw_context ctx;
-    int limit_capabilities = 0;
-    int is_root            = 0, access_ok = 0, msg_type = 0; //variables for accepting user messages only from hipd
+    int                   limit_capabilities = 0;
+    int                   is_root            = 0, access_ok = 0, msg_type = 0; //variables for accepting user messages only from hipd
 
     /* Make sure that root path is set up correcly (e.g. on Fedora 9).
      * Otherwise may get warnings from system_print() commands.
@@ -2007,7 +2004,7 @@
             rule_file = optarg;
             break;
         case 'F':
-            filter_traffic = 0;
+            filter_traffic         = 0;
             restore_filter_traffic = filter_traffic;
             break;
         case 'h':
@@ -2018,11 +2015,11 @@
             accept_normal_traffic_by_default = 0;
             break;
         case 'i':
-            hip_userspace_ipsec = 1;
+            hip_userspace_ipsec       = 1;
             hip_kernel_ipsec_fallback = 0;
             break;
         case 'I':
-            hip_userspace_ipsec = 1;
+            hip_userspace_ipsec       = 1;
             hip_kernel_ipsec_fallback = 1;
             break;
         case 'k':
@@ -2034,7 +2031,7 @@
         case 'm':
 #ifdef CONFIG_HIP_MIDAUTH
             filter_traffic = 1;
-            use_midauth = 1;
+            use_midauth    = 1;
             break;
 #endif
         case 'o':
@@ -2082,11 +2079,11 @@
     HIP_IFEL((hip_fw_sock < 0), 1, "Could not create socket for firewall.\n");
     memset(&sock_addr, 0, sizeof(sock_addr));
     sock_addr.sin6_family = AF_INET6;
-    sock_addr.sin6_port = htons(HIP_FIREWALL_SYNC_PORT);
-    sock_addr.sin6_addr = in6addr_loopback;
+    sock_addr.sin6_port   = htons(HIP_FIREWALL_SYNC_PORT);
+    sock_addr.sin6_addr   = in6addr_loopback;
 
-    for (i=0; i<2; i++) {
-        err = bind(hip_fw_sock, (struct sockaddr *)& sock_addr,
+    for (i = 0; i < 2; i++) {
+        err = bind(hip_fw_sock, (struct sockaddr *) &sock_addr,
                    sizeof(sock_addr));
         if (err == 0) {
             break;
@@ -2103,9 +2100,9 @@
     HIP_IFEL((hip_fw_async_sock < 0), 1, "Could not create socket for firewall.\n");
     memset(&sock_addr, 0, sizeof(sock_addr));
     sock_addr.sin6_family = AF_INET6;
-    sock_addr.sin6_port = htons(HIP_FIREWALL_PORT);
-    sock_addr.sin6_addr = in6addr_loopback;
-    HIP_IFEL(bind(hip_fw_async_sock, (struct sockaddr *)& sock_addr, sizeof(sock_addr)), -1,
+    sock_addr.sin6_port   = htons(HIP_FIREWALL_PORT);
+    sock_addr.sin6_addr   = in6addr_loopback;
+    HIP_IFEL(bind(hip_fw_async_sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)), -1,
              "Bind on firewall socket addr failed. Give -k option to kill old hipfw\n");
     HIP_IFEL(hip_daemon_connect(hip_fw_async_sock), -1,
              "connecting socket failed\n");
@@ -2175,7 +2172,7 @@
         FD_SET(h4->fd, &read_fdset);
         FD_SET(h6->fd, &read_fdset);
 
-        timeout.tv_sec = HIP_SELECT_TIMEOUT;
+        timeout.tv_sec  = HIP_SELECT_TIMEOUT;
         timeout.tv_usec = 0;
 
         // get handle with queued packet and process
@@ -2238,8 +2235,8 @@
 
             HIP_DEBUG("Receiving message type %d (%d bytes)\n",
                       hip_get_msg_type(msg), len);
-            n    = recvfrom(hip_fw_async_sock, msg, len, 0,
-                            (struct sockaddr *) &sock_addr, &alen);
+            n = recvfrom(hip_fw_async_sock, msg, len, 0,
+                         (struct sockaddr *) &sock_addr, &alen);
 
             if (n < 0) {
                 HIP_ERROR("Error receiving message parameters from daemon.\n");

=== modified file 'firewall/firewall_control.c'
--- firewall/firewall_control.c	2010-11-30 14:50:30 +0000
+++ firewall/firewall_control.c	2011-01-11 14:04:40 +0000
@@ -60,20 +60,20 @@
  */
 static int hip_handle_bex_state_update(struct hip_common *msg)
 {
-    const struct in6_addr *src_hit     = NULL, *dst_hit = NULL;
-    const struct hip_tlv_common *param = NULL;
-    int err                      = 0, msg_type = 0;
+    const struct in6_addr       *src_hit = NULL, *dst_hit = NULL;
+    const struct hip_tlv_common *param   = NULL;
+    int                          err     = 0, msg_type = 0;
 
     msg_type = hip_get_msg_type(msg);
 
     /* src_hit */
-    param    = hip_get_param(msg, HIP_PARAM_HIT);
-    src_hit  = hip_get_param_contents_direct(param);
+    param   = hip_get_param(msg, HIP_PARAM_HIT);
+    src_hit = hip_get_param_contents_direct(param);
     HIP_DEBUG_HIT("Source HIT: ", src_hit);
 
     /* dst_hit */
-    param    = hip_get_next_param(msg, param);
-    dst_hit  = hip_get_param_contents_direct(param);
+    param   = hip_get_next_param(msg, param);
+    dst_hit = hip_get_param_contents_direct(param);
     HIP_DEBUG_HIT("Destination HIT: ", dst_hit);
 
     /* update bex_state in firewalldb */
@@ -100,7 +100,7 @@
  */
 int hip_handle_msg(struct hip_common *msg)
 {
-    int type, err = 0;
+    int                type, err = 0;
     struct hip_common *msg_out = NULL;
 
     HIP_DEBUG("Handling message from hipd\n");

=== modified file 'firewall/firewall_defines.h'
--- firewall/firewall_defines.h	2011-01-04 14:32:37 +0000
+++ firewall/firewall_defines.h	2011-01-11 14:04:40 +0000
@@ -48,9 +48,9 @@
     ipq_packet_msg_t *ipq_packet;
 
     // IP layer information
-    int               ip_version; /* 4, 6 */
-    int               ip_hdr_len;
-    struct in6_addr   src, dst;
+    int             ip_version;   /* 4, 6 */
+    int             ip_hdr_len;
+    struct in6_addr src, dst;
     union {
         struct ip6_hdr *ipv6;
         struct ip      *ipv4;
@@ -65,43 +65,43 @@
     } transport_hdr;
     struct udphdr *udp_encap_hdr;
 
-    int            modified;
+    int modified;
 };
 
 /********** State table structures **************/
 
 struct esp_address {
-    struct in6_addr  dst_addr;
-    uint32_t        *update_id; // null or pointer to the update id from the packet
+    struct in6_addr dst_addr;
+    uint32_t       *update_id;  // null or pointer to the update id from the packet
     // that announced this address.
     // when ack with the update id is seen all esp_addresses with
     // null update_id can be removed.
 };
 
 struct esp_tuple {
-    uint32_t                spi;
-    uint32_t                new_spi;
-    uint32_t                spi_update_id;
-    struct slist           *dst_addr_list;
-    struct tuple           *tuple;
+    uint32_t      spi;
+    uint32_t      new_spi;
+    uint32_t      spi_update_id;
+    struct slist *dst_addr_list;
+    struct tuple *tuple;
     /* tracking of the ESP SEQ number */
-    uint32_t                seq_no;
+    uint32_t seq_no;
     /* members needed for ESP protection extension */
-    uint8_t                 esp_prot_tfm;
-    uint32_t                hash_item_length;
-    uint32_t                hash_tree_depth;
-    long                    num_hchains;
-    unsigned char           active_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
+    uint8_t       esp_prot_tfm;
+    uint32_t      hash_item_length;
+    uint32_t      hash_tree_depth;
+    long          num_hchains;
+    unsigned char active_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
     // need for verification of anchor updates
-    unsigned char           first_active_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
-    unsigned char           next_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
-    int                     active_root_length;
-    unsigned char          *active_roots[MAX_NUM_PARALLEL_HCHAINS];
-    int                     next_root_length[MAX_NUM_PARALLEL_HCHAINS];
-    unsigned char          *next_roots[MAX_NUM_PARALLEL_HCHAINS];
+    unsigned char  first_active_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
+    unsigned char  next_anchors[MAX_NUM_PARALLEL_HCHAINS][MAX_HASH_LENGTH];
+    int            active_root_length;
+    unsigned char *active_roots[MAX_NUM_PARALLEL_HCHAINS];
+    int            next_root_length[MAX_NUM_PARALLEL_HCHAINS];
+    unsigned char *next_roots[MAX_NUM_PARALLEL_HCHAINS];
     /** List temporarily storing anchor elements until the consecutive update
      *  msg reveals that all on-path devices know the new anchor. */
-    struct hip_ll              anchor_cache;
+    struct hip_ll anchor_cache;
     /** buffer storing hashes of previous packets for cumulative authentication */
     struct esp_cumulative_item hash_buffer[MAX_RING_BUFFER_SIZE];
 };
@@ -130,9 +130,9 @@
     struct connection *connection;
     int                state;
     uint32_t           lupdate_seq;
-    int esp_relay;
-    struct in6_addr esp_relay_daddr;
-    in_port_t esp_relay_dport;
+    int                esp_relay;
+    struct in6_addr    esp_relay_daddr;
+    in_port_t          esp_relay_dport;
 };
 
 struct connection {
@@ -142,10 +142,10 @@
     int            state;
     struct timeval time_stamp;
     /* members needed for ESP protection extension */
-    int            num_esp_prot_tfms;
-    uint8_t        esp_prot_tfms[MAX_NUM_TRANSFORMS];
+    int     num_esp_prot_tfms;
+    uint8_t esp_prot_tfms[MAX_NUM_TRANSFORMS];
 #ifdef CONFIG_HIP_MIDAUTH
-    int            pisa_state;
+    int pisa_state;
 #endif
 };
 

=== modified file 'firewall/helpers.c'
--- firewall/helpers.c	2010-12-13 21:15:07 +0000
+++ firewall/helpers.c	2011-01-11 14:04:40 +0000
@@ -71,7 +71,7 @@
 struct in6_addr *numeric_to_addr(const char *num)
 {
     static struct in6_addr ap;
-    int err;
+    int                    err;
     if ((err = inet_pton(AF_INET6, num, &ap)) == 1) {
         return &ap;
     }

=== modified file 'firewall/line_parser.c'
--- firewall/line_parser.c	2010-11-30 14:40:39 +0000
+++ firewall/line_parser.c	2011-01-11 14:04:40 +0000
@@ -110,8 +110,8 @@
         return NULL;
     }
 
-    remaining   = lp->ma->end - lp->cur;
-    lp->cur     = memchr(lp->cur, '\n', remaining);
+    remaining = lp->ma->end - lp->cur;
+    lp->cur   = memchr(lp->cur, '\n', remaining);
 
     // given the rest of the parsing code, we should always find a \n, but
     // let's check to be sure

=== modified file 'firewall/lsi.c'
--- firewall/lsi.c	2011-01-04 13:57:31 +0000
+++ firewall/lsi.c	2011-01-11 14:04:40 +0000
@@ -84,7 +84,7 @@
  * @param src_ip  an optional source IP address for the I1
  * @param dst_ip  a destination IP for the I1
  * @return        zero on success or negative on error
-
+ *
  * @note Many of the parameters are optional, but at least a
  * destination LSI, HIT or IP (for opportunistic BEX) must to be
  * provided
@@ -97,7 +97,7 @@
                     const struct in6_addr *dst_ip)
 {
     struct hip_common *msg = NULL;
-    int err                = 0;
+    int                err = 0;
     HIP_IFE(!(msg = hip_msg_alloc()), -1);
     HIP_IFEL(!dst_hit && !dst_ip && !dst_lsi,
              -1, "no destination hit, ip or lsi provided\n");
@@ -181,7 +181,7 @@
 int hip_is_packet_lsi_reinjection(hip_lsi_t *lsi)
 {
     hip_lsi_t *local_lsi;
-    int err = 0;
+    int        err = 0;
     HIP_IFEL(!(local_lsi = hip_fw_get_default_lsi()), -1,
              "Failed to get default LSI");
     if (local_lsi->s_addr == lsi->s_addr) {
@@ -212,13 +212,13 @@
                         const int ipOrigTraffic,
                         const int incoming)
 {
-    int err              = 0;
-    int ip_hdr_size      = 0;
-    int packet_length    = 0;
-    int protocol         = 0;
-    int ttl              = 0;
-    uint8_t *msg              = NULL;
-    struct icmphdr *icmp = NULL;
+    int             err           = 0;
+    int             ip_hdr_size   = 0;
+    int             packet_length = 0;
+    int             protocol      = 0;
+    int             ttl           = 0;
+    uint8_t        *msg           = NULL;
+    struct icmphdr *icmp          = NULL;
 
     if (ipOrigTraffic == 4) {
         const struct ip *iphdr = (const struct ip *) m->payload;
@@ -238,7 +238,7 @@
         HIP_DEBUG_IN6ADDR("New packet dst address: ", dst_hit);
     }
 
-    if ((int)m->data_len <= (BUFSIZE - ip_hdr_size)) {
+    if ((int) m->data_len <= (BUFSIZE - ip_hdr_size)) {
         packet_length = m->data_len - ip_hdr_size;
         HIP_DEBUG("packet size smaller than buffer size\n");
     } else {
@@ -308,16 +308,16 @@
                                const struct in6_addr *ip_dst,
                                const int lsi_support)
 {
-    int err                                               = 0;
-    int verdict                                           = 1;
-    int ip_hdr_size                                       = 0;
-    int portDest                                          = 0;
-    struct hip_hadb_user_info_state *entry                = NULL;
-    enum hip_port_binding port_binding                    = HIP_PORT_INFO_UNKNOWN;
-    const struct ip6_hdr *ip6_hdr                         = NULL;
-    struct in6_addr src_addr, dst_addr;
+    int                              err          = 0;
+    int                              verdict      = 1;
+    int                              ip_hdr_size  = 0;
+    int                              portDest     = 0;
+    struct hip_hadb_user_info_state *entry        = NULL;
+    enum hip_port_binding            port_binding = HIP_PORT_INFO_UNKNOWN;
+    const struct ip6_hdr            *ip6_hdr      = NULL;
+    struct in6_addr                  src_addr, dst_addr;
 
-    ip6_hdr = (const struct ip6_hdr *) m->payload;
+    ip6_hdr     = (const struct ip6_hdr *) m->payload;
     ip_hdr_size = sizeof(struct ip6_hdr);
 
     switch (ip6_hdr->ip6_nxt) {
@@ -398,7 +398,7 @@
 int hip_fw_handle_outgoing_lsi(ipq_packet_msg_t *m, struct in_addr *lsi_src,
                                struct in_addr *lsi_dst)
 {
-    int err = 0;
+    int                              err        = 0;
     struct hip_hadb_user_info_state *entry_peer = NULL;
 
     if (lsi_dst) {

=== modified file 'firewall/midauth.c'
--- firewall/midauth.c	2011-01-07 16:09:23 +0000
+++ firewall/midauth.c	2011-01-11 14:04:40 +0000
@@ -71,7 +71,7 @@
 static void update_ipv4_header(struct iphdr *ip, int len)
 {
     unsigned short *w = (unsigned short *) ip;
-    int hdrlen, checksum = 0;
+    int             hdrlen, checksum = 0;
 
     ip->tot_len = htons(len);
     ip->check   = 0;
@@ -113,16 +113,16 @@
  */
 static void update_udp_header(struct iphdr *ip, int len)
 {
-    unsigned long sum;
-    uint16_t *w       = (uint16_t *) ((unsigned char *) ip + (ip->ihl * 4));
-    uint16_t protocol = ntohs(IPPROTO_UDP);
-    int i;
+    unsigned long  sum;
+    uint16_t      *w        = (uint16_t *) ((unsigned char *) ip + (ip->ihl * 4));
+    uint16_t       protocol = ntohs(IPPROTO_UDP);
+    int            i;
     struct udphdr *udp = (struct udphdr *) w;
 
     len -= ip->ihl * 4;
 
     udp->check = 0;
-    udp->len = htons(len);
+    udp->len   = htons(len);
 
     /* UDP header and data */
     sum = 0;
@@ -133,11 +133,11 @@
     if (len == 1) {
         unsigned short padding = 0;
         *(unsigned char *) (&padding) = *(unsigned char *) w;
-        sum += padding;
+        sum                          += padding;
     }
 
     /* add UDP pseudoheader */
-    w          = (uint16_t *) &ip->saddr;
+    w = (uint16_t *) &ip->saddr;
     for (i = 0; i < 4; w++, i++) {
         sum += *w;
     }
@@ -171,9 +171,9 @@
     memcpy(&dst.sin_addr, &ip->daddr, sizeof(uint32_t));
 
     hip_zero_msg_checksum(msg);
-    msg->checksum  = hip_checksum_packet((char *) msg,
-                                         (struct sockaddr *) &src,
-                                         (struct sockaddr *) &dst);
+    msg->checksum = hip_checksum_packet((char *) msg,
+                                        (struct sockaddr *) &src,
+                                        (struct sockaddr *) &dst);
 }
 
 /**
@@ -184,8 +184,8 @@
 static void update_hip_checksum_ipv6(struct ip6_hdr *ip)
 {
     struct sockaddr_in6 src, dst;
-    struct hip_common *msg = (struct hip_common *) ((char *) ip +
-                                                    sizeof(struct ip6_hdr));
+    struct hip_common  *msg = (struct hip_common *) ((char *) ip +
+                                                     sizeof(struct ip6_hdr));
 
     memset(&src, 0, sizeof(src));
     memset(&dst, 0, sizeof(dst));
@@ -197,9 +197,9 @@
     memcpy(&dst.sin6_addr, &ip->ip6_dst, sizeof(struct in6_addr));
 
     hip_zero_msg_checksum(msg);
-    msg->checksum   = hip_checksum_packet((char *) msg,
-                                          (struct sockaddr *) &src,
-                                          (struct sockaddr *) &dst);
+    msg->checksum = hip_checksum_packet((char *) msg,
+                                        (struct sockaddr *) &src,
+                                        (struct sockaddr *) &dst);
 }
 
 /**
@@ -210,9 +210,9 @@
  */
 static void midauth_update_all_headers(struct hip_fw_context *ctx)
 {
-    struct iphdr *ipv4   = NULL;
+    struct iphdr   *ipv4 = NULL;
     struct ip6_hdr *ipv6 = NULL;
-    size_t len           = 0;
+    size_t          len  = 0;
 
     len = hip_get_msg_total_len(ctx->transport_hdr.hip);
 
@@ -253,9 +253,9 @@
 int midauth_verify_challenge_response(struct hip_common *hip,
                                       struct hip_challenge_response *s)
 {
-    int err = 0;
+    int                 err = 0;
     struct hip_solution solution;
-    uint8_t digist[HIP_AH_SHA_LEN];
+    uint8_t             digist[HIP_AH_SHA_LEN];
 
     HIP_IFEL(hip_build_digest(HIP_DIGEST_SHA1, s->opaque, 24, digist) < 0,
              -1, "Building of SHA1 Random seed I failed\n");
@@ -282,10 +282,10 @@
  */
 static int midauth_relocate_last_hip_parameter(struct hip_common *hip)
 {
-    int err                  = 0, len, total_len, offset;
-    char buffer[HIP_MAX_PACKET], *ptr = (char *) hip;
+    int                    err = 0, len, total_len, offset;
+    char                   buffer[HIP_MAX_PACKET], *ptr = (char *) hip;
     struct hip_tlv_common *i = NULL, *last = NULL;
-    hip_tlv type;
+    hip_tlv                type;
 
     while ((i = hip_get_next_param_readwrite(hip, i))) {
         last = i;
@@ -297,7 +297,7 @@
     len       = hip_get_param_total_len(last);
     type      = hip_get_param_type(last);
 
-    HIP_IFEL(len > (int)sizeof(buffer), -1,
+    HIP_IFEL(len > (int) sizeof(buffer), -1,
              "Last parameter's length exceeds HIP_MAX_PACKET\n");
 
     /* @todo check for signature parameter to avoid broken packets */
@@ -337,7 +337,7 @@
                                   uint8_t opaque_len)
 {
     struct hip_common *hip = ctx->transport_hdr.hip;
-    int err                = 0;
+    int                err = 0;
 
     ctx->modified = 1;
 
@@ -398,7 +398,7 @@
  */
 int midauth_filter_hip(struct hip_fw_context *ctx)
 {
-    int verdict               = NF_ACCEPT;
+    int             verdict   = NF_ACCEPT;
     midauth_handler h         = NULL;
     midauth_handler h_default = midauth_handler_accept;
     /* @todo change this default value to midauth_handler_drop to

=== modified file 'firewall/pisa.c'
--- firewall/pisa.c	2011-01-09 22:18:11 +0000
+++ firewall/pisa.c	2011-01-11 14:04:40 +0000
@@ -71,7 +71,7 @@
  * call */
 #define PISA_RANDOM_TTL 2.0
 
-static char pisa_random_data[2][PISA_RANDOM_LEN];
+static char            pisa_random_data[2][PISA_RANDOM_LEN];
 static struct in6_addr community_operator_hit;
 
 /* @todo make this configurable, issuer HIT */
@@ -127,7 +127,7 @@
 void pisa_check_for_random_update(void)
 {
     static time_t lastupdate = 0;
-    time_t now;
+    time_t        now;
 
     time(&now);
     if (difftime(now, lastupdate) > PISA_RANDOM_TTL) {
@@ -149,8 +149,8 @@
 static int pisa_append_hmac(struct in6_addr *hit1, struct in6_addr *hit2,
                             int rnd, void *data, int data_len)
 {
-    uint8_t key[32 + PISA_RANDOM_LEN];
-    int err          = 0;
+    uint8_t      key[32 + PISA_RANDOM_LEN];
+    int          err = 0;
     unsigned int len = HIP_AH_SHA_LEN;
 
     /* sanity checks for arguments */
@@ -187,8 +187,8 @@
 {
     uint8_t opaque[PISA_PUZZLE_OPAQUE_LEN];
 
-    struct hip_common *hip = ctx->transport_hdr.hip;
-    int seed               = PISA_PUZZLE_SEED;
+    struct hip_common *hip  = ctx->transport_hdr.hip;
+    int                seed = PISA_PUZZLE_SEED;
 
     memcpy(&opaque, &seed, 4);
 
@@ -206,12 +206,12 @@
  * @return pointer to the puzzle we accepted or NULL at failure
  */
 static struct hip_challenge_response *pisa_check_challenge_response(
-        struct hip_fw_context *ctx)
+    struct hip_fw_context *ctx)
 {
     struct hip_challenge_response *response;
-    struct hip_common *hip = ctx->transport_hdr.hip;
-    uint8_t hash[2][PISA_PUZZLE_OPAQUE_LEN];
-    int seed               = PISA_PUZZLE_SEED;
+    struct hip_common             *hip = ctx->transport_hdr.hip;
+    uint8_t                        hash[2][PISA_PUZZLE_OPAQUE_LEN];
+    int                            seed = PISA_PUZZLE_SEED;
 
     memcpy(&hash[0][0], &seed, 4);
     memcpy(&hash[1][0], &seed, 4);
@@ -235,7 +235,7 @@
 
         response = (struct hip_challenge_response *)
                    hip_get_next_param_readwrite(hip,
-                                           (struct hip_tlv_common *) response);
+                                                (struct hip_tlv_common *) response);
     }
 
     return NULL;
@@ -249,19 +249,19 @@
  */
 static int pisa_check_certificate(struct hip_fw_context *ctx)
 {
-    struct hip_common *hip = ctx->transport_hdr.hip;
-    const struct hip_cert *cert;
+    struct hip_common        *hip = ctx->transport_hdr.hip;
+    const struct hip_cert    *cert;
     struct hip_cert_spki_info ci;
-    struct pisa_cert pc;
-    char *buf              = NULL;
-    int err                = 0, len;
-    time_t now             = time(NULL);
+    struct pisa_cert          pc;
+    char                     *buf = NULL;
+    int                       err = 0, len;
+    time_t                    now = time(NULL);
 
     cert = hip_get_param(hip, HIP_PARAM_CERT);
     HIP_IFEL(cert == NULL, -1, "No certificate found.\n");
 
-    len  = ntohs(cert->length);
-    buf  = calloc(1, len);
+    len = ntohs(cert->length);
+    buf = calloc(1, len);
     memcpy(buf, cert + 1, len);
 
     HIP_IFEL(hip_cert_spki_char2certinfo(buf, &ci), -1,
@@ -307,7 +307,7 @@
 static void pisa_accept_connection(const struct hip_fw_context *ctx)
 {
     struct hip_common *hip = ctx->transport_hdr.hip;
-    struct tuple *t        = get_tuple_by_hits(&hip->hits, &hip->hitr);
+    struct tuple      *t   = get_tuple_by_hits(&hip->hits, &hip->hitr);
 
     if (t) {
         t->connection->pisa_state = PISA_STATE_ALLOW;
@@ -326,7 +326,7 @@
 static void pisa_remove_connection(const struct hip_fw_context *ctx)
 {
     struct hip_common *hip = ctx->transport_hdr.hip;
-    struct tuple *t        = get_tuple_by_hits(&hip->hits, &hip->hitr);
+    struct tuple      *t   = get_tuple_by_hits(&hip->hits, &hip->hitr);
 
     if (t) {
         t->connection->pisa_state = PISA_STATE_DISALLOW;
@@ -422,7 +422,7 @@
  */
 static int pisa_handler_r2(struct hip_fw_context *ctx)
 {
-    int verdict                             = NF_DROP, sig = 0, cert = 0;
+    int                            verdict  = NF_DROP, sig = 0, cert = 0;
     struct hip_challenge_response *solution = NULL;
 
 #ifdef CONFIG_HIP_PERFORMANCE
@@ -477,9 +477,9 @@
  */
 static int pisa_handler_u2(struct hip_fw_context *ctx)
 {
-    int verdict                             = NF_DROP;
-    int sig                                 = 0;
-    int cert                                = 0;
+    int                            verdict  = NF_DROP;
+    int                            sig      = 0;
+    int                            cert     = 0;
     struct hip_challenge_response *solution = NULL;
 
     solution = pisa_check_challenge_response(ctx);
@@ -507,8 +507,8 @@
  */
 static int pisa_handler_u3(struct hip_fw_context *ctx)
 {
-    int verdict                             = NF_DROP;
-    int sig                                 = 0;
+    int                            verdict  = NF_DROP;
+    int                            sig      = 0;
     struct hip_challenge_response *solution = NULL;
 
     solution = pisa_check_challenge_response(ctx);
@@ -538,6 +538,7 @@
     pisa_remove_connection(ctx);
     return NF_ACCEPT;
 }
+
 /**
  * Initialize basic PISA functionality
  *

=== modified file 'firewall/pisa_cert.c'
--- firewall/pisa_cert.c	2010-10-15 15:29:14 +0000
+++ firewall/pisa_cert.c	2011-01-11 14:04:40 +0000
@@ -54,8 +54,8 @@
  */
 static char *pisa_cert_get_part(char *cert, const char *name, char *r)
 {
-    int level = 0, len = 0;
-    char *p   = cert, *start = NULL;
+    int   level = 0, len = 0;
+    char *p     = cert, *start = NULL;
 
     if (!r) {
         return NULL;
@@ -137,7 +137,7 @@
 static void pisa_cert_get_content(char *cert, const char *name, char *r)
 {
     char *start = cert;
-    int len     = 0;
+    int   len   = 0;
 
     if (!r) {
         return;
@@ -180,8 +180,8 @@
  */
 void pisa_split_cert(char *cert, struct pisa_cert *pc)
 {
-    struct tm t;
-    char buffer1[224], buffer2[224];
+    struct tm       t;
+    char            buffer1[224], buffer2[224];
     struct in6_addr addr;
 
     pisa_cert_get_part(cert, "not-before", buffer1);

=== modified file 'firewall/port_bindings.c'
--- firewall/port_bindings.c	2010-11-29 08:58:13 +0000
+++ firewall/port_bindings.c	2011-01-11 14:04:40 +0000
@@ -75,10 +75,10 @@
  */
 static uint8_t *cache = NULL;
 
-static const unsigned int CACHE_SIZE_PROTOS = 2;
-static const unsigned int CACHE_SIZE_PORTS  = 1 << (sizeof(in_port_t) * 8);
-static unsigned int cache_size_entries      = 0;
-static unsigned int cache_size_bytes        = 0;
+static const unsigned int CACHE_SIZE_PROTOS  = 2;
+static const unsigned int CACHE_SIZE_PORTS   = 1 << (sizeof(in_port_t) * 8);
+static unsigned int       cache_size_entries = 0;
+static unsigned int       cache_size_bytes   = 0;
 
 /**
  * Allocate and initializes the cache resources.
@@ -93,17 +93,17 @@
 {
     HIP_ASSERT(!cache);
 
-    cache_size_entries  = CACHE_SIZE_PROTOS * CACHE_SIZE_PORTS;
-    cache_size_bytes    = cache_size_entries * sizeof(*cache);
+    cache_size_entries = CACHE_SIZE_PROTOS * CACHE_SIZE_PORTS;
+    cache_size_bytes   = cache_size_entries * sizeof(*cache);
 
     // check that the conversion used in the cache from enum hip_port_binding
     // to uint8_t is consistent
-    HIP_ASSERT(HIP_PORT_INFO_IPV6UNBOUND == (enum hip_port_binding)(uint8_t)HIP_PORT_INFO_IPV6UNBOUND);
-    HIP_ASSERT(HIP_PORT_INFO_IPV6BOUND == (enum hip_port_binding)(uint8_t)HIP_PORT_INFO_IPV6BOUND);
+    HIP_ASSERT(HIP_PORT_INFO_IPV6UNBOUND == (enum hip_port_binding) (uint8_t) HIP_PORT_INFO_IPV6UNBOUND);
+    HIP_ASSERT(HIP_PORT_INFO_IPV6BOUND == (enum hip_port_binding) (uint8_t) HIP_PORT_INFO_IPV6BOUND);
 
     /* We zero the cache on allocation assuming that HIP_PORT_INFO_UNKNOWN
-    is 0 and thus the whole cache initially has that value. */
-    HIP_ASSERT((uint8_t)HIP_PORT_INFO_UNKNOWN == 0);
+     * is 0 and thus the whole cache initially has that value. */
+    HIP_ASSERT((uint8_t) HIP_PORT_INFO_UNKNOWN == 0);
     cache = calloc(1, cache_size_bytes);
     if (cache) {
         return 0;
@@ -146,8 +146,8 @@
 static inline unsigned int get_cache_index(const uint8_t protocol,
                                            const uint16_t port)
 {
-    unsigned int index              = 0;
-    unsigned int protocol_offset    = 0;
+    unsigned int index           = 0;
+    unsigned int protocol_offset = 0;
 
     // determine the offset into the first (protocol) dimension
     if (IPPROTO_TCP == protocol) {
@@ -190,7 +190,7 @@
         const unsigned int index = get_cache_index(protocol, port);
 
         // convert the port binding to the cache storage type
-        const uint8_t value = (uint8_t)binding;
+        const uint8_t value = (uint8_t) binding;
 
         cache[index] = value;
     }
@@ -225,7 +225,7 @@
     if (cache) {
         const unsigned int index = get_cache_index(protocol, port);
 
-        binding = (enum hip_port_binding)cache[index];
+        binding = (enum hip_port_binding) cache[index];
     }
 
     return binding;
@@ -244,11 +244,6 @@
     }
 }
 
-
-
-
-
-
 static struct hip_file_buffer tcp6_file;
 static struct hip_file_buffer udp6_file;
 
@@ -321,11 +316,11 @@
 static enum hip_port_binding hip_port_bindings_get_from_proc(const uint8_t protocol,
                                                              const uint16_t port)
 {
-    const unsigned int PORT_STR_OFFSET  = 39;
-    const unsigned int PORT_STR_LEN     = 4;
-    enum hip_port_binding result        = HIP_PORT_INFO_IPV6UNBOUND;
-    const struct hip_mem_area *ma       = NULL;
-    char *line;
+    const unsigned int         PORT_STR_OFFSET = 39;
+    const unsigned int         PORT_STR_LEN    = 4;
+    enum hip_port_binding      result          = HIP_PORT_INFO_IPV6UNBOUND;
+    const struct hip_mem_area *ma              = NULL;
+    char                      *line;
     // the files /proc/net/{udp,tcp}6 are line-based and the line number of the
     // port to look up is not known in advance
     // -> use a parser that lets us iterate over the lines in the files
@@ -353,11 +348,11 @@
 
     // is the current line valid and is it long enough to hold a port binding?
     while (line && ma->end > (line + PORT_STR_OFFSET + PORT_STR_LEN)) {
-        const unsigned int PORT_BASE_HEX    = 16;
-        unsigned long proc_port             = 0;
+        const unsigned int PORT_BASE_HEX = 16;
+        unsigned long      proc_port     = 0;
         // note that strtoul() is about 10 times faster than sscanf().
-        errno       = 0;
-        proc_port   = strtoul(line + PORT_STR_OFFSET, NULL, PORT_BASE_HEX);
+        errno     = 0;
+        proc_port = strtoul(line + PORT_STR_OFFSET, NULL, PORT_BASE_HEX);
         if (0 == errno) {
             if (proc_port == port) {
                 result = HIP_PORT_INFO_IPV6BOUND;

=== modified file 'firewall/reinject.c'
--- firewall/reinject.c	2011-01-09 14:59:33 +0000
+++ firewall/reinject.c	2011-01-11 14:04:40 +0000
@@ -77,8 +77,8 @@
     err = setsockopt(*firewall_raw_sock_v6, IPPROTO_IPV6,
                      IPV6_RECVERR, &off, sizeof(on));
     HIP_IFEL(err, -1, "setsockopt recverr failed\n");
-    err  = setsockopt(*firewall_raw_sock_v6, IPPROTO_IPV6,
-                      IPV6_2292PKTINFO, &on, sizeof(on));
+    err = setsockopt(*firewall_raw_sock_v6, IPPROTO_IPV6,
+                     IPV6_2292PKTINFO, &on, sizeof(on));
     HIP_IFEL(err, -1, "setsockopt pktinfo failiped\n");
     err = setsockopt(*firewall_raw_sock_v6, SOL_SOCKET,
                      SO_REUSEADDR, &on, sizeof(on));
@@ -365,16 +365,16 @@
                                    int proto,
                                    int ttl)
 {
-    int err               = 0, sent, sa_size;
-    int firewall_raw_sock = 0, is_ipv6 = 0, on = 1;
-    struct ip *iphdr      = NULL;
-    struct udphdr *udp    = NULL;
-    struct tcphdr *tcp    = NULL;
-    struct icmphdr *icmp  = NULL;
+    int                     err               = 0, sent, sa_size;
+    int                     firewall_raw_sock = 0, is_ipv6 = 0, on = 1;
+    struct ip              *iphdr             = NULL;
+    struct udphdr          *udp               = NULL;
+    struct tcphdr          *tcp               = NULL;
+    struct icmphdr         *icmp              = NULL;
     struct sockaddr_storage src, dst;
-    struct sockaddr_in6 *sock_src6 = NULL, *sock_dst6 = NULL;
-    struct sockaddr_in *sock_src4 = NULL, *sock_dst4 = NULL;
-    struct in6_addr any   = IN6ADDR_ANY_INIT;
+    struct sockaddr_in6    *sock_src6 = NULL, *sock_dst6 = NULL;
+    struct sockaddr_in     *sock_src4 = NULL, *sock_dst4 = NULL;
+    struct in6_addr         any       = IN6ADDR_ANY_INIT;
 
     HIP_ASSERT(src_hit != NULL && dst_hit != NULL);
 
@@ -391,7 +391,7 @@
         sock_dst4->sin_family = AF_INET;
         IPV6_TO_IPV4_MAP(src_hit, &(sock_src4->sin_addr));
         IPV6_TO_IPV4_MAP(dst_hit, &(sock_dst4->sin_addr));
-        sa_size               = sizeof(struct sockaddr_in);
+        sa_size = sizeof(struct sockaddr_in);
         HIP_DEBUG_LSI("src4 addr ", &(sock_src4->sin_addr));
         HIP_DEBUG_LSI("dst4 addr ", &(sock_dst4->sin_addr));
     } else {
@@ -399,8 +399,8 @@
         ipv6_addr_copy(&sock_src6->sin6_addr, src_hit);
         sock_dst6->sin6_family = AF_INET6;
         ipv6_addr_copy(&sock_dst6->sin6_addr, dst_hit);
-        sa_size                = sizeof(struct sockaddr_in6);
-        is_ipv6                = 1;
+        sa_size = sizeof(struct sockaddr_in6);
+        is_ipv6 = 1;
     }
 
     switch (proto) {
@@ -409,21 +409,21 @@
             HIP_DEBUG(" IPPROTO_UDP v6\n");
             firewall_raw_sock              = firewall_raw_sock_udp_v6;
             ((struct udphdr *) msg)->check = ipv6_checksum(IPPROTO_UDP,
-                                               &sock_src6->sin6_addr,
-                                               &sock_dst6->sin6_addr, msg, len);
+                                                           &sock_src6->sin6_addr,
+                                                           &sock_dst6->sin6_addr, msg, len);
         } else {
             HIP_DEBUG(" IPPROTO_UDP v4\n");
             firewall_raw_sock = firewall_raw_sock_udp_v4;
 
-            udp               = (struct udphdr *) msg;
-
-            sa_size           = sizeof(struct sockaddr_in);
-
-            udp->check        = htons(0);
-            udp->check        = ipv4_checksum(IPPROTO_UDP,
-                                              (uint8_t *) &(sock_src4->sin_addr),
-                                              (uint8_t *) &(sock_dst4->sin_addr),
-                                              (uint8_t *) udp, len);
+            udp = (struct udphdr *) msg;
+
+            sa_size = sizeof(struct sockaddr_in);
+
+            udp->check = htons(0);
+            udp->check = ipv4_checksum(IPPROTO_UDP,
+                                       (uint8_t *) &(sock_src4->sin_addr),
+                                       (uint8_t *) &(sock_dst4->sin_addr),
+                                       (uint8_t *) udp, len);
             memmove(msg + sizeof(struct ip), udp, len);
         }
         break;
@@ -440,10 +440,10 @@
             HIP_DEBUG(" IPPROTO_TCP v4\n");
             firewall_raw_sock = firewall_raw_sock_tcp_v4;
 
-            tcp->check        = ipv4_checksum(IPPROTO_TCP,
-                                              (uint8_t *) &(sock_src4->sin_addr),
-                                              (uint8_t *) &(sock_dst4->sin_addr),
-                                              (uint8_t *) tcp, len);
+            tcp->check = ipv4_checksum(IPPROTO_TCP,
+                                       (uint8_t *) &(sock_src4->sin_addr),
+                                       (uint8_t *) &(sock_dst4->sin_addr),
+                                       (uint8_t *) tcp, len);
 
             memmove(msg + sizeof(struct ip), tcp, len);
         }
@@ -486,7 +486,7 @@
         sent = sendto(firewall_raw_sock, iphdr,
                       iphdr->ip_len, 0,
                       (struct sockaddr *) &dst, sa_size);
-        if (sent != (int)(len + sizeof(struct ip))) {
+        if (sent != (int) (len + sizeof(struct ip))) {
             HIP_ERROR("Could not send the all requested" \
                       " data (%d/%d)\n", sent,
                       iphdr->ip_len);
@@ -535,9 +535,9 @@
     int firewall_raw_sock = 0, is_ipv6 = 0;
 
     struct sockaddr_storage src, dst;
-    struct sockaddr_in6 *sock_src6, *sock_dst6;
-    struct sockaddr_in *sock_src4, *sock_dst4;
-    struct in6_addr any = IN6ADDR_ANY_INIT;
+    struct sockaddr_in6    *sock_src6, *sock_dst6;
+    struct sockaddr_in     *sock_src4, *sock_dst4;
+    struct in6_addr         any = IN6ADDR_ANY_INIT;
 
     HIP_ASSERT(src_hit != NULL && dst_hit != NULL);
 
@@ -554,7 +554,7 @@
         IPV6_TO_IPV4_MAP(src_hit, &sock_src4->sin_addr);
         sock_dst4->sin_family = AF_INET;
         IPV6_TO_IPV4_MAP(dst_hit, &sock_dst4->sin_addr);
-        sa_size               = sizeof(struct sockaddr_in);
+        sa_size = sizeof(struct sockaddr_in);
         HIP_DEBUG_LSI("src4 addr ", &(sock_src4->sin_addr));
         HIP_DEBUG_LSI("dst4 addr ", &(sock_dst4->sin_addr));
     } else {
@@ -562,8 +562,8 @@
         ipv6_addr_copy(&sock_src6->sin6_addr, src_hit);
         sock_dst6->sin6_family = AF_INET6;
         ipv6_addr_copy(&sock_dst6->sin6_addr, dst_hit);
-        sa_size                = sizeof(struct sockaddr_in6);
-        is_ipv6                = 1;
+        sa_size = sizeof(struct sockaddr_in6);
+        is_ipv6 = 1;
         HIP_DEBUG_HIT("src6 addr ", &(sock_src6->sin6_addr));
         HIP_DEBUG_HIT("dst6 addr ", &(sock_dst6->sin6_addr));
     }
@@ -574,13 +574,13 @@
         if (is_ipv6) {
             firewall_raw_sock = firewall_raw_sock_tcp_v6;
             ((struct tcphdr *) msg)->check
-                    = ipv6_checksum(IPPROTO_TCP, &sock_src6->sin6_addr,
-                                       &sock_dst6->sin6_addr, msg, len);
+                = ipv6_checksum(IPPROTO_TCP, &sock_src6->sin6_addr,
+                                &sock_dst6->sin6_addr, msg, len);
         } else {
             firewall_raw_sock = firewall_raw_sock_tcp_v4;
             ((struct tcphdr *) msg)->check
-                    = ipv4_checksum(IPPROTO_TCP, (uint8_t *) &(sock_src4->sin_addr),
-                                       (uint8_t *) &(sock_dst4->sin_addr), msg, len);
+                = ipv4_checksum(IPPROTO_TCP, (uint8_t *) &(sock_src4->sin_addr),
+                                (uint8_t *) &(sock_dst4->sin_addr), msg, len);
         }
         break;
     case IPPROTO_UDP:
@@ -592,13 +592,13 @@
         if (is_ipv6) {
             firewall_raw_sock = firewall_raw_sock_udp_v6;
             ((struct udphdr *) msg)->check
-                    = ipv6_checksum(IPPROTO_UDP, &sock_src6->sin6_addr,
-                                       &sock_dst6->sin6_addr, msg, len);
+                = ipv6_checksum(IPPROTO_UDP, &sock_src6->sin6_addr,
+                                &sock_dst6->sin6_addr, msg, len);
         } else {
             firewall_raw_sock = firewall_raw_sock_udp_v4;
             ((struct udphdr *) msg)->check
-                    = ipv4_checksum(IPPROTO_UDP, (uint8_t *) &(sock_src4->sin_addr),
-                                       (uint8_t *) &(sock_dst4->sin_addr), msg, len);
+                = ipv4_checksum(IPPROTO_UDP, (uint8_t *) &(sock_src4->sin_addr),
+                                (uint8_t *) &(sock_dst4->sin_addr), msg, len);
         }
         break;
     case IPPROTO_ICMP:
@@ -613,11 +613,11 @@
 
         break;
     case IPPROTO_ICMPV6:
-        firewall_raw_sock = firewall_raw_sock_icmp_v6;
+        firewall_raw_sock                       = firewall_raw_sock_icmp_v6;
         ((struct icmp6_hdr *) msg)->icmp6_cksum = htons(0);
         ((struct icmp6_hdr *) msg)->icmp6_cksum
-                = ipv6_checksum(IPPROTO_ICMPV6, &sock_src6->sin6_addr,
-                                   &sock_dst6->sin6_addr, msg, len);
+            = ipv6_checksum(IPPROTO_ICMPV6, &sock_src6->sin6_addr,
+                            &sock_dst6->sin6_addr, msg, len);
         break;
 
     case IPPROTO_ESP:

=== modified file 'firewall/rule_management.c'
--- firewall/rule_management.c	2011-01-10 15:23:36 +0000
+++ firewall/rule_management.c	2011-01-11 14:04:40 +0000
@@ -127,9 +127,9 @@
 static void check_and_write_default_config(const char *file)
 {
     struct stat status;
-    FILE *fp = NULL;
-    ssize_t items;
-    int i    = 0;
+    FILE       *fp = NULL;
+    ssize_t     items;
+    int         i = 0;
 
     /* Firewall depends on hipd to create HIPL_SYSCONFDIR */
     for (i = 0; i < 5; i++) {
@@ -269,8 +269,8 @@
  */
 void print_rule_tables(void)
 {
-    struct dlist *list  = input_rules;
-    struct rule *rule   = NULL;
+    struct dlist *list = input_rules;
+    struct rule  *rule = NULL;
     while (list != NULL) {
         rule = list->data;
         print_rule(rule);
@@ -359,7 +359,7 @@
 static struct hit_option *parse_hit(char *token)
 {
     struct hit_option *option = malloc(sizeof(struct hit_option));
-    struct in6_addr *hit      = NULL;
+    struct in6_addr   *hit    = NULL;
 
     if (!strcmp(token, NEGATE_STR)) {
         option->boolean = 0;
@@ -388,10 +388,10 @@
  */
 static int load_rsa_file(FILE *fp, struct hip_host_id *hi)
 {
-    int err                     = 0;
-    RSA *rsa                    = NULL;
-    unsigned char *rsa_key_rr   = NULL;
-    int rsa_key_rr_len;
+    int            err        = 0;
+    RSA           *rsa        = NULL;
+    unsigned char *rsa_key_rr = NULL;
+    int            rsa_key_rr_len;