def process_service_check_result(self, service, return_code, plugin_output):
        """Process service check result
        Format of the line that triggers function call::

        PROCESS_SERVICE_CHECK_RESULT;<host_name>;<service_description>;<return_code>;<plugin_output>

        :param service: service to process check to
        :type service: alignak.objects.service.Service
        :param return_code: exit code of plugin
        :type return_code: int
        :param plugin_output: plugin output
        :type plugin_output: str
        :return: None
        """
        now = time.time()
        cls = service.__class__

        # If globally disabled OR service disabled, do not launch..
        if not cls.accept_passive_checks or not service.passive_checks_enabled:
            return

        try:
            plugin_output = plugin_output.decode('utf8', 'ignore')
            logger.debug('%s > Passive service check plugin output: %s',
                         service.get_full_name(), plugin_output)
        except AttributeError:
            # Python 3 will raise an exception
            pass
        except UnicodeError:
            pass

        # Maybe the check is just too old, if so, bail out!
        if self.current_timestamp < service.last_chk:
            logger.debug('%s > Passive service check is too old (%d seconds). '
                         'Ignoring, check output: %s',
                         service.get_full_name(), self.current_timestamp < service.last_chk,
                         plugin_output)
            return

        # Create a check object from the external command
        chk = service.launch_check(now, self.hosts, self.services, self.timeperiods,
                                   self.daemon.macromodulations, self.daemon.checkmodulations,
                                   self.daemon.checks, force=True)
        # Should not be possible to not find the check, but if so, don't crash
        if not chk:
            logger.error('%s > Passive service check failed. None check launched !?',
                         service.get_full_name())
            return

        # Now we 'transform the check into a result'
        # So exit_status, output and status is eaten by the service
        chk.exit_status = return_code
        chk.get_outputs(plugin_output, service.max_plugins_output_length)

        logger.debug('%s > Passive service check output: %s',
                     service.get_full_name(), chk.output)

        chk.status = ACT_STATUS_WAIT_CONSUME
        chk.check_time = self.current_timestamp  # we are using the external command timestamps
        # Set the corresponding service's check type to passive
        chk.set_type_passive()
        # self.daemon.nb_check_received += 1
        self.send_an_element(chk)
        # Ok now this result will be read by the scheduler the next loop

        # raise a passive check log only if needed
        if self.my_conf.log_passive_checks:
            log_level = 'info'
            if return_code == 1:  # WARNING
                log_level = 'warning'
            if return_code == 2:  # CRITICAL
                log_level = 'error'
            self.send_an_element(make_monitoring_log(
                log_level, 'PASSIVE SERVICE CHECK: %s;%s;%d;%s;%s;%s' % (
                    self.hosts[service.host].get_name(), service.get_name(),
                    return_code, chk.output, chk.long_output, chk.perf_data)))
Process service check result
        Format of the line that triggers function call::

        PROCESS_SERVICE_CHECK_RESULT;<host_name>;<service_description>;<return_code>;<plugin_output>

        :param service: service to process check to
        :type service: alignak.objects.service.Service
        :param return_code: exit code of plugin
        :type return_code: int
        :param plugin_output: plugin output
        :type plugin_output: str
        :return: None