def start(config):
    """Start twisted event loop and the fun should begin..."""

    host = config.get('broker', 'host') 
    port = int(config.get('broker', 'port'))

    username = config.get('broker', 'username')
    password = config.get('broker', 'password')

    fileServerPort      = int(config.get('fileserver', 'port'))
    fileServerDirectory = config.get('fileserver', 'directory')

    # Start File Server
    try:
        privkey = os.path.abspath( os.path.dirname(__file__) + '/services/privkey.pem')
        cacert = os.path.abspath( os.path.dirname(__file__) + '/services/cacert.pem')
        logger.info('Using SSL, privkey = %s, cacert = %s' % (privkey, cacert))

        reactor.listenSSL(fileServerPort, FileServerFactory(fileServerDirectory), 
            ssl.DefaultOpenSSLContextFactory(privkey, cacert) )

        logger.info('Listening on port %d, serving files from directory: %s' % (fileServerPort, fileServerDirectory))
    except:
        logger.fatal("Unable to start file server at port: %d, please check." % fileServerPort)

    stompProtocolFactory = StompProtocolFactory()

    reactor.connectTCP(host, port, stompProtocolFactory)
    reactor.run()
    return internet.TCPClient(host, port, stompProtocolFactory)

def Start():
	Globals.serverIP = "192.168.1.40"
	
	#MySQL Data
	Globals.dbHost = "127.0.0.1"
	Globals.dbUser = "user"
	Globals.dbPass = "pass"
	Globals.dbDatabase = "db"
	
	CheckMySqlConn()
	
	SSLInfo = ssl.DefaultOpenSSLContextFactory('crt/privkey.pem', 'crt/cacert.pem')
	
	factory = Factory()
	factory.protocol = GosRedirector.GOSRedirector
	reactor.listenSSL(42127, factory, SSLInfo)
	print("[SSL REACTOR] GOSREDIRECTOR STARTED [42127]")
	
	factory = Factory()
	factory.protocol = BlazeMain_Client.BLAZEHUB
	reactor.listenTCP(10041, factory)
	print("[TCP REACTOR] BLAZE CLIENT [10041]")
	
	factory = Factory()
	factory.protocol = BlazeMain_Server.BLAZEHUB
	reactor.listenTCP(10071, factory)
	print("[TCP REACTOR] BLAZE SERVER [10071]")
	
	sites = server.Site(Https.Simple())
	reactor.listenSSL(443, sites, SSLInfo)
	print("[WEB REACTOR] Https [443]")

	reactor.run()

def process_nmap_commands(logger_name):
	""" Main function. Here we set up the environment, factory and port """
	global nmap_commands_file
	global nmap_command
	global port
	global mlog
	global verbose_level
	global client_timeout

	observer = log.PythonLoggingObserver(logger_name)
	observer.start()

	# Create the factory
	factory = Factory()
	factory.protocol = NmapServerProtocol

	# Create the time based print
	loop = task.LoopingCall(show_info)
	loop.start(5) 

	# Create the time based file read
	loop2 = task.LoopingCall(read_file_and_fill_nmap_variable)
	loop2.start(1)

	# To mark idel clients as hold
	loop3 = task.LoopingCall(timeout_idle_clients)
	loop3.start(client_timeout) # call every second

	if not sql_file =="":
		loop4 = task.LoopingCall(sql_import_loop)
		loop4.start(5)

	# Create the reactor
	reactor.listenSSL(port, factory, ServerContextFactory())
	reactor.run()

def main():
    logging.basicConfig(level=logging.INFO,
            format='%(asctime)s %(levelname)-s: %(message)s')
    args = _getArgs()

    ippool = IPPool(args.remote)
    ippool.register(args.local)

    factory = SSTPProtocolFactory(pppd=args.pppd, pppdConfigFile=args.pppd_config,
            local=args.local, remotePool=ippool)

    if args.no_ssl:
        logging.info('Running without SSL.')
        reactor.listenTCP(args.listen_port, factory)
    else:
        certificate = _load_cert(args.pem_cert)
        if certificate is None:
            logging.critical('Cannot read certificate.')
            sys.exit(2)
            return
        reactor.listenSSL(args.listen_port, factory,
                certificate.options(), interface=args.listen)

    logging.info('Listening on %s:%s...' % (args.listen, args.listen_port))
    reactor.run()

def startagent(port = myport):
	if agentdaemonize:
		print "Daemonizing"
		from hqdaemon import daemonize
		daemonize('/dev/null','/tmp/daemon.log','/tmp/daemon.log')
	if sys.platform.find("win32") != -1:
		import win32file
		win32file._setmaxstdio(2048)

	if use_ssl:
		print "Agent is started on port ", myport, " SSL is enabled "
		try:
			myContextFactory = ssl.DefaultOpenSSLContextFactory(agent_ssl_key, agent_ssl_cert)
			ctx = myContextFactory.getContext()
			# ctx.set_verify( SSL.VERIFY_PEER, verifyCallback)
			# ctx.set_options( SSL.OP_ALL ) 
			# Since we have self-signed certs we have to explicitly
			# tell the server to trust them.
			ctx.load_verify_locations(agent_ssl_pem)
		except Exception, e:
			print "Failed to start, SSL keys are specified but do not exist ", e
			sys.exit(1)
		
		reactor.listenSSL(myport, ExecuteActionFactory(), myContextFactory)
		reactor.run(installSignalHandlers=False)

def build_reactor(options, **kwargs):
    web_socket_instance = FilteredWebSocketFactory(**kwargs)
    subscriber = kwargs.pop("subscriber", None)

    if options.key and options.cert:
        with open(options.key) as keyFile:
            with open(options.cert) as certFile:
                cert = ssl.PrivateCertificate.loadPEM(keyFile.read() + certFile.read())
                reactor.listenSSL(options.port, web_socket_instance, cert.options())
    else:
        reactor.listenTCP(
            options.port,
            web_socket_instance
        )
    if subscriber is not None:
        reactor.callInThread(
            subscriber.listener,
            web_socket_instance
        )
        reactor.addSystemEventTrigger(
            "before",
            "shutdown",
            subscriber.kill
        )

    # Start the consumer loop
    consumer_loop = LoopingCall(
        web_socket_instance.consumer
    )
    consumer_loop.start(0.001, now=False)
    return web_socket_instance

def main():
    args = _getArgs()
    logging.basicConfig(level=args.log_level,
            format='%(asctime)s %(levelname)-s: %(message)s')
    logging.addLevelName(5, 'VERBOSE')

    ippool = IPPool(args.remote)
    ippool.register(args.local)

    if args.no_ssl:
        logging.info('Running without SSL.')
        factory = SSTPProtocolFactory(pppd=args.pppd, pppdConfigFile=args.pppd_config,
                local=args.local, remotePool=ippool, certHash=None)
        reactor.listenTCP(args.listen_port, factory)
    else:
        cert = _load_cert(args.pem_cert)
        sha1 = cert.digest('sha1').replace(':', '').decode('hex')
        sha256 = cert.digest('sha256').replace(':', '').decode('hex')
        cert_options = cert.options()

        if args.ciphers:
            cert_options.getContext().set_cipher_list(args.ciphers)

        factory = SSTPProtocolFactory(pppd=args.pppd, pppdConfigFile=args.pppd_config,
                local=args.local, remotePool=ippool, certHash=[sha1, sha256])
        reactor.listenSSL(args.listen_port, factory,
                cert_options, interface=args.listen)


    logging.info('Listening on %s:%s...' % (args.listen, args.listen_port))
    reactor.run()

def main():
    """This runs the protocol on port 25000"""
    factory = protocol.Factory()
    factory.protocol = Echo
    reactor.listenSSL(25000, factory,
                      ssl.DefaultOpenSSLContextFactory(KEYFILE, CERTFILE))
    reactor.run()

def main():
    """ Run the server. """
    # setup logger first
    initLog()

    # Load the client's self-signed certificate.
    clientCert = open(CLIENT_CERT_FILE).read()
    clientCertObj = ssl.Certificate.loadPEM(clientCert)

    # Load the server's key and the server's self-signed certificate.
    serverKey = open(SERVER_KEY_FILE).read()
    serverCert = open(SERVER_CERT_FILE).read()
    serverPEM = serverKey + serverCert
    serverCertObj = ssl.PrivateCertificate.loadPEM(serverPEM)

    # Create an SSL context factory. Passing the client's certificate along enables client authentication.
    sslContextFactory = serverCertObj.options(clientCertObj)

    kinectServerFactory = KinectServerFactory()

    # Set the Twisted reactor up to listen for connections. For each incoming connection, create a KinectServer
    # (using the KinectServerFactory) and create an SSL context (using the sslContextFactory). The SSL context is used
    # to verify clients and set up an SSL layer. The KinectServer is used to handle all messages their decrypted state;
    # messages are relayed to all other connections.
    reactor.listenSSL(PORT, kinectServerFactory, sslContextFactory)

    # Run the reactor (which enters Twisted's main loop).
    reactor.run()

def main(argv):
    (logLevel, sslPort, httpPort,
     certFile, keyFile, userName,
     groupName, background,
     incomingInterface)     = parseOptions(argv)
    privateKey              = initializeKey(keyFile)
    database                = initializeDatabase()
    sslFactory              = initializeFactory(database, privateKey)
    connectFactory          = http.HTTPFactory(timeout=10)
    connectFactory.protocol = ConnectChannel
    
    reactor.listenSSL(sslPort, sslFactory, ServerContextFactory(certFile, keyFile),
                      interface=incomingInterface)
    reactor.listenSSL(4242, sslFactory, ServerContextFactory(certFile, keyFile),
                      interface=incomingInterface)
    reactor.listenTCP(port=httpPort, factory=connectFactory,
                      interface=incomingInterface)
        
    initializeLogging(logLevel)
    checkPrivileges(userName, groupName)

    if background:
        print "\nconvergence " + str(gVersion) + " by Moxie Marlinspike backgrounding..."
        convergence.daemonize.createDaemon()
    else:
        print "\nconvergence " + str(gVersion) + " by Moxie Marlinspike running..."

    writePidFile()
    dropPrivileges(userName, groupName)

    reactor.run()

def runApplication():
    opts = Options()
    opts.parseOptions()

    common.initLogs(opts['logfile'])

    common.installReactor(opts['reactor'])

    config = common.loadConfig(opts['config'])

    #starting services with options from config
    if opts['ssl']:
        reactor.listenSSL(
            config.getint('finger', 'port'),
            FingerFactory(),
            DefaultOpenSSLContextFactory(
                config.get('ssl', 'cert'),
                config.get('ssl', 'private')
            )
        )
        reactor.listenSSL(
            config.getint('web', 'port'),
            server.Site(SomeLeafResource()),
            DefaultOpenSSLContextFactory(
                config.get('ssl', 'cert'),
                config.get('ssl', 'private')
            )
        )
    else:
        reactor.listenTCP(config.getint('finger', 'port'), FingerFactory())
        reactor.listenTCP(config.getint('web', 'port'), server.Site(SomeLeafResource()))
    reactor.run()

def main():

    parser = OptionParser()
    parser.add_option('-l', '--loglevel', default='info', dest='logLevel', help='This sets the logging level you have these options: debug, info, warning, error, critical \t\tThe standard value is info')
    parser.add_option('-p', '--port', default=4443, type='int', dest='port', help='This options lets you use a custom port instead of 443 (use a port > 1024 to run as non root user)')
    parser.add_option('--logfile', default=None, dest='logfile', help='Log to a file instead of stdout.')
    (options, _) = parser.parse_args()
    
    x = logging.getLogger()
    x.setLevel(log_levels[options.logLevel])
    
    if options.logfile != None:
        h = logging.FileHandler(options.logfile)
    else:
        h = logging.StreamHandler()
    
    f = logging.Formatter(u"%(levelname)s %(message)s")
    h.setFormatter(f)
    x.addHandler(h)
    
    
    x.info("Starting server on port {0}".format(options.port))
    reactor.listenSSL(options.port, SiriFactory(), ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt'))
    reactor.run()
    x.info("Server shutdown complete")

    def start_listening(self):
        config = self.get_config()

        if not config.no_tls and config.bind_port is not None:
            reactor.listenSSL(
                config.bind_port,
                Site(self.root_resource),
                self.tls_context_factory,
                interface=config.bind_host
            )
            logger.info("Synapse now listening on port %d", config.bind_port)

        if config.unsecure_port is not None:
            reactor.listenTCP(
                config.unsecure_port,
                Site(self.root_resource),
                interface=config.bind_host
            )
            logger.info("Synapse now listening on port %d", config.unsecure_port)

        metrics_resource = self.get_resource_for_metrics()
        if metrics_resource and config.metrics_port is not None:
            reactor.listenTCP(
                config.metrics_port, Site(metrics_resource), interface="127.0.0.1",
            )
            logger.info("Metrics now running on 127.0.0.1 port %d", config.metrics_port)

def main(argv):
    FLAGS(argv)
    if not FLAGS.logfile and not FLAGS.daemonize:
        # No log file and not daemonized.
        log.startLogging(sys.stderr)
    elif not FLAGS.logfile and FLAGS.daemonize:
        # Daemonized, but no log file.
        fd, name = tempfile.mkstemp(prefix='flamongo', suffix='.log')
        os.close(fd)
        sys.stderr.write('Logging to %s\n' % name)
        log.startLogging(open(name, 'a'))
    else:
        f = open(FLAGS.logfile, 'a')
        log.startLogging(f)
    # FIXME
    mongoengine.connect('flamongo')
    # TODO define connection options.
    site = server.Site(TopLevel(lambda: Connection()))
    reactor.listenTCP(FLAGS.port, site)
    try:
        from twisted.internet import ssl
        ssl_context = ssl.DefaultOpenSSLContextFactory(FLAGS.privatekey,
            FLAGS.certificate)
        reactor.listenSSL(FLAGS.secureport, site, ssl_context)
    except ImportError:
        # removes the partial import.
        ssl = None
        log.err('SSL not enabled. Needs PyOpenSSL.')
    except Exception as ex:
        log.err(str(ex))
    if FLAGS.daemonize:
        utils.daemonize()
    reactor.run()

def process_nmap_commands(loggerName):
    """ Main function. Here we set up the environment, factory, interface, and port """
    global nmapCommandsFile
    global nmapCommand
    global port
    global mlog
    global verboseLevel
    global clientTimeout
    
    observer = log.PythonLoggingObserver(loggerName)
    observer.start()
    
    # Create the factory
    factory = Factory()
    factory.protocol = NmapServerProtocol
    
    # Create the time based print
    loop = task.LoopingCall(show_info)
    loop.start(5.0) # call every second
    
    # Create the time based file read
    loop2 = task.LoopingCall(read_file_and_fill_nmap_variable)
    loop2.start(30.0) # call every second
    
    # To mark idle clients as hold
    loop3 = task.LoopingCall(timeout_idle_clients)
    loop3.start(clientTimeout) # call every second
    
    # Create the reactor
    reactor.listenSSL(port, factory, ServerContextFactory(), interface=interface)
    reactor.run()

def addWebServer(cfg, dist, sched):
    """Set up a web server.
         cfg -- a configuration object from Main.  We use these options:
                HTTPS_N_BRIDGES_PER_ANSWER
                HTTP_UNENCRYPTED_PORT
                HTTP_UNENCRYPTED_BIND_IP
                HTTP_USE_IP_FROM_FORWARDED_HEADER
                HTTPS_PORT
                HTTPS_BIND_IP
                HTTPS_USE_IP_FROM_FORWARDED_HEADER
         dist -- an IPBasedDistributor object.
         sched -- an IntervalSchedule object.
    """
    Site = twisted.web.server.Site
    site = None
    if cfg.HTTP_UNENCRYPTED_PORT:
        ip = cfg.HTTP_UNENCRYPTED_BIND_IP or ""
        resource = WebResource(dist, sched, cfg.HTTPS_N_BRIDGES_PER_ANSWER,
                       cfg.HTTP_USE_IP_FROM_FORWARDED_HEADER,
                       includeFingerprints=cfg.HTTPS_INCLUDE_FINGERPRINTS)
        site = Site(resource)
        reactor.listenTCP(cfg.HTTP_UNENCRYPTED_PORT, site, interface=ip)
    if cfg.HTTPS_PORT:
        from twisted.internet.ssl import DefaultOpenSSLContextFactory
        #from OpenSSL.SSL import SSLv3_METHOD
        ip = cfg.HTTPS_BIND_IP or ""
        factory = DefaultOpenSSLContextFactory(cfg.HTTPS_KEY_FILE,
                                               cfg.HTTPS_CERT_FILE)
        resource = WebResource(dist, sched, cfg.HTTPS_N_BRIDGES_PER_ANSWER,
                       cfg.HTTPS_USE_IP_FROM_FORWARDED_HEADER,
                       includeFingerprints=cfg.HTTPS_INCLUDE_FINGERPRINTS)
        site = Site(resource)
        reactor.listenSSL(cfg.HTTPS_PORT, site, factory, interface=ip)
    return site

def start_site(config, resource):
    log.info('Starting the API on port %s' % config.port)
    if config.sslkey and config.sslcert:
        reactor.listenSSL(config.port, PixelatedSite(resource), _ssl_options(config.sslkey, config.sslcert),
                          interface=config.host)
    else:
        reactor.listenTCP(config.port, PixelatedSite(resource), interface=config.host)

    def __init__(
        self,
        port,
        ssl,
        server_context_factory = None,
        reactor = None,
        interface = '',
        **keywords
    ):

        if reactor is None:
            from twisted.internet import reactor

        if ssl and server_context_factory is None:
            from planes.sh.ssl import ServerContextFactory
            server_context_factory = ServerContextFactory()

        self.port = port
        self.ssl = ssl
        self.reactor = reactor
        self.factory = self.Factory(reactor = reactor, **keywords)

        if ssl:
            reactor.listenSSL(
                self.port,
                self.factory,
                server_context_factory,
                interface = interface,
            )
        else:
            reactor.listenTCP(
                port,
                self.factory,
                interface = interface,
            )

def Run(withListen=True):

    global instance_SBProtocolFactory, bReactorStopped
    instance_SBProtocolFactory = SBProtocolFactory()

    InternalMessage.protocolInternal = SBProtocol()
    InternalMessage.protocolInternal.role = "internal"
    InternalMessage.protocolInternal.factory = instance_SBProtocolFactory
    threading.Thread(target=InternalMessage.Run).start()

    if withListen:
        reactor.listenTCP(9630, instance_SBProtocolFactory)  # @UndefinedVariable

        cert = None
        with open("server.pem") as keyAndCert:
            cert = ssl.PrivateCertificate.loadPEM(keyAndCert.read())
        reactor.listenSSL(9631, instance_SBProtocolFactory, cert.options())
        reactor.listenTCP(9632, EchoProtocolFactory())  # @UndefinedVariable

    try:
        reactor.run()  # @UndefinedVariable
    except:
        pass
    InternalMessage.Stop()
    bReactorStopped = True
    try:
        # reactor.stop()
        import sys

        sys.exit(0)
    except:
        pass

 def run(self):
     task.LoopingCall(self.status_check).start(0.5)
     root = File('www')
     root.putChild('st', StatusHandler(self))
     root.putChild('upd', self.updateHandler)
     root.putChild('cfg', ConfigHandler(self))
     root.putChild('upt', UptimeHandler(self))
     
     if self.config['config']['use_auth']:
         clk = ClickHandler(self)
         args={self.config['site']['username']:self.config['site']['password']}
         checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**args)
         realm = HttpPasswordRealm(clk)
         p = portal.Portal(realm, [checker])
         credentialFactory = BasicCredentialFactory("Garage Door Controller")
         protected_resource = HTTPAuthSessionWrapper(p, [credentialFactory])
         root.putChild('clk', protected_resource)
     else:
         root.putChild('clk', ClickHandler(self))
     
     site = server.Site(root)
     
     if not self.get_config_with_default(self.config['config'], 'use_https', False):
         reactor.listenTCP(self.config['site']['port'], site)  # @UndefinedVariable
         reactor.run()  # @UndefinedVariable
     else:
         sslContext = ssl.DefaultOpenSSLContextFactory(self.config['site']['ssl_key'], self.config['site']['ssl_cert'])
         reactor.listenSSL(self.config['site']['port_secure'], site, sslContext)  # @UndefinedVariable
         reactor.run()  # @UndefinedVariable