eap_protocol.c

00001 /*
00002  * Copyright (c) 2017-2019, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 
00019 #include "nsconfig.h"
00020 
00021 #include "ns_types.h"
00022 #include "eventOS_event.h"
00023 #include "ns_trace.h"
00024 #include "string.h"
00025 #include "Core/include/ns_socket.h"
00026 #include "NWK_INTERFACE/Include/protocol.h"
00027 #include "6LoWPAN/Bootstraps/protocol_6lowpan.h"
00028 #include "6LoWPAN/Bootstraps/protocol_6lowpan_bootstrap.h"
00029 #ifdef ECC
00030 #include "libX509_V3.h"
00031 #include "ecc.h"
00032 #endif
00033 #include "Security/Common/sec_lib.h"
00034 #include "net_nvm_api.h"
00035 #include "Security/PANA/pana.h"
00036 
00037 #include "common_functions.h"
00038 #include "Security/PANA/pana_eap_header.h"
00039 #ifdef PANA
00040 
00041 #define TRACE_GROUP "eap"
00042 
00043 const uint8_t EAP_ANYMOUS[9] = {'a', 'n', 'o', 'n', 'y', 'm', 'o', 'u', 's'};
00044 
00045 static bool force_frag_last_retry = false;
00046 
00047 static bool force_frag_start_fail = false;
00048 
00049 static bool force_frag_timeout = false;
00050 
00051 static void eap_seq_back_to_accept(sec_suite_t *suite)
00052 {
00053     if (suite->pana_session.eap_id_seq == 0) {
00054         suite->pana_session.eap_id_seq = 0xff;
00055     } else {
00056         suite->pana_session.eap_id_seq--;
00057     }
00058 }
00059 
00060 void pana_eap_fragmetation_start_filter(bool state)
00061 {
00062     tr_debug("Set start state %u", state);
00063     force_frag_start_fail = state;
00064 }
00065 
00066 void pana_eap_fragmetation_force_timeout(bool state)
00067 {
00068     force_frag_timeout = state;
00069 }
00070 
00071 void pana_eap_fragmetation_force_retry(bool state)
00072 {
00073     force_frag_last_retry = state;
00074 }
00075 
00076 static buffer_t *eap_common_headroom_get_to_buffer(buffer_t *buf, uint16_t header_size)
00077 {
00078     if ((buf = buffer_headroom(buf, header_size)) == 0) {
00079         return NULL;
00080     }
00081     buffer_data_reserve_header(buf, header_size);
00082     return buf;
00083 }
00084 
00085 void pana_eap_identity_build(buffer_t *buf, sec_suite_t *suite)
00086 {
00087     uint8_t *ptr;
00088     uint8_t eap_code;
00089     buf->buf_ptr  = 0;
00090     const uint8_t *nonce_ptr;
00091     if (suite->pana_session.user_server) {
00092         buf->buf_end  = 0;
00093         eap_code = EAP_REQ;
00094         nonce_ptr = suite->pana_session.pana_heap->agent_nonce;
00095     } else {
00096 
00097         buf->buf_end  = 9;
00098         ptr = buf->buf ;
00099         memcpy(ptr, EAP_ANYMOUS, 9);
00100         eap_code = EAP_RESPONSE;
00101         nonce_ptr = suite->pana_session.pana_heap->client_nonce;
00102     }
00103 
00104     buf = eap_common_headroom_get_to_buffer(buf, eap_header_size(eap_code));
00105     if (!buf) {
00106         return;
00107     }
00108 
00109     eap_header_build(buffer_data_pointer(buf), buffer_data_length(buf), eap_code, suite->pana_session.eap_id_seq, EAP_IDENTITY);
00110 
00111     pana_eap_payload_down(buf, nonce_ptr, suite);
00112     tr_warn("TX EAP Identity!");
00113 }
00114 
00115 void pana_eap_tls_start_build(buffer_t *buf, sec_suite_t *suite)
00116 {
00117     buf->buf_ptr  = 0;
00118     buf->buf_end  = 0;
00119     if (suite->tls_session->tls_heap) {
00120         tls_heap_t *tls_heap = suite->tls_session->tls_heap;
00121         tls_heap->tls_handshake_h_len = 0;
00122     }
00123 
00124     uint8_t header_size = eap_header_size(EAP_REQ);
00125     header_size += eap_tls_header_size(EAP_TLS_START);
00126 
00127     buf = eap_common_headroom_get_to_buffer(buf, header_size);
00128     if (!buf) {
00129         return;
00130     }
00131 
00132     uint8_t *ptr = eap_header_build(buffer_data_pointer(buf), buffer_data_length(buf), EAP_REQ, suite->pana_session.eap_id_seq, EAP_TLS);
00133 
00134     eap_tls_header_build(ptr, EAP_TLS_START, 0);
00135 
00136     pana_eap_payload_down(buf, NULL, suite);
00137 
00138 }
00139 
00140 
00141 void pana_eap_tls_finnish_build(buffer_t *buf, sec_suite_t *suite)
00142 {
00143     buffer_data_clear(buf);
00144     uint8_t eap_code;
00145     if (suite->state == TLS_ALERT) {
00146         eap_code = EAP_FAILURE;
00147     } else {
00148         eap_code = EAP_RESPONSE;
00149     }
00150 
00151 
00152     uint8_t header_size = eap_header_size(eap_code);
00153     header_size += eap_tls_header_size(0);
00154 
00155     buf = eap_common_headroom_get_to_buffer(buf, header_size);
00156     if (!buf) {
00157         return;
00158     }
00159 
00160     uint8_t *ptr = eap_header_build(buffer_data_pointer(buf), buffer_data_length(buf), eap_code, suite->pana_session.eap_id_seq, EAP_TLS);
00161 
00162     eap_tls_header_build(ptr, 0, 0);
00163 
00164     pana_eap_payload_down(buf, NULL, suite);
00165 }
00166 
00167 bool pana_eap_frag_re_tx(sec_suite_t *suite)
00168 {
00169     buffer_t *f_buf;
00170     if (suite->pana_session.eap_assy_buf) {
00171         buffer_t *buf = 0;
00172         f_buf = buffer_get(suite->pana_session.last_assy_size + 50);
00173         buf = suite->pana_session.eap_assy_buf;
00174         if (f_buf) {
00175             memcpy(buffer_data_pointer(f_buf), buffer_data_pointer(buf) + suite->pana_session.assy_off_set, suite->pana_session.last_assy_size);
00176             buffer_data_length_set(f_buf, suite->pana_session.last_assy_size);
00177             goto success_push;
00178         }
00179     } else if (suite->pana_session.eap_frag_buf || suite->pana_session.packet_delivered) {
00180         f_buf = buffer_get(127);
00181         if (f_buf) {
00182 
00183             //tr_debug("EAP assembly re REQ timer");
00184             f_buf->buf_ptr  = f_buf->buf_end ;
00185             goto success_push;
00186         }
00187     }
00188     return false;
00189 success_push:
00190     f_buf->interface  = suite->interface;
00191     memcpy(f_buf->dst_sa .address , suite->session_address, 16);
00192     f_buf->src_sa .addr_type  = ADDR_NONE ;
00193     pana_eap_down(f_buf, suite);
00194     return true;
00195 }
00196 
00197 buffer_t *eap_down(buffer_t *buf, sec_suite_t *suite)
00198 {
00199     //tr_debug("EAP Down");
00200     uint16_t tls_payload_len = 0;
00201     uint8_t eap_code;
00202     uint8_t eap_tls_flags = 0;
00203     tls_payload_len = buffer_data_length(buf);
00204     if (tls_payload_len >  EAP_MTU_SIZE) {
00205         //Check Fragmentation
00206         if (suite->pana_session.assy_length) {
00207             tr_debug("Already Fragmentation");
00208             buffer_free(buf);
00209             buf = (buffer_t *)0;
00210             return buf;
00211         } else {
00212             pana_lib_parameters_s *parameters = pana_parameters_get();
00213 
00214             buffer_t *f_buf = buffer_get(parameters->EAP_FRAGMENT_SIZE + 50);
00215             buf->seq  = suite->pana_session.eap_id_seq;
00216             suite->pana_session.eap_assy_buf  = buf;
00217             suite->pana_session.assy_length = tls_payload_len;
00218             suite->pana_session.assy_off_set = 0;
00219             suite->pana_session.last_assy_size = parameters->EAP_FRAGMENT_SIZE;
00220             if (suite->pana_session.user_server) {
00221                 //tr_debug("Set Re Tx Timer");
00222                 pana_timeout_timer_set(suite, suite->state);
00223             } else {
00224                 sec_set_auth_timeout(suite, TLS_KEY_CHANGE);
00225             }
00226             if (f_buf) {
00227                 f_buf->interface  = suite->interface;
00228                 eap_tls_flags = EAP_TLS_FRAGMENT_LENGTH | EAP_TLS_MORE_FRAGMENTS;
00229                 memcpy(buffer_data_pointer(f_buf), buffer_data_pointer(buf), parameters->EAP_FRAGMENT_SIZE);
00230                 memcpy(f_buf->dst_sa .address , buf->src_sa .address , 16);
00231                 buf->src_sa .addr_type  = ADDR_NONE ;
00232                 f_buf->src_sa .addr_type  = ADDR_NONE ;
00233                 buffer_data_length_set(f_buf, parameters->EAP_FRAGMENT_SIZE);
00234                 buf = f_buf;
00235 
00236             } else {
00237                 return NULL;
00238             }
00239         }
00240     } else {
00241         if (suite->pana_session.assy_length) {
00242             if (suite->pana_session.assy_length > (suite->pana_session.assy_off_set + suite->pana_session.last_assy_size)) {
00243                 eap_tls_flags = EAP_TLS_MORE_FRAGMENTS;
00244                 if (suite->pana_session.assy_off_set == 0) {
00245                     eap_tls_flags |= EAP_TLS_FRAGMENT_LENGTH;
00246                     //tr_debug("Retry First");
00247                 }
00248             }
00249         }
00250     }
00251 
00252     if (suite->pana_session.user_server) {
00253         eap_code = EAP_REQ;
00254     } else {
00255         eap_code = EAP_RESPONSE;
00256     }
00257 
00258     uint8_t header_size = eap_header_size(eap_code);
00259     header_size += eap_tls_header_size(eap_tls_flags);
00260 
00261     buf = eap_common_headroom_get_to_buffer(buf, header_size);
00262     if (!buf) {
00263         return NULL;
00264     }
00265 
00266     uint8_t *ptr = eap_header_build(buffer_data_pointer(buf), buffer_data_length(buf), eap_code, suite->pana_session.eap_id_seq, EAP_TLS);
00267 
00268     eap_tls_header_build(ptr, eap_tls_flags, suite->pana_session.assy_length);
00269 
00270     return (buf);
00271 }
00272 
00273 buffer_t *eap_up(buffer_t *buf, sec_suite_t *suite)
00274 {
00275     eap_header_t header;
00276     uint8_t *ptr = buffer_data_pointer(buf);
00277     uint16_t payload_length = buffer_data_length(buf);
00278     uint8_t response_counter = suite->retry_counter;
00279     if (!eap_header_parse(ptr, payload_length, &header)) {
00280         return buffer_free(buf);
00281     }
00282 
00283     if (header.eap_code == EAP_RESPONSE) {
00284         if (header.id_seq != suite->pana_session.eap_id_seq) {
00285             tr_warn("EAP:Drop Packet by ID");
00286             suite->timer = 65;
00287             return buffer_free(buf);
00288         }
00289         //tr_debug("EAP RES");
00290         suite->pana_session.eap_id_seq++;
00291         suite->retry_counter = 0;
00292     } else if (header.eap_code == EAP_REQ) {
00293 
00294         if (header.type == EAP_IDENTITY) {
00295             suite->pana_session.eap_id_seq = header.id_seq;
00296         } else {
00297 
00298             uint8_t eap_seq = suite->pana_session.eap_id_seq;
00299             if (eap_seq == 0xff) {
00300                 eap_seq = 0;
00301             } else {
00302                 eap_seq++;
00303             }
00304 
00305             if (eap_seq != header.id_seq) {
00306                 if (suite->pana_session.eap_id_seq == header.id_seq) {
00307                     //tr_debug("EAP:Same SEQ");
00308                     if (suite->pana_session.assy_length) {
00309                         tr_debug("SEND ACK. Should send same packet again");
00310                     } else if (suite->pana_session.frag_length) {
00311                         tr_debug("SEND ACK. Should send same packet again");
00312                         buf->buf_ptr  = buf->buf_end ;
00313                         buf = buffer_turnaround(buf);
00314                         memcpy(buf->dst_sa .address , buf->src_sa .address , 16);
00315                         buf->src_sa .addr_type  = ADDR_NONE ;
00316                         return buf;
00317                     } else {
00318                         tr_debug("REQ but Frag ready");
00319                         return buffer_free(buf);
00320                     }
00321                 } else {
00322                     tr_debug("EAP:Drop unknown Req ID. MSG: %x, ses: %x", header.id_seq, suite->pana_session.eap_id_seq);
00323                     return buffer_free(buf);
00324                 }
00325             } else {
00326                 suite->pana_session.eap_id_seq = header.id_seq;
00327             }
00328         }
00329     }
00330 
00331     switch (header.type) {
00332         case EAP_IDENTITY:
00333             if (header.eap_code == EAP_REQ) {
00334                 sec_lib_state_machine_trig(suite, EAP_IDENTITY_RES);
00335             } else {
00336 #ifdef PANA_SERVER_API
00337                 if (suite->pana_session.user_server) {
00338                     sec_lib_state_machine_trig(suite, TLS_START);
00339                 }
00340 #endif
00341             }
00342             return buffer_free(buf);
00343 
00344         case EAP_TLS:
00345         case EAP_TTLS: {
00346             eap_tls_header_t eap_tls_header;
00347             if (!eap_tls_header_parse(header.data_ptr, header.length - 5, &eap_tls_header)) {
00348                 return buffer_free(buf);
00349             }
00350 
00351             if (eap_tls_header.eap_tls_flags & EAP_TLS_START) {
00352                 suite->pana_session.eap_id_seq = header.id_seq;
00353                 sec_lib_state_machine_trig(suite, TLS_INIT);
00354                 return buffer_free(buf);
00355             }
00356             buffer_data_pointer_set(buf, eap_tls_header.data_ptr);
00357 
00358             if (header.eap_code == EAP_RESPONSE) {
00359                 if (eap_tls_header.eap_tls_flags) {
00360                     if (suite->pana_session.assy_length) {
00361                         suite->pana_session.assy_off_set += suite->pana_session.last_assy_size;
00362                         if (suite->pana_session.assy_off_set < suite->pana_session.assy_length) {
00363                             tr_warn("Packet TX process fail");
00364                         } else {
00365                             tr_debug("EAP Frag TX Done & Start RX frag");
00366 
00367                         }
00368                         //tr_debug("Free Frag Buf");
00369                         if (suite->pana_session.eap_assy_buf) {
00370                             tr_debug("Free Frag Buf");
00371                             buffer_free(suite->pana_session.eap_assy_buf);
00372                             suite->pana_session.eap_assy_buf  = NULL;
00373                         }
00374                         suite->pana_session.assy_length = 0;
00375                         suite->pana_session.assy_off_set = 0;
00376                         suite->pana_session.last_assy_size = 0;
00377                         suite->pana_session.packet_delivered = true;
00378                         suite->retry_counter = 0;
00379                     }
00380                 }
00381             }
00382 
00383             if ((eap_tls_header.eap_tls_flags & EAP_TLS_MORE_FRAGMENTS) == 0) {
00384                 if (suite->pana_session.frag_length) {
00385                     if (force_frag_last_retry || force_frag_timeout) {
00386                         force_frag_last_retry = false;
00387                         if (header.eap_code == EAP_RESPONSE) {
00388                             suite->retry_counter = response_counter;
00389                         }
00390                         eap_seq_back_to_accept(suite);
00391                         return buffer_free(buf);
00392                     }
00393                     buffer_t *t_buf = suite->pana_session.eap_frag_buf;
00394 
00395                     uint16_t check_len = suite->pana_session.frag_off_set;
00396                     check_len += eap_tls_header.tls_frame_length;
00397                     suite->pana_session.eap_frag_buf = NULL;
00398                     suite->pana_session.frag_length = 0;
00399                     if (check_len == buffer_data_length(t_buf)) {
00400                         memcpy(buffer_data_pointer(t_buf) + suite->pana_session.frag_off_set, eap_tls_header.data_ptr, eap_tls_header.tls_frame_length);
00401                         t_buf->seq  = header.id_seq;
00402                         tr_debug("Full packet RX");
00403                         buffer_free(buf);
00404                         buf = t_buf;
00405                         suite->pana_session.frag_off_set = 0;
00406                     } else {
00407 
00408                         buffer_free(t_buf);
00409                         suite->pana_session.frag_off_set = 0;
00410                         sec_lib_state_machine_trig(suite, TLS_ALERT_INTERNAL);
00411                         return buffer_free(buf);
00412                     }
00413                 } else if (suite->pana_session.assy_length) {
00414                     buffer_t *t_buf = suite->pana_session.eap_assy_buf;
00415                     if (header.eap_code == EAP_RESPONSE) {
00416                         suite->pana_session.assy_off_set += suite->pana_session.last_assy_size;
00417                         if (eap_tls_header.tls_frame_length == 0) {
00418                             t_buf->seq  = header.id_seq;
00419                         }
00420                     } else {
00421                         uint8_t cmp_seq = t_buf->seq ;
00422                         if (cmp_seq == 0xff) {
00423                             cmp_seq = 0;
00424                         } else {
00425                             cmp_seq++;
00426                         }
00427                         if (cmp_seq == header.id_seq) {
00428                             suite->pana_session.assy_off_set += suite->pana_session.last_assy_size;
00429                             if (eap_tls_header.tls_frame_length == 0) {
00430                                 t_buf->seq  = header.id_seq;
00431                             }
00432                         } else {
00433                             tr_debug("RETX");
00434                         }
00435                     }
00436                     if (suite->pana_session.assy_off_set < suite->pana_session.assy_length) {
00437                         if (eap_tls_header.tls_frame_length == 0) {
00438                             uint16_t len = 0;
00439                             buffer_t *f_buf = 0;
00440                             buffer_free(buf);
00441                             suite->retry_counter = 0;
00442                             pana_lib_parameters_s *parameters = pana_parameters_get();
00443                             if (suite->pana_session.assy_off_set + parameters->EAP_FRAGMENT_SIZE < suite->pana_session.assy_length) {
00444                                 len = parameters->EAP_FRAGMENT_SIZE;
00445                             } else {
00446                                 len = suite->pana_session.assy_length - suite->pana_session.assy_off_set;
00447                             }
00448 
00449                             f_buf = buffer_get(len + 50);
00450                             if (f_buf) {
00451                                 //memcpy(f_buf->dst_sa.address, t_buf->src_sa.address, 16);
00452                                 f_buf->interface  = suite->interface;
00453                                 f_buf->src_sa .addr_type  = ADDR_NONE ;
00454                                 f_buf->dst_sa .addr_type  = ADDR_NONE ;
00455                                 memcpy(buffer_data_pointer(f_buf), buffer_data_pointer(t_buf) + suite->pana_session.assy_off_set, len);
00456                                 buffer_data_length_set(f_buf, len);
00457                                 suite->pana_session.last_assy_size = len;
00458                                 tr_debug("Push frag");
00459                                 return (f_buf);
00460                             } else {
00461                                 tr_warn("No Mem");
00462                                 return NULL;
00463                             }
00464                         } else {
00465                             //IT cuold be alert
00466                             buf->session_ptr = suite;
00467                             eap_tls_payload_push(buf);
00468                             return NULL;
00469                         }
00470                     } else {
00471                         tr_debug("EAP Frag TX Done");
00472                         suite->pana_session.eap_assy_buf  = buffer_free(t_buf);
00473                         suite->pana_session.assy_length = 0;
00474                         suite->pana_session.assy_off_set = 0;
00475                         suite->pana_session.last_assy_size = 0;
00476                     }
00477                 } else if (!eap_tls_header.tls_frame_length) {
00478                     if (header.eap_code == EAP_RESPONSE) {
00479 #ifdef PANA_SERVER_API
00480                         if (suite->state == TLS_KEY_CHANGE && suite->pana_session.user_server) {
00481                             //tr_debug("TLS Auth Ready");
00482                             pana_key_calculation(suite);
00483                             sec_lib_state_machine_trig(suite, TLS_EAP_END_PANA_VERIFY);
00484                         }
00485 #endif
00486                     }
00487 
00488                     return buffer_free(buf);
00489                 }
00490                 buf->session_ptr = suite;
00491                 eap_tls_payload_push(buf);
00492                 return NULL;
00493 
00494             }
00495 
00496             //More flag is active
00497             if (!eap_tls_header.tls_frame_length) {
00498                 tr_debug("More without Data");
00499                 return buffer_free(buf);
00500             }
00501             bool skip_packet = false;
00502 
00503             if (eap_tls_header.tls_length) {
00504                 //Check did we have a already action
00505                 if (suite->pana_session.frag_length == 0) {
00506 
00507                     buffer_t *f_buf = NULL;
00508                     if (force_frag_start_fail) {
00509                         tr_debug("Force to drop fragment");
00510                         force_frag_start_fail = false;
00511                     } else {
00512                         tr_debug("First Fragment");
00513                         f_buf = buffer_get(eap_tls_header.tls_length);
00514                     }
00515                     if (f_buf) {
00516                         buffer_data_length_set(f_buf, eap_tls_header.tls_length);
00517                         memcpy(buffer_data_pointer(f_buf), eap_tls_header.data_ptr, eap_tls_header.tls_frame_length);
00518                         suite->pana_session.frag_off_set = eap_tls_header.tls_frame_length;
00519                         f_buf->seq  = header.id_seq;
00520                         suite->pana_session.eap_frag_buf = f_buf;
00521                         suite->pana_session.frag_length = eap_tls_header.tls_length;
00522                         skip_packet = true;
00523                     } else {
00524                         tr_debug("No free men for Fragment: %i", eap_tls_header.tls_length);
00525                         sec_lib_state_machine_trig(suite, TLS_ALERT_INTERNAL);
00526                         return buffer_free(buf);
00527                     }
00528                 } else if (suite->pana_session.frag_length != eap_tls_header.tls_length) {
00529                     tr_debug("Fragment started already");
00530                     skip_packet = true;
00531                 } else {
00532 
00533                 }
00534             }
00535 
00536             if (!skip_packet && suite->pana_session.frag_length) {
00537                 uint16_t check_len = 0;
00538                 buffer_t *t_buf = suite->pana_session.eap_frag_buf;
00539                 check_len = suite->pana_session.frag_off_set;
00540                 check_len += eap_tls_header.tls_frame_length;
00541 
00542                 //new sequency
00543                 if (check_len < buffer_data_length(t_buf)) {
00544                     tr_debug("Copy Data to Fragment");
00545                     memcpy(buffer_data_pointer(t_buf) + suite->pana_session.frag_off_set, eap_tls_header.data_ptr, eap_tls_header.tls_frame_length);
00546                     suite->pana_session.frag_off_set += eap_tls_header.tls_frame_length;
00547                     t_buf->seq  = suite->pana_session.eap_id_seq;
00548                 } else {
00549                     tr_debug("Overflow possible Free Current entry and set Alert");
00550                     buffer_free(t_buf);
00551                     suite->pana_session.eap_frag_buf = NULL;
00552                     suite->pana_session.frag_length = 0;
00553                     suite->pana_session.frag_off_set = 0;
00554                     sec_lib_state_machine_trig(suite, TLS_ALERT_INTERNAL);
00555                     return buffer_free(buf);
00556                 }
00557             }
00558 
00559             if (header.eap_code == EAP_RESPONSE) {
00560 #ifdef PANA_SERVER_API
00561                 if (suite->state == TLS_TX_SERVER_KEY_EXCHANGE) {
00562                     if (suite->pana_session.assy_length) {
00563                         suite->retry_counter = 0;
00564                     }
00565                 }
00566 #endif
00567                 pana_timeout_timer_set(suite, suite->state);
00568             }
00569             /* TX ACK or new request to sender*/
00570             buf = buffer_turnaround(buf);
00571             buf->buf_ptr  = buf->buf_end ;
00572             memcpy(buf->dst_sa .address , buf->src_sa .address , 16);
00573             buf->src_sa .addr_type  = ADDR_NONE ;
00574             return (buf);
00575         }
00576 
00577 
00578         default:
00579             tr_debug("%x", header.type);
00580             return buffer_free(buf);
00581     }
00582 }
00583 #else
00584 void pana_eap_fragmetation_start_filter(bool state)
00585 {
00586     (void) state;
00587 }
00588 
00589 void pana_eap_fragmetation_force_timeout(bool state)
00590 {
00591     (void) state;
00592 }
00593 
00594 void pana_eap_fragmetation_force_retry(bool state)
00595 {
00596     (void) state;
00597 }
00598 
00599 #endif