def main(args):
    ''' Main function '''

    try:
        options, arguments = getopt.getopt(args[1:], '6A:p:Sv')
    except getopt.error:
        sys.exit('usage: neubot skype_clnt [-6Sv] [-A address] [-p port]')
    if arguments:
        sys.exit('usage: neubot skype_clnt [-6Sv] [-A address] [-p port]')

    prefer_ipv6 = 0
    address = '127.0.0.1'
    port = 45678
    sslconfig = False
    verbose = 0
    for name, value in options:
        if name == '-6':
            prefer_ipv6 = 1
        elif name == '-A':
            address = value
        elif name == '-p':
            port = int(value)
        elif name == '-S':
            sslconfig = True
        elif name == '-v':
            verbose += 1

    level = logging.INFO
    if verbose > 0:
        level = logging.DEBUG
    logging.getLogger().setLevel(level)

    handler = SkypeClient()
    handler.connect((address, port), prefer_ipv6, sslconfig, {})
    POLLER.loop()

def main(args):
    ''' Main function '''
    try:
        options, arguments = getopt.getopt(args[1:], '6A:P:p:Sv')
    except getopt.error:
        sys.exit(USAGE)
    if arguments:
        sys.exit(USAGE)

    prefer_ipv6 = 0
    address = 'mlab-ns.appspot.com'
    policy = ''
    port = 80
    sslconfig = 0
    level = logging.INFO
    for name, value in options:
        if name == '-6':
            prefer_ipv6 = 1
        elif name == '-A':
            address = value
        elif name == '-P':
            policy = value
        elif name == '-p':
            port = int(value)
        elif name == '-S':
            sslconfig = 1
        elif name == '-v':
            level = logging.DEBUG

    logging.getLogger().setLevel(level)

    handler = RunnerMlabns()
    extra = {'policy': policy}
    handler.connect((address, port), prefer_ipv6, sslconfig, extra)
    POLLER.loop()

 def _waiting_rawtest(self, stream, data):
     ''' Waiting for RAWTEST message from client '''
     context = stream.opaque
     context.bufferise(data)
     tmp = context.pullup(len(RAWTEST))
     if not tmp:
         stream.recv(len(RAWTEST), self._waiting_rawtest)
         return
     if tmp[4:5] == PING_CODE:
         logging.debug('< PING')
         stream.send(PINGBACK, self._sent_pingback)
         logging.debug('> PINGBACK')
         return
     if tmp[4:5] != RAWTEST_CODE:
         raise RuntimeError('raw_srvr: received invalid message')
     logging.debug('< RAWTEST')
     logging.info('raw_srvr: waiting for RAWTEST message... complete')
     logging.info('raw_srvr: raw test... in progress')
     context.count = context.snap_count = stream.bytes_out
     context.ticks = context.snap_ticks = utils.ticks()
     context.snap_utime, context.snap_stime = os.times()[:2]
     message = PIECE_CODE + context.auth * int(LEN_MESSAGE / AUTH_LEN)
     context.message = struct.pack('!I', len(message)) + message
     stream.send(context.message, self._piece_sent)
     #logging.debug('> PIECE')
     POLLER.sched(1, self._periodic, stream)
     stream.recv(1, self._waiting_eof)

def main(args):
    ''' Main function '''

    try:
        options, arguments = getopt.getopt(args[1:], '6A:p:Sv')
    except getopt.error:
        sys.exit(USAGE)
    if not arguments:
        sys.exit(USAGE)

    prefer_ipv6 = 0
    address = '127.0.0.1'
    sslconfig = 0
    port = 80
    level = logging.INFO
    for name, value in options:
        if name == '-6':
            prefer_ipv6 = 1
        elif name == '-A':
            address = value
        elif name == '-p':
            port = int(value)
        elif name == '-S':
            sslconfig = 1
        elif name == '-v':
            level = logging.DEBUG

    logging.getLogger().setLevel(level)

    handler = HttpClientSmpl(POLLER)
    handler.connect((address, port), prefer_ipv6, sslconfig,
      (address, port, collections.deque(arguments), [0]))
    POLLER.loop()

def main(args):
    ''' Run the API server '''

    try:
        options, arguments = getopt.getopt(args[1:], 'O:v')
    except getopt.error:
        sys.exit('usage: neubot background_api [-v] [-O setting]')
    if arguments:
        sys.exit('usage: neubot background_api [-v] [-O setting]')

    settings = []
    for name, value in options:
        if name == '-O':
            settings.append(value)
        elif name == '-v':
            LOG.verbose()

    settings = utils_rc.parse_safe(iterable=settings)
    if not 'address' in settings:
        settings['address'] = '127.0.0.1 ::1'
    if not 'port' in settings:
        settings['port'] = '9774'

    start(settings['address'], settings['port'])
    POLLER.loop()

def main(args):
    ''' Main function '''
    try:
        options, arguments = getopt.getopt(args[1:], '6A:p:v')
    except getopt.error:
        sys.exit('usage: neubot skype_negotiate [-6v] [-A address] [-p port]')
    if arguments:
        sys.exit('usage: neubot skype_negotiate [-6v] [-A address] [-p port]')

    prefer_ipv6 = 0
    address = '127.0.0.1'
    port = 8080
    level = logging.INFO
    for name, value in options:
        if name == '-6':
            prefer_ipv6 = 1
        elif name == '-A':
            address = value
        elif name == '-p':
            port = int(value)
        elif name == '-v':
            level = logging.DEBUG

    logging.getLogger().setLevel(level)

    handler = SkypeNegotiate()
    handler.connect((address, port), prefer_ipv6, 0, {})
    POLLER.loop()

def main(args):
    ''' Main() function '''

    try:
        options, arguments = getopt.getopt(args[1:], '')
    except getopt.error:
        sys.exit('usage: neubot background_win32')
    if options or arguments:
        sys.exit('usage: neubot background_win32')

    # Read settings from database
    CONFIG.merge_database(DATABASE.connection())

    #
    # Save logs into the database, to easily access
    # and show them via the web user interface.
    #
    LOG.use_database()

    # Complain if privacy settings are not OK
    privacy.complain_if_needed()

    background_api.start('127.0.0.1 ::1', '9774')
    BACKGROUND_RENDEZVOUS.start()

    __start_updater()

    POLLER.loop()

def main(args):
    ''' main() function '''

    try:
        options, arguments = getopt.getopt(args[1:], 'vy')
    except getopt.error:
        sys.exit('neubot updater_runner [-vy] [version]')
    if len(arguments) > 1:
        sys.exit('neubot updater_runner [-vy] [version]')

    privacy = False
    for tpl in options:
        if tpl[0] == '-v':
            LOG.verbose()
        elif tpl[0] == '-y':
            privacy = True

    # Honor -y and force privacy permissions
    if privacy:
        CONFIG.conf.update({'privacy.informed': 1, 'privacy.can_collect': 1,
                            'privacy.can_publish': 1})

    updater = UpdaterRunner('win32', os.path.dirname(ROOTDIR))

    if arguments:
        updater.retrieve_files(arguments[0])
    else:
        # Enable automatic updates if we arrive here
        CONFIG.conf['win32_updater'] = 1
        updater.retrieve_versioninfo()

    POLLER.loop()

def main(args):
    """ Main function """

    try:
        options, arguments = getopt.getopt(args[1:], "6A:p:Sv")
    except getopt.error:
        sys.exit("usage: neubot raw_clnt [-6Sv] [-A address] [-p port]")
    if arguments:
        sys.exit("usage: neubot raw_clnt [-6Sv] [-A address] [-p port]")

    prefer_ipv6 = 0
    address = "127.0.0.1"
    port = 12345
    sslconfig = False
    verbose = 0
    for name, value in options:
        if name == "-6":
            prefer_ipv6 = 1
        elif name == "-A":
            address = value
        elif name == "-p":
            port = int(value)
        elif name == "-S":
            sslconfig = True
        elif name == "-v":
            verbose += 1

    level = logging.INFO
    if verbose > 0:
        level = logging.DEBUG
    logging.getLogger().setLevel(level)

    handler = RawClient()
    handler.connect((address, port), prefer_ipv6, sslconfig, {})
    POLLER.loop()

def main(args):
    ''' main() function '''

    CONFIG['verbose'] = 1

    ctx = {'uri': args[1]}
    RunnerDload(ctx)
    POLLER.loop()

 def _connect(self):
     ''' Connect first available epnt '''
     sock = utils_net.connect(self.epnts.popleft(), self.prefer_ipv6)
     if sock:
         self.sock = sock
         self.timestamp = utils.ticks()
         POLLER.set_writable(self)
     else:
         self._connection_failed()

 def handle_write(self):
     POLLER.unset_writable(self)
     if not utils_net.isconnected(self.endpoint, self.sock):
         self._connection_failed()
         return
     deferred = Deferred()
     deferred.add_callback(self._handle_connect)
     deferred.add_errback(self._handle_connect_error)
     deferred.callback(utils.ticks())

 def _connection_failed(self):
     ''' Failed to connect first available epnt '''
     if self.sock:
         POLLER.unset_writable(self)
         self.sock = None  # MUST be below unset_writable()
     if not self.epnts:
         self.aterror.callback_each_np(self)
         return
     self._connect()

 def _periodic(self, args):
     """ Periodically snap goodput """
     stream = args[0]
     if stream.opaque:
         deferred = Deferred()
         deferred.add_callback(self._periodic_internal)
         deferred.add_errback(lambda err: self._periodic_error(stream, err))
         deferred.callback(stream)
         POLLER.sched(1, self._periodic, stream)

def main(args):
    """ main() function """

    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    LOG.verbose()

    ctx = {"uri": args[1]}
    RunnerDload(ctx)
    POLLER.loop()

    def __init__(self, parent, sock, endpoint):
        Pollable.__init__(self)
        self.parent = parent
        self.lsock = sock
        self.endpoint = endpoint

        # Want to listen "forever"
        self.watchdog = -1

        POLLER.set_readable(self)
        self.parent.handle_listen(self)

def main(args):
    """ Main function """
    try:
        options, arguments = getopt.getopt(args[1:], "6A:np:vy")
    except getopt.error:
        sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]")
    if arguments:
        sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]")

    prefer_ipv6 = 0
    # address = 'master.neubot.org'
    address = "localhost"
    runner = 1
    port = 8080
    noisy = 0
    fakeprivacy = 0
    for name, value in options:
        if name == "-6":
            prefer_ipv6 = 1
        elif name == "-A":
            address = value
        elif name == "-n":
            runner = 0
        elif name == "-p":
            port = int(value)
        elif name == "-v":
            noisy = 1
        elif name == "-y":
            fakeprivacy = 1

    if os.path.isfile(DATABASE.path):
        DATABASE.connect()
        CONFIG.merge_database(DATABASE.connection())
    else:
        logging.warning("skype: database file is missing: %s", DATABASE.path)
        BACKEND.use_backend("null")
    if noisy:
        log.set_verbose()
    if runner:
        result = runner_clnt.runner_client(
            CONFIG["agent.api.address"], CONFIG["agent.api.port"], CONFIG["verbose"], "skype"
        )
        if result:
            sys.exit(0)

    logging.info("skype: running the test in the local process context...")
    if not fakeprivacy and not privacy.allowed_to_run():
        privacy.complain()
        logging.info("skype: otherwise use -y option to temporarily provide " "privacy permissions")
        sys.exit(1)

    handler = SkypeNegotiate()
    handler.connect((address, port), prefer_ipv6, 0, {})
    POLLER.loop()

    def send(self, send_octets, send_complete):
        ''' Async send() '''

        if self.isclosed:
            raise RuntimeError('stream: send() on a closed stream')
        if self.send_octets:
            raise RuntimeError('stream: already send()ing')

        self.send_octets = send_octets
        self.send_complete = send_complete

        if self.send_blocked:
            logging.debug('stream: send() is blocked')
            return

        POLLER.set_writable(self)

 def handshake(self):
     ''' Async SSL handshake '''
     try:
         self.opaque.sock.sock.do_handshake()
     except ssl.SSLError:
         exception = sys.exc_info()[1]
         if exception.args[0] == ssl.SSL_ERROR_WANT_READ:
             POLLER.set_readable(self)
         elif exception.args[0] == ssl.SSL_ERROR_WANT_WRITE:
             POLLER.set_writable(self)
         else:
             raise
     else:
         stream = self.opaque
         self.opaque = None
         stream.atconnect.callback(stream)

 def _schedule_after(self, interval):
     ''' Schedule next rendezvous after interval seconds '''
     logging.info('background_rendezvous: next rendezvous in %d seconds',
                  interval)
     timestamp = POLLER.sched(interval, self.run)
     STATE.update('idle', publish=False)
     STATE.update('next_rendezvous', timestamp)