# squid und clamav [solved]

## sm0ker

hi.

folgendes problem: ich habe squid installiert der rennt ohne probs. nun wollte ich dass squid mit clamav zusammen 'arbeitet', also squidclam installiert und entsprechen die squid.conf angepasst.

```

redirect_program /usr/bin/squidclam

redirect_children 15

redirector_access deny localhost

acl SSL_ports port 443 563

redirector_access deny SSL_ports

```

clamd.conf ist so eingestellt, dass er auch archive scanned. nur macht er das nicht. kann eicar.zip (http://www.testvirus.de/testvirus/eicar.zip) downloaden ohne, dass er meckert oder gar des ganze blockt, was er ja eigentlich machen soll! die logfiles geben leider auch nix her...

```

Fri Feb  3 11:46:59 2006 -> +++ Started at Fri Feb  3 11:46:59 2006

Fri Feb  3 11:46:59 2006 -> clamd daemon 0.88 (OS: linux-gnu, ARCH: i386, CPU: i686)

Fri Feb  3 11:46:59 2006 -> Log file size limit disabled.

Fri Feb  3 11:46:59 2006 -> Verbose logging activated.

Fri Feb  3 11:46:59 2006 -> Running as user clamav (UID 105, GID 410)

Fri Feb  3 11:46:59 2006 -> Reading databases from /var/lib/clamav

Fri Feb  3 11:47:02 2006 -> Protecting against 43963 viruses.

Fri Feb  3 11:47:02 2006 -> Unix socket file /var/run/clamav/clamd.sock

Fri Feb  3 11:47:02 2006 -> Setting connection queue length to 15

Fri Feb  3 11:47:02 2006 -> Listening daemon: PID: 14282

Fri Feb  3 11:47:02 2006 -> Archive: Archived file size limit set to 15728640 bytes.

Fri Feb  3 11:47:02 2006 -> Archive: Recursion level limit set to 9.

Fri Feb  3 11:47:02 2006 -> Archive: Files limit set to 1500.

Fri Feb  3 11:47:02 2006 -> Archive: Compression ratio limit set to 250.

Fri Feb  3 11:47:02 2006 -> Archive: Limited memory usage.

Fri Feb  3 11:47:02 2006 -> Archive support enabled.

Fri Feb  3 11:47:02 2006 -> Archive: RAR support enabled.

Fri Feb  3 11:47:02 2006 -> Portable Executable support enabled.

Fri Feb  3 11:47:02 2006 -> Detection of broken executables enabled.

Fri Feb  3 11:47:02 2006 -> Mail files support enabled.

Fri Feb  3 11:47:02 2006 -> OLE2 support enabled.

Fri Feb  3 11:47:02 2006 -> HTML support enabled.

Fri Feb  3 11:47:02 2006 -> Self checking every 1800 seconds.

```

mehr hat er mir nicht zu sagen, auch sehe ich nicht ob er ueberhaupt etwas blockt! auf der seite sind noch andere test files, wobei ich die nicht downloaden kann, aber auch nicht weiss ob clamd die blockt oder das aus irgendeinem anderen grund nicht geht...

jemand ne idee was da schief laeuft?Last edited by sm0ker on Fri Feb 03, 2006 2:20 pm; edited 1 time in total

----------

## tuxian

Ich habs mal so gemacht:

squid.conf:

```
redirect_program /etc/squid/SquidClamAV_Redirector.py -c /etc/squid/SquidClamAV_Redirector.conf

redirect_children 5

```

/etc/squid/SquidClamAV_Redirector.py:

```
#!/usr/bin/python -u

############################################################################

#    Copyright (C) 2004 by Michael Lang                                    #

#    Michael.Lang@jackal-net.at                                            #

#                                                                          #

#    This program is free software; you can redistribute it and#or modify  #

#    it under the terms of the GNU General Public License as published by  #

#    the Free Software Foundation; either version 2 of the License, or     #

#    (at your option) any later version.                                   #

#                                                                          #

#    This program is distributed in the hope that it will be useful,       #

#    but WITHOUT ANY WARRANTY; without even the implied warranty of        #

#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #

#    GNU General Public License for more details.                          #

#                                                                          #

#    You should have received a copy of the GNU General Public License     #

#    along with this program; if not, write to the                         #

#    Free Software Foundation, Inc.,                                       #

#    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             #

############################################################################

""" Squid Proxy Redirector for VirusScanning

    fetches the requested Url Scans it and returns

    it to the User or denys access to it """

import urllib

import pyclamav

import sys

import syslog

import getopt

import string

import ConfigParser

import os

import tempfile

ModuleName = 'SquidClamAV_Redirector'

version = '1.6.2'

sys_priority    = {     'LOG_EMERG'     :0,

                        'LOG_KERN'      :0,

                        'LOG_ALERT'     :1,

                        'LOG_CRIT'      :2,

                        'LOG_CONS'      :2,

                        'LOG_CRON'      :72,

                        'LOG_ERR'       :3,

                        'LOG_WARNING'   :4,

                        'LOG_NOTICE'    :5,

                        'LOG_INFO'      :6,

                        'LOG_DEBUG'     :7,

                        'LOG_LOCAL0'    :128,

                        'LOG_LOCAL1'    :136,

                        'LOG_LOCAL2'    :144,

                        'LOG_LOCAL3'    :152,

                        'LOG_LOCAL4'    :160,

                        'LOG_LOCAL5'    :168,

                        'LOG_LOCAL6'    :176,

                        'LOG_LOCAL7'    :184,

                        'LOG_LPR'       :48,

                        'LOG_MAIL'      :16,

                        'LOG_NDELAY'    :8,

                        'LOG_NEWS'      :56,

                        'LOG_NOWAIT'    :16,

                        'LOG_PERROR'    :32,

                        'LOG_PID'       :1,

                        'LOG_SYSLOG'    :40,

                        'LOG_USER'      :8,

                        'LOG_UUCP'      :64,

                }

sys_facility    = {     'LOG_EMERG'     :0,

                        'LOG_KERN'      :0,

                        'LOG_ALERT'     :1,

                        'LOG_CRIT'      :2,

                        'LOG_CONS'      :2,

                        'LOG_CRON'      :72,

                        'LOG_ERR'       :3,

                        'LOG_WARNING'   :4,

                        'LOG_NOTICE'    :5,

                        'LOG_INFO'      :6,

                        'LOG_DEBUG'     :7,

                        'LOG_LOCAL0'    :128,

                        'LOG_LOCAL1'    :136,

                        'LOG_LOCAL2'    :144,

                        'LOG_LOCAL3'    :152,

                        'LOG_LOCAL4'    :160,

                        'LOG_LOCAL5'    :168,

                        'LOG_LOCAL6'    :176,

                        'LOG_LOCAL7'    :184,

                        'LOG_LPR'       :48,

                        'LOG_MAIL'      :16,

                        'LOG_NDELAY'    :8,

                        'LOG_NEWS'      :56,

                        'LOG_NOWAIT'    :16,

                        'LOG_PERROR'    :32,

                        'LOG_PID'       :1,

                        'LOG_SYSLOG'    :40,

                        'LOG_USER'      :8,

                        'LOG_UUCP'      :64,

                }

class Logging(object):

        """ Syslog Class for the Redirector """

        def __init__(self):

                self.ident      = 'SquidClamAV'

                self.priority   = sys_priority['LOG_INFO']

                self.facility   = sys_facility['LOG_USER']

                self.logopt     = 0

        def set_priority(self, priority):

                """ set the syslog priority """

                self.priority   = sys_priority[priority]

        def set_facility(self, facility):

                """ set the syslog facility """

                self.facility   = sys_facility[facility]

        def log(self, message):

                """ log this message for the Redirector """

                syslog.openlog(self.ident, self.logopt, self.facility)

                syslog.syslog(message)

class SquidClamAV_Redirector(object):

        """ Fetching Urls to scan with ClamAV """

        def __init__(self, config=None):

                self.configfile         = config

                self.url                = None

                self.proxy              = {}

                self.logfile            = Logging()

                self.file               = None

                self.virusurl           = None

                self.whitelist          = []

                self.tmppath            = '/tmp/'

                self.cleancache         = 300

                self.debug              = {}

                self.force_protocol     = None

                self.redirection_limit = 15

                self.max_request_size   = 0

                self.redirection        = 0

                self.mimetypes          = ['text/html']

                self.timeout            = 30.0

                self.Redirects_Accepted = [300, 301, 302, 303]

                self.__read_config__()

                self.__start_urlhandler__()

        def set_max_request_size(self, size):

                """ set the Maximum of Bytes for the Request to be fetched """

                try:

                        size = int(size)

                except ValueError:

                        if string.lower(size[-2:]) == 'kb':

                                try:

                                        size = int(size[:-2])

                                except ValueError:

                                        self.logfile.log("Unknown Size defined %s" % str(size))

                                        return

                                self.max_request_size = (size * 1024)

                        elif string.lower(size[-2:]) == 'mb':

                                try:

                                        size = int(size[:-2])

                                except ValueError:

                                        self.logfile.log("Unknown Size defined %s" % str(size))

                                        return

                                self.max_request_size = ((size * 1024) * 1024)

                        elif string.lower(size[-2:]) == 'gb':

                                try:

                                        size = int(size[:-2])

                                except ValueError:

                                        self.logfile.log("Unknown Size defined %s" % str(size))

                                        return

                                self.max_request_size = (((size * 1024) * 1024) * 1024)

                        elif string.lower(size[-1:]) == 'b':

                                try:

                                        size = int(size[:-1])

                                except ValueError:

                                        self.logfile.log("Unknown Size defined %s" % str(size))

                                        return

                                self.max_request_size = size

                        else:

                                self.logfile.log("Unknown Size defined %s" % str(size))

                                self.max_request_size = 0

                return

        def get_size(self):

                """ retrieve request Size """

                size = None

                if self.redirection >= self.redirection_limit:

                        """ prevent Redirection Loops """

                        if self.debug.has_key('print_error'):

                                self.logfile.log("Redirection limit exceeded")

                        return 1

                try:

                        self.usize = self.urlhandler.open(self.url)

                except IOError, error:

                        if error[1] in self.Redirects_Accepted:

                                """ redirect try to fetch the new URL """

                                rsp_header = error[-1]

                                if rsp_header.has_key('location'):

                                        """ attach used url if location doesnt start with http """

                                        if rsp_header['location'][:4] != 'http':

                                                if rsp_header['location'][0] == '/':

                                                        baseurl = string.split(self.url, '/')

                                                        if baseurl[1] == '':

                                                                self.url = baseurl[0] + '//' + \

                                                                baseurl[2]

                                                        else:

                                                                self.redirection += 1

                                                                return

                                                else:

                                                        baseurl = string.split(self.url, '/')

                                                        del baseurl[-1]

                                                        self.url = string.join(baseurl, '/')

                                                if self.url[-1] != '/':

                                                        if rsp_header['location'][0] != '/':

                                                                self.url = self.url + '/' + \

                                                                        rsp_header['location']

                                                        else:

                                                                self.url = self.url + rsp_header['location']

                                                else:

                                                        if rsp_header['location'][0] == '/':

                                                                self.url = self.url + \

                                                                        rsp_header['location'][1:]

                                                        else:

                                                                self.url = self.url + rsp_header['location']

                                        else:

                                                self.url = rsp_header['location']

                                        self.redirection += 1

                                        if self.get_size() == None:

                                                return

                                elif 'all' in self.mimetypes:

                                        return

                                elif rsp_header.has_key('content-type'):

                                        cheader = string.split(str(rsp_header['content-type']),';')

                                        if str(cheader[0]) in self.mimetypes:

                                                return

                                try:

                                        self.usize.close()

                                except:

                                        pass

                                return 1

                        elif error[1] == 'timed out':

                                if self.debug.has_key('print_error'):

                                        self.logfile.log("Timeout for URL %s" % self.url)

                                return 1

                        else:

                                if self.debug.has_key('print_error'):

                                        self.logfile.log("Unable to get Size from Url %s: %s" % (str(self.url), str(error)))

                                try:

                                        self.usize.close()

                                except:

                                        pass

                                return 1

                except Exception, error:

                        self.logfile.log("Unexpected Error on URL %s: %s" % (str(self.url), str(error)))

                if not self.usize.headers.has_key('content-length'):

                        if 'all' in self.mimetypes:

                                return

                        if self.usize.headers.has_key('content-type'):

                                try:

                                        cheader = string.split(str(self.usize.headers['content-type']),';')

                                        if str(cheader[0]) in self.mimetypes:

                                                return

                                except:

                                        return 1

                        try:

                                self.usize.close()

                        except:

                                pass

                        return 1

                try:

                        size = int(self.usize.headers['content-length'])

                except ValueError:

                        try:

                                self.usize.close()

                        except:

                                pass

                        return 1

                if size <= self.max_request_size or self.max_request_size == 0:

                        return

                try:

                        self.usize.close()

                except:

                        pass

                return 1

        def get_file(self, url):

                """ retrieve the Url for the User if the Extension matches

                        the defined Values from Config """

                self.url        = url

                if not self.match_extension():

                        """ ignore of not in extension list """

                        return

                if self.match_whitelist():

                        """ ignore if in whitelist """

                        return

                if self.url[:4] == 'http:' or self.url[:5] == 'https:':

                        """ protocol defined """

                        pass

                else:

                        """ url is without protocol like www.jackal-net.at instead of

                            http://www.jackal-net.at what makes problem with urllib """

                        check_http = string.find(self.url, ':80')

                        if check_http != -1:

                                """ force url to be http request """

                                if self.debug.has_key('print_okay'):

                                        self.logfile.log("rewriting url %s to http://%s" % (self.url, self.url))

                                self.url = 'http://' + self.url

                        check_https = string.find(self.url, ':443')

                        if check_https != -1:

                                """ force url to be https request """

                                if self.debug.has_key('print_okay'):

                                        self.logfile.log("rewriting url %s to https://%s" % (self.url, self.url))

                                self.url = 'https://' + self.url

                        if check_http == 1 and check_https == 1:

                                """ unknown Protocol ignoring request """

                                if self.force_protocol:

                                        if self.debug.has_key('print_error'):

                                                self.logfile.log("Forced rewriting url %s to %s://%s" % (self.url, self.force_protocol, self.url))

                                        self.url = self.force_protocol + '://' + self.url

                                else:

                                        if self.debug.has_key('print_ignored'):

                                                self.logfile.log("Ignoring request to %s due unknown Protocol" % self.url)

                                        return

                if self.get_size():

                        return

                try:

                        urlhandle       = self.usize.read()

                except IOError, error:

                        self.logfile.log("Unknown UrlError encountered: %s %s" % (str(error), str(error[-1])))

                        return 1

                except:

                        return 1

                try:

                        nr, file = tempfile.mkstemp()

                        os.close(nr)

                except OSError, error:

                        if self.debug.has_key('print_error'):

                                self.logfile.log("IOError: %s" % str(error))

                        return 1

                try:

                        self.fileh = open(file, 'wb')

                except IOError, error:

                        if error[1] == 'timed out':

                                if self.debug.has_key('print_error'):

                                        self.logfile.log("Timeout for URL %s" % self.url)

                                return 1

                        else:

                                if self.debug.has_key('print_error'):

                                        self.logfile.log("IOError: %s" % str(error))

                                return 1

                except Exception, error:

                        if self.debg.has_key('print_error'):

                                self.logfile.log("Unexpected Error: %s" % str(error))

                        return 1

                self.fileh.write(urlhandle + '\n')

                self.fileh.flush()

                self.file = file

                if self.file != None:

                        return 1

        def match_whitelist(self):

                """ let see if the Url is in a whitelist domain """

                for w_dom in self.whitelist:

                        check = string.find(string.lower(self.url), string.lower(w_dom))

                        if check != -1:

                                """ domain is whitelisted ignore """

                                return 1

                return

        def match_extension(self):

                """ let see if we are configure for this kind of File """

                if 'all' in self.extensions:

                        return 1

                blocks  = string.split(self.url, '.')

                seak    = '.' + str(blocks[-1])

                if seak.lower() in self.extensions:

                        return 1

                return

        def __read_config__(self):

                """ Set the Config Parameters """

                self.config     = ConfigParser.ConfigParser()

                try:

                        self.config.read(self.configfile)

                except Exception, error:

                        if self.debug.has_key('print_error'):

                                self.logfile.log("Error reading Config %s: %s" % (str(self.configfile), str(error)))

                        return 1

                if self.config.has_section('Proxy'):

                        for option in self.config.options('Proxy'):

                                self.proxy[option] = self.config.get('Proxy', option)

                if self.config.has_section('Whitelist'):

                        for option in self.config.options('Whitelist'):

                                if not self.config.get('Whitelist', option) in self.whitelist:

                                        self.whitelist.append(self.config.get('Whitelist', option))

                if self.config.has_section('Extensions'):

                        self.extensions = []

                        for option in self.config.options('Extensions'):

                                extensions = string.split(self.config.get('Extensions', option))

                                for ext in extensions:

                                        if not ext in self.extensions:

                                                self.extensions.append(ext)

                if self.config.has_option('SquidClamAV', 'virusurl'):

                        self.virusurl   = self.config.get('SquidClamAV', 'virusurl')

                if self.config.has_option('SquidClamAV', 'cleancache'):

                        self.cleancache = int(self.config.get('SquidClamAV', 'cleancache'))

                if self.config.has_option('SquidClamAV', 'log_priority'):

                        self.logfile.set_priority(self.config.get('SquidClamAV', 'log_priority'))

                if self.config.has_option('SquidClamAV', 'log_facility'):

                        self.logfile.set_facility(self.config.get('SquidClamAV', 'log_facility'))

                if self.config.has_option('SquidClamAV', 'ForceProtocol'):

                        self.force_protocol = self.config.get('SquidClamAV', 'ForceProtocol')

                if self.config.has_option('SquidClamAV', 'TempPath'):

                        self.tmppath = self.config.get('SquidClamAV', 'TempPath')

                if self.config.has_option('SquidClamAV', 'MaxRequestSize'):

                        self.set_max_request_size(self.config.get('SquidClamAV', 'MaxRequestSize'))

                if self.config.has_option('SquidClamAV', 'Timeout'):

                        self.timeout = float(self.config.get('SquidClamAV', 'Timeout'))

                if self.config.has_option('SquidClamAV', 'MaxRedirection'):

                        try:    self.redirection_limit = int(self.config.get('SquidClamAV', 'MaxRedirection'))

                        except ValueError:      self.redirection_limit = 15

                if self.config.has_option('SquidClamAV', 'acceptredirects'):

                        self.Redirects_Accepted = []

                        for redir_err in string.split(self.config.get('SquidClamAV', 'acceptredirects')):

                                self.Redirects_Accepted.append(int(redir_err))

                if self.config.has_option('SquidClamAV', 'MIMETypes'):

                        self.mimetypes = []

                        for mtype in string.split(self.config.get('SquidClamAV', 'MIMETypes')):

                                self.mimetypes.append(string.lower(mtype))

                if self.config.has_option('Debug', 'Error'):

                        self.debug['print_error']       = 1

                if self.config.has_option('Debug', 'Clean'):

                        self.debug['print_okay']        = 1

                if self.config.has_option('Debug', 'Infected'):

                        self.debug['print_infected']    = 1

                if self.config.has_option('Debug', 'Ignored'):

                        self.debug['print_ignored']     = 1

        def __start_urlhandler__(self):

                """ create the urlhandler object """

                # set timeout

                urllib.socket.setdefaulttimeout(self.timeout)

                self.urlhandler = urllib.URLopener()

                if self.proxy != {}:

                        self.urlhandler.proxies = self.proxy

                self.urlhandler.addheaders      = [('User-agent', ModuleName + ' ' + str(version))]

        def get_virusurl(self):

                """ build the redirect url with base = virusurl ? url = requesturl & virus = virusname """

                try:    return "%s?url=%s&virus=%s" % (self.virusurl, self.url, self.virus)

                except: return "http://localhost.no_url_set.localdomain"

        def run(self):

                """ parse the stdin buffer """

                while [ 1 ]:

                        squidline = sys.stdin.readline()

                        if not squidline:

                                #self.logfile.log('No Input from STDIN')

                                break

                        # Squid Request Line = Url User/Domain Type

                        squidline = string.strip(squidline)

                        #self.logfile.log("Request: %s" % str(squidline))

                        try:

                                url, src_address, ident, method = string.split(squidline)

                        except ValueError:

                                continue

                        self.redirection = 0

                        if self.get_file(url):

                                #self.logfile.log("Scanning File %s" % self.file)

                                try:    self.scan_result = pyclamav.scanfile(self.file)

                                except Exception, error:

                                        if self.debug.has_key('print_error'):

                                                self.logfile.log("Unexpected Error on LibClamAV: %s" % str(error))

                                        try:

                                                self.fileh.close()

                                                os.unlink(self.file)

                                        except: pass

                                        sys.stdout.write("\n")

                                #self.logfile.log("Scan Result for %s: %s" % (self.file, self.scan_result))

                                if self.scan_result[0] == 0:

                                        """ pass clean file """

                                        if self.debug.has_key('print_okay'):

                                                self.logfile.log("Url: %s Status OKAY" % str(self.url))

                                        try:

                                                self.fileh.close()

                                                os.unlink(self.file)

                                        except:

                                                pass

                                        sys.stdout.write("\n")

                                elif self.scan_result[0] == 1:

                                        """ virus found """

                                        self.virus = self.scan_result[1]

                                        if self.debug.has_key('print_infected'):

                                                self.logfile.log("Url: %s Status Infected %s" % (self.url, self.virus))

                                        try:

                                                self.fileh.close()

                                                os.unlink(self.file)

                                        except:

                                                pass

                                        sys.stdout.write("%s %s %s %s\n" % (self.get_virusurl(), src_address, ident, method))

                                elif self.scan_result != None:

                                        """ error from ClamAV """

                                        if self.debug.has_key('print_error'):

                                                self.logfile.log("Url: %s Status Error %s" % (self.url, self.scan_result))

                                        try:

                                                self.fileh.close()

                                                os.unlink(self.file)

                                        except:

                                                pass

                                        sys.stdout.write("\n")

                        else:

                                if self.debug.has_key('print_ignored'):

                                        self.logfile.log("Ignored Request %s" % str(squidline))

                                try:

                                        self.fileh.close()

                                        os.unlink(self.file)

                                except:

                                        pass

                                sys.stdout.write("\n")

                        if self.cleancache <= 0:

                                """ cleanup the cached objects """

                                self.logfile.log("Cleaning up served %s requests, exiting" % str(self.config.get('SquidClamAV', 'cleancache')))

                                sys.exit()

                                self.urlhandler.cleanup()

                                self.cleancache = int(self.config.get('SquidClamAV', 'cleancache'))

                        else:

                                self.cleancache -= 1

                        # make sure the FH isnt open anymore

                        try:

                                self.fileh.close()

                                os.unlink(self.file)

                        except: pass

if __name__ == '__main__':

        try:

                opts, args = getopt.getopt(sys.argv[1:], "c:v", ["config"])

        except getopt.GetoptError:

                sys.stderr.write("usage: %s -c|-config <configfile>\n\n")

                sys.exit(1)

        config = None

        for o, a in opts:

                if o in ('c', '-c', '-config', '--config'):

                        config = a

                        if not os.path.isfile(a):

                                sys.stderr.write("Couldnt find File %s\n\n" % str(config))

                                sys.exit(1)

                if o in ('v', '-v', '--v'):

                        sys.stderr.write("%s Version %s\n\n" % (ModuleName, version))

                        sys.exit(0)

        if not config:

                sys.stderr.write("%s Version %s\n" % (ModuleName, version))

                sys.stderr.write("usage: %s -c|-config <configfile>\n\n")

                sys.exit(1)

        redirector = SquidClamAV_Redirector(config)

        redirector.run()

```

/etc/squid/SquidClamAV_Redirector.conf:

```

[SquidClamAV]

virusurl = http://localhost/information.php

cleancache = 300

ForceProtocol = http

MaxRequestsize = 2Mb

log_priority = LOG_INFO

log_facility = LOG_LOCAL6

acceptredirects = 300 301 302 303

MIMETypes = all image/bmp image/gif image/jpeg image/png image/tiff text/html text/plain text/css

[Debug]

Infected = true

Clean = true

Error = true

Ignored = true

[Extensions]

pattern = all .jpg .exe .zip .rar .ar .com .bzip .gz

[Proxy]

#http = http://localhost:8080

#https = http://localhost:8080

[Whitelist]
```

Nur war das ganze sooo langsam dass ich es dann wieder geaktiviert habe, funktioniert hatte es aber!

----------

## sm0ker

leider funzt das script nicht wie es sollte und da ich keine ahnung von python habe....

```

hero squid # ./redirect.py

  File "./redirect.py", line 206

    self.url = baseurl[0] + '//' + \

                                    ^

SyntaxError: invalid token

hero squid #

```

nen tipp?

----------

## flash49

```

hero squid # ./redirect.py

  File "./redirect.py", line 206

    self.url = baseurl[0] + '//' + \

                                    ^

SyntaxError: invalid token

hero squid # 
```

Da er sich über das Ende der Zeile beschwert würde ich mal auf ein falsches Textformat tippen. Hast du die Datei unter Windows erstellt?

----------

## sm0ker

nein, habe die datei in nano gepastet, aber da haben sich 3 fehler eingeschlichen welche ich beseitigt habe...

nun klappt alles wie es soll!

danke.

----------

## sambatasse

Hallo sm0ker

wenn es leuft mach doch mal bitte ein Aussage zur Geschwindigkeit.

Kann mann damit Arbeiten?

Dann würde mich das auch Intressieren.

Danke

----------

## sm0ker

hi. also es funktioniert wie gesagt einwandfrei, ABER wie tuxian schon schreib, ist es wirklcih langsam. hab hier einen router (p3 700 ,256mb ram) am rennen und es dauert beim manchen seiten solange, als wenn ich isdn haette... (sind aber 2 mbit) also ich denk mal auf nem schnelleren rechner laeuft es auch 'fluessigger' kann nat. auch dran liegen, dass auf dem router ein 'paar services' rennen...

----------

## ro

ich empfehl dir dansguardian, hat mich nicht viel arbeit gekostet, das zu konfigurieren (ist glaub ich sogar fast out of the box gegangen). und eigentlich gabs keine performance-einbussen. sogar archive werden gescannt. wenn du dich dafür entscheidest sag mir bitte bescheid ob das für dich auch die bessere lösung ist....

----------

## tuxian

Naja ich hatte es auf einem P4 3GHz laufen und da war es trotzdem auch sehr langsam, eine richtige Bremse also, wundert mich aber auch nicht sonderlich wenn jede Datei einer Seite durchs Python-Sktipt geschickt wird!

----------

## sm0ker

@ ro

ich werde des mal testen, gucken ob es 'besser' ist  :Wink: 

 *Quote:*   

> 
> 
> Naja ich hatte es auf einem P4 3GHz laufen und da war es trotzdem auch sehr langsam, eine richtige Bremse also, wundert mich aber auch nicht sonderlich wenn jede Datei einer Seite durchs Python-Sktipt geschickt wird!
> 
> 

 

y0

----------

## tuxian

Also diesen Thread zu laden dauert mit SquidClamAV ca. 7,5sec, ohne ca. 2,5sec.

----------

## tuxian

 *ro wrote:*   

> ich empfehl dir dansguardian, hat mich nicht viel arbeit gekostet, das zu konfigurieren (ist glaub ich sogar fast out of the box gegangen). und eigentlich gabs keine performance-einbussen. sogar archive werden gescannt. wenn du dich dafür entscheidest sag mir bitte bescheid ob das für dich auch die bessere lösung ist....

 

Ist das nicht ein reiner Content-Filter?

Hab nirgends auf dessen HP war über eine Virenscanner-Funktion gefunden.

Wenn doch muss er ja auch einen Virenscanner verwenden, verwendet der auch ClamAV oder einen anderen?

----------

## ro

bei mir verwendet der f-prot. du kannst den aber auch so konfigurieren dass er clamav nimmt, im prinzip musst du in der config nur den pfad zum scanner angeben.

----------

## flash49

Bei mir hab ich noch keine Geschwindigkeitseinbußen bemerkt (DUAL P3-550, DSL6000), allerdings hab ich bei den zu scannenen Dateiendungen das "all " entfernt und dafür .wmf hinzugefügt. Bilder werden also nicht mehr gescannt. (Es sei denn das "all" in den Mimetypes sorgt noch dafür.)

Im log stehen auch nur noch die infizierten Dateien und nicht mehr alle. ( clean=false ignored=false)

----------

## sm0ker

mir geht's im prinzip darum, dass ich hier nen router und ein kleines lan dran hab! hier 'surfen' meine lady und die kids! leider achtet da niemand wirklich auf warnungen! wuerd aber 'trotzdem' mein lan gerne 'schuetzen'! nur wie! und es sollte auf dem p3 700mhz rennen ohne gross 'stress' zu machen! geht des? wenn ja wie? weil die anderen services rennen ja auch noch und mir waere es am liebsten, wenn des alles ohne grosse 'einbussen' rennt! wer ne idee?

----------

