1

#!/usr/bin/env python

     2

"""

     3

    Simple (limited) netcat-like example, implemented using the socket/lib.event2 layer.

     4

"""

     5

     6

from qmsk.net.socket import socket, address

     7

from qmsk.net.socket.constants import *

     8

     9

from qmsk.net.lib.event2 import base, event

    10

from qmsk.net.lib.event2.constants import *

    11

from qmsk.net.lib.event2.event import CallbackEvent as cb_event

    12

    13

import sys, os, fcntl, errno

    14

import optparse

    15

    16

# global options

    17

options = None

    18

    19

# global event_base

    20

ev_base = base.event_base()

    21

    24

    25

def parse_argv (argv) :

    26

    global options

    27

    28

    prog = argv.pop(0)

    29

    30

    parser = optparse.OptionParser(prog=prog)

    31

    32

    parser.add_option('-4', "--ipv4", help="Force AF_INET", action='store_true')

    33

    parser.add_option('-6', "--ipv6", help="Force AF_INET6", action='store_true')

    34

    parser.add_option('-v', "--verbose", help="Display status output", action='store_true')

    35

    parser.add_option('-d', "--debug", help="Display extra output", action='store_true')

    36

    parser.add_option('-w', "--timeout", help="Timeout for connect()", type='float')

    37

    38

    options, args = parser.parse_args(argv)

    39

    40

    if options.ipv4 and options.ipv6 :

    41

        raise Exception("-4 and -6 are mutually exclusive!")

    42

    43

    if options.debug :

    44

        # enable both

    45

        options.verbose = True

    46

    47

    return args

    48

    49

def log_msg (prefix, msg, *args) :

    50

    if args :

    51

        msg = msg % args

    52

    53

    sys.stderr.write("%s %s\n" % (prefix, msg))

    54

    55

def log_err (msg, *args) :

    56

    log_msg('!!!', msg, *args)

    57

    58

def log_warn (msg, *args) :

    59

    log_msg('+++', msg, *args)

    60

    61

def log_info (msg, *args) :

    62

    if options.verbose :

    63

        log_msg('***', msg, *args)

    64

    65

def log_debug (msg, *args) :

    66

    if options.debug :

    67

        log_msg('---', msg, *args)

    68

    69

    70

def setnonblocking (file) :

    71

    """

    72

        Set the non-blocking IO flag on the given file object

    73

    """

    74

    75

    fcntl.fcntl(file.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)

    76

    77

def sock_connect (host, port, family, socktype) :

    78

    """

    79

        Try and perform a series of non-blocking connects to the given host:port using the given family and socktype,

    80

        yielding a series of socket objects.

    81

    """

    82

    83

    for ai in address.getaddrinfo(host, port, family, socktype) :

    84

        log_info("sock_connect: ai: %s", ai)

    85

    86

        # build socket

    87

        try :

    88

            # construct

    89

            log_debug("sock_connect: socket(%d, %d, %d)", ai.family, ai.socktype, ai.protocol)

    90

            sock = socket.socket(ai.family, ai.socktype, ai.protocol)

    91

            log_debug("sock_connect: socket=%s", sock)

    92

    93

            # set nonblock mode

    94

            log_debug("sock_connect: setnonblocking(%s)", sock)

    95

            setnonblocking(sock)

    96

    97

            # start connect

    98

            try :

    99

                log_debug("sock_connect: connect(%s)", ai.addr)

   100

                sock.connect(ai.addr)

   101

   102

            except OSError, e :

   103

                if e.errno != errno.EINPROGRESS :

   104

                    raise

   105

   106

            else :

   107

                # XXX: wut???

   108

                log_warn("sock_connect: connect: didn't return EINPROGRESS")

   109

   110

        except OSError, e :

   111

            # fsck

   112

            log_warn("sock_connect: %s: %s", ai.addr, e)

   113

   114

        else :

   115

            # yay

   116

            yield sock

   117

   141

def on_connect (ev, events, sock, sock_iter) :

   142

    """

   143

        Outbound connect EV_WRITE callback, i.e. connection failed or was established

   144

    """

   145

   146

    log_debug("on_connect: ev=%r, events=%#x", ev, events)

   147

   148

    # test for timeout

   149

    if events & EV_TIMEOUT :

   150

        log_warn("on_connect: connect failed, timeout")

   151

   152

        # keep trying

   153

        return client_connect_next(sock_iter)

   154

   155

   156

    # test for errno

   157

    err = sock.getsockopt_int(SOL_SOCKET, SO_ERROR)

   158

   159

    if err :

   160

        # fail

   161

        log_warn("on_connect: connect failed, errno=%d", err)

   162

   163

        # keep trying

   164

        return client_connect_next(sock_iter)

   165

   166

   167

    # ok, connected

   169

   170

   172

    """

   174

    """

   175

   180

   181

   212

   213

    else :

   241

   242

def run_client (host, port) :

   243

    """

   244

        Execute in client-mode

   245

    """

   246

   247

    # figure out AF to use

   248

    if options.ipv4 :

   249

        family = AF_INET

   250

   251

    elif options.ipv6 :

   252

        family = AF_INET6

   253

   254

    else :

   255

        family = AF_UNSPEC

   256

   257

    # fixed socktype

   258

    socktype = SOCK_STREAM

   259

   260

    # look up the address and start a non-blocking connect

   261

    sock_iter = sock_connect(host, port, family, socktype)

   262

   263

    # start waiting

   264

    client_connect_next(sock_iter)

   265

   266

def main (argv) :

   267

    # parse args

   268

    args = parse_argv(argv)

   269

   270

    # XXX: support listen mode

   271

    host, port = args

   272

   273

    run_client(host, port)

   274

   275

    # run mainloop

   276

    log_debug("main: entering event loop")

   277

   278

    if ev_base.loop() :

   279

        log_debug("main: event loop done")

   280

   281

    else :

   282

        log_err("main: event loop was idle!")

   283

   284

if __name__ == '__main__' :

   285

    main(sys.argv)

   286