code: def _recv_cf(self, data):
          
          if self.rx_state != ISOTP_WAIT_DATA:
              return 0
  
          self.rx_timer.cancel()
  
          # CFs are never longer than the FF
          if len(data) > self.rx_ll_dl:
              return 1
  
          # CFs have usually the LL_DL length
          if len(data) < self.rx_ll_dl:
              # this is only allowed for the last CF
              if self.rx_len - self.rx_idx > self.rx_ll_dl:
                  warning("Received a CF with insuffifient length")
                  return 1
  
          if six.indexbytes(data, 0) & 0x0f != self.rx_sn:
              # Wrong sequence number
              warning("RX state was reset because wrong sequence number was "
                      "received")
              self.rx_state = ISOTP_IDLE
              return 1
  
          self.rx_sn = (self.rx_sn + 1) % 16
          self.rx_buf += data[1:]
          self.rx_idx = len(self.rx_buf)
  
          if self.rx_idx >= self.rx_len:
              # we are done
              self.rx_buf = self.rx_buf[0:self.rx_len]
              self.rx_state = ISOTP_IDLE
              self.rx_queue.put(self.rx_buf)
              for cb in self.rx_callbacks:
                  cb(self.rx_buf)
              self.call_release()
              self.rx_buf = None
              return 0
  
          # perform blocksize handling, if enabled
          if self.rxfc_bs != 0:
              self.rx_bs += 1
  
              # check if we reached the end of the block
              if self.rx_bs >= self.rxfc_bs and not self.listen_mode:
                  # send our FC frame
                  load = self.ea_hdr
                  load += struct.pack("BBB", N_PCI_FC, self.rxfc_bs,
                                      self.rxfc_stmin)
                  self.can_send(load)
  
          # wait for another CF
          self.rx_timer.set_timeout(self.cf_timeout, self._rx_timer_handler)
          return 0
docs: Process a received 'Consecutive Frame' frame