wapproxy.c File Reference

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <assert.h>
#include "gwlib/gwlib.h"
#include "msg.h"
#include "shared.h"
#include "wap/wap.h"
#include "wap/wtp.h"
#include "wap/wtp_pdu.h"

Go to the source code of this file.

Data Structures
struct	_udpc

Typedefs
typedef struct _udpc	Udpc

Enumerations
enum	{ CONNECTIONLESS_PORT = 9200, CONNECTION_ORIENTED_PORT = 9201, WTLS_CONNECTIONLESS_PORT = 9202, WTLS_CONNECTION_ORIENTED_PORT = 9203 }

Functions
static void	udpc_destroy (Udpc *udpc)
static WAPEvent *	wdp_msg2event (Msg *msg)
static void	wdp_event_dump (Msg *msg)
static void	wtp_event_dump (Msg *msg)
static void	dump (Msg *msg)
static void	udp_receiver (void *arg)
static int	send_udp (int fd, Msg *msg)
static void	udp_sender (void *arg)
static Udpc *	udpc_create (int port, char *interface_name, Octstr *map_addr)
static int	add_service (int port, char *interface_name, Octstr *map_addr)
static int	udp_start (Cfg *cfg)
static Udpc *	udpc_find_mapping (Msg *msg, int inbound)
static int	udp_addwdp_from_server (Msg *msg)
static int	udp_addwdp_from_client (Msg *msg)
static int	udp_shutdown (void)
static int	udp_die (void)
static void	wdp_router (void *arg)
static void	service_router (void *arg)
static void	help (void)
int	main (int argc, char **argv)

Variables
static volatile sig_atomic_t	udp_running
static List *	udpc_list
static Octstr *	interface_name = NULL
static Octstr *	wapgw
static int	verbose = 0
static int	server_port = 0
List *	incoming_wdp
List *	outgoing_wdp
List *	flow_threads
Counter *	incoming_wdp_counter
Counter *	outgoing_wdp_counter

Typedef Documentation

Udpc

typedef struct _udpc Udpc

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CONNECTIONLESS_PORT
CONNECTION_ORIENTED_PORT
WTLS_CONNECTIONLESS_PORT
WTLS_CONNECTION_ORIENTED_PORT

Definition at line 123 of file wapproxy.c.

     {
    CONNECTIONLESS_PORT = 9200,
    CONNECTION_ORIENTED_PORT = 9201,
    WTLS_CONNECTIONLESS_PORT = 9202,
    WTLS_CONNECTION_ORIENTED_PORT = 9203
};

Function Documentation

add_service()

static int add_service ( int  port, char *  interface_name, Octstr *  map_addr  )

static

Definition at line 455 of file wapproxy.c.

References error(), gwlist_add_producer(), gwlist_append(), gwthread_create, interface_name, _udpc::outgoing_list, _udpc::receiver, udp_receiver(), udp_sender(), udpc_create(), udpc_destroy(), and udpc_list.

Referenced by udp_addwdp_from_client(), and udp_start().

{
    Udpc *udpc;
    
    if ((udpc = udpc_create(port, interface_name, map_addr)) == NULL)
        goto error;
    gwlist_add_producer(udpc->outgoing_list);

    udpc->receiver = gwthread_create(udp_receiver, udpc);
    if (udpc->receiver == -1)
        goto error;

    if (gwthread_create(udp_sender, udpc) == -1)
        goto error;

    gwlist_append(udpc_list, udpc);
    return 0;
    
error:    
    error(0, "Failed to start UDP receiver/sender thread");
    udpc_destroy(udpc);
    return -1;
}

dump()

static void dump ( Msg *  msg )

static

Definition at line 246 of file wapproxy.c.

References msg, msg_dump(), verbose, wdp_event_dump(), and wtp_event_dump().

Referenced by udp_receiver(), and udp_sender().

{
    switch (verbose) {
        case 0: 
            break;
        case 1:
            msg_dump(msg, 0);
            break;
        case 2:
            wdp_event_dump(msg);
            break;
        case 3:
            msg_dump(msg, 0);
            wdp_event_dump(msg);
            break;
        case 4:
            wtp_event_dump(msg);
            break;
        case 5: 
            msg_dump(msg, 0);
            wtp_event_dump(msg);
            break;
       case 6: 
            wdp_event_dump(msg);
            wtp_event_dump(msg);
            break;
       case 7: 
            msg_dump(msg, 0);
            wdp_event_dump(msg);
            wtp_event_dump(msg);
            break;
    }
}

help()

static void help ( void  )

static

Definition at line 717 of file wapproxy.c.

References info().

Referenced by main().

{
    info(0, "Usage: wapproxy [options] host ...");
    info(0, "where host is the real wap gw to forward to and options are:");
    info(0, "-v number");
    info(0, "    set log level for stderr logging");
    info(0, "-i interface");
    info(0, "    bind to the given interface for UDP server port (default: 0.0.0.0)");
    info(0, "-p port");
    info(0, "    bind to the given port for UDP server port (default: 9201)");
    info(0, "-m");
    info(0, "    dump WDP/UDP packets, msg_dump()");
    info(0, "-e");
    info(0, "    dump WAP event packets, wap_event_dump()");
    info(0, "-t");
    info(0, "    dump WTP PDUs, wtp_pdu_dump()");
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 736 of file wapproxy.c.

References cfg, CONNECTION_ORIENTED_PORT, counter_create(), counter_destroy(), debug(), error(), flow_threads, getopt(), gwlib_init(), gwlib_shutdown(), gwlist_add_producer(), gwlist_consume(), gwlist_create, gwlist_destroy(), gwlist_remove_producer(), gwthread_create, gwthread_sleep(), help(), incoming_wdp, incoming_wdp_counter, interface_name, log_set_output_level(), octstr_create, octstr_destroy(), optarg, optind, outgoing_wdp, outgoing_wdp_counter, panic, report_versions(), server_port, service_router(), udp_shutdown(), udp_start(), verbose, wapgw, and wdp_router().

{
    int opt;
    Cfg *cfg = NULL;
    
    gwlib_init();
    
    server_port = CONNECTION_ORIENTED_PORT;
    
    while ((opt = getopt(argc, argv, "v:meti:p:")) != EOF) {

        switch (opt) {
            case 'v':
                log_set_output_level(atoi(optarg));
                break;

            case 'm':
                verbose += 1;                                           
                break;

            case 'e':
                verbose += 2;
                break;

            case 't':
                verbose += 4;
                break;
                
            case 'h':
                help();
                exit(0);

            case 'i':
                interface_name = octstr_create(optarg);
                break;
                
            case 'p':
                server_port = atoi(optarg);
                break;

            case '?':
            default:
                error(0, "Invalid option %c", opt);
                help();
                panic(0, "Stopping.");
        }
    }
    
    if (optind == argc) {
        help();
        exit(0);
    }

    /* get the host or IP of the real wap gw to forward the WDP packets */
    wapgw = octstr_create(argv[optind]);

    /* if no interface was given use 0.0.0.0 */
    if (!interface_name)
        interface_name = octstr_create("*");

    report_versions("wapproxy");

    /* initialize main inbound and outbound queues */
    outgoing_wdp = gwlist_create();
    incoming_wdp = gwlist_create();
    flow_threads = gwlist_create();

    outgoing_wdp_counter = counter_create();
    incoming_wdp_counter = counter_create();

    /* start the main UDP listening threads */
    udp_start(cfg);

    gwlist_add_producer(outgoing_wdp);    
    
    debug("bb", 0, "starting WDP routers");
    if (gwthread_create(service_router, NULL) == -1)
        panic(0, "Failed to start a new thread for inbound WDP routing");
    if (gwthread_create(wdp_router, NULL) == -1)
        panic(0, "Failed to start a new thread for outbound WDP routing");

    gwthread_sleep(5.0); /* give time to threads to register themselves */

    while (gwlist_consume(flow_threads) != NULL)
    ;

    udp_shutdown();

    gwlist_remove_producer(outgoing_wdp);

    gwlist_destroy(flow_threads, NULL);
    gwlist_destroy(incoming_wdp, NULL);
    gwlist_destroy(outgoing_wdp, NULL);

    counter_destroy(incoming_wdp_counter);
    counter_destroy(outgoing_wdp_counter);
    octstr_destroy(interface_name);
    octstr_destroy(wapgw);

    gwlib_shutdown();

    return 0;
}

send_udp()

static int send_udp ( int  fd, Msg *  msg  )

static

Definition at line 352 of file wapproxy.c.

References error(), msg, octstr_destroy(), udp_create_address(), and udp_sendto().

Referenced by udp_sender().

{
    Octstr *cliaddr;
    int ret;

    cliaddr = udp_create_address(msg->wdp_datagram.destination_address,
                                 msg->wdp_datagram.destination_port);
    ret = udp_sendto(fd, msg->wdp_datagram.user_data, cliaddr);
    if (ret == -1)
        error(0, "could not send UDP datagram");
    octstr_destroy(cliaddr);
    return ret;
}

service_router()

static void service_router ( void *  arg )

static

Definition at line 691 of file wapproxy.c.

References flow_threads, gw_assert(), gwlist_add_producer(), gwlist_consume(), gwlist_remove_producer(), incoming_wdp, msg, udp_addwdp_from_client(), and udp_die().

Referenced by main().

{
    Msg *msg;

    gwlist_add_producer(flow_threads);
    
    while (1) {

        if ((msg = gwlist_consume(incoming_wdp)) == NULL)
            break;

        gw_assert(msg_type(msg) == wdp_datagram);
    
        udp_addwdp_from_client(msg);
    }
    udp_die();

    gwlist_remove_producer(flow_threads);
}

udp_addwdp_from_client()

static int udp_addwdp_from_client ( Msg *  msg )

static

Definition at line 583 of file wapproxy.c.

References add_service(), CONNECTION_ORIENTED_PORT, gwlist_produce(), info(), interface_name, msg, octstr_destroy(), octstr_duplicate, octstr_get_cstr, _udpc::outgoing_list, panic, udp_create_address(), udp_get_ip(), udp_get_port(), udp_running, udpc_find_mapping(), and wapgw.

Referenced by service_router().

{
    Udpc *udpc;
    Octstr *map_addr;
    Octstr *os;
    Octstr *source;
    
    if (!udp_running) return -1;
    assert(msg != NULL);
    assert(msg_type(msg) == wdp_datagram);
    
    /* 
     * Check if there is allready a bound UDP port for this mapping.
     * If not create a mapping and bind the mapped UDP port
     * The mapped port is simply 2x of the client port. 
     */
    if ((udpc = udpc_find_mapping(msg, 1)) == NULL) {
        info(0, "Creating UDP mapping <%s:%ld> <-> <%s:%ld>",
              octstr_get_cstr(msg->wdp_datagram.source_address),
              msg->wdp_datagram.source_port,
              octstr_get_cstr(msg->wdp_datagram.destination_address),
              msg->wdp_datagram.source_port*2);

        map_addr = udp_create_address(msg->wdp_datagram.source_address, 
                                      msg->wdp_datagram.source_port);
        add_service(msg->wdp_datagram.source_port * 2, 
                    octstr_get_cstr(interface_name), map_addr);
        /* now we should find it in the udpc_list */
        if ((udpc = udpc_find_mapping(msg, 1)) == NULL)
            panic(0,"Could not find UDP mapping, internal error");
    }

    /* now swap the message addressing */
    octstr_destroy(msg->wdp_datagram.source_address);
    octstr_destroy(msg->wdp_datagram.destination_address);

    os = octstr_duplicate(interface_name);
    source = udp_create_address(os, msg->wdp_datagram.source_port * 2);
    msg->wdp_datagram.source_address = udp_get_ip(source);
    msg->wdp_datagram.source_port = udp_get_port(source);
    msg->wdp_datagram.destination_address = octstr_duplicate(wapgw);
    msg->wdp_datagram.destination_port = CONNECTION_ORIENTED_PORT;

    octstr_destroy(os);

    gwlist_produce(udpc->outgoing_list, msg);
    
    return -1;
}

udp_addwdp_from_server()

static int udp_addwdp_from_server ( Msg *  msg )

static

Definition at line 532 of file wapproxy.c.

References gwlist_produce(), interface_name, _udpc::map_addr, msg, octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, _udpc::outgoing_list, panic, server_port, udp_create_address(), udp_get_ip(), udp_get_port(), udp_running, and udpc_find_mapping().

Referenced by wdp_router().

{
    Udpc *udpc;
    Octstr *os;
    Octstr *source;

    if (!udp_running) return -1;
    assert(msg != NULL);
    assert(msg_type(msg) == wdp_datagram);

    octstr_destroy(msg->wdp_datagram.source_address);
    msg->wdp_datagram.source_address = 
        octstr_create(octstr_get_cstr(msg->wdp_datagram.destination_address));
    msg->wdp_datagram.source_port = msg->wdp_datagram.destination_port;

    if ((udpc = udpc_find_mapping(msg, 0)) == NULL) 
        /* there should have been one */
        panic(0,"Could not find UDP mapping, internal error");

    /* insert the found mapped destination */
    octstr_destroy(msg->wdp_datagram.source_address);
    octstr_destroy(msg->wdp_datagram.destination_address);
    
    msg->wdp_datagram.destination_address = udp_get_ip(udpc->map_addr);
    msg->wdp_datagram.destination_port = udp_get_port(udpc->map_addr);

    /* now search for our inbound UDP socket */
    os = octstr_duplicate(interface_name);
    source = udp_create_address(os, server_port);

    msg->wdp_datagram.source_address = udp_get_ip(source);
    msg->wdp_datagram.source_port = udp_get_port(source);
    if ((udpc = udpc_find_mapping(msg, 0)) == NULL) 
        panic(0,"Could not find main inbound UDP socket, internal error");

    /* 
     * ok, got the destination, got the socket, 
     * now put it on the outbound queue
     */
    gwlist_produce(udpc->outgoing_list, msg);

    octstr_destroy(os);

    return 0;
}

udp_die()

static int udp_die ( void  )

static

Definition at line 644 of file wapproxy.c.

References debug(), gwlist_consume(), gwlist_destroy(), gwlist_remove_producer(), _udpc::outgoing_list, udp_running, and udpc_list.

Referenced by service_router(), and wdp_router().

{
    Udpc *udpc;

    if (!udp_running) return -1;
    
    /*
     * remove producers from all outgoing lists.
     */
    debug("bb.udp", 0, "udp_die: removing producers from udp-lists");

    while ((udpc = gwlist_consume(udpc_list)) != NULL) {
        gwlist_remove_producer(udpc->outgoing_list);
    }
    gwlist_destroy(udpc_list, NULL);
    udp_running = 0;
    
    return 0;
}

udp_receiver()

static void udp_receiver ( void *  arg )

static

Definition at line 285 of file wapproxy.c.

References _udpc::addr, counter_increase(), dump(), error(), _udpc::fd, flow_threads, gwlist_add_producer(), gwlist_produce(), gwlist_remove_producer(), gwthread_wakeup(), incoming_wdp, incoming_wdp_counter, info(), MAIN_THREAD_ID, _udpc::map_addr, msg, msg_create, octstr_compare(), octstr_destroy(), octstr_get_cstr, outgoing_wdp, outgoing_wdp_counter, read_available(), udp_get_ip(), udp_get_port(), and udp_recvfrom().

Referenced by add_service().

{
    Octstr *datagram, *cliaddr;
    int ret;
    Msg *msg;
    Udpc *conn = arg;
    Octstr *ip;

    gwlist_add_producer(incoming_wdp);
    gwlist_add_producer(flow_threads);
    gwthread_wakeup(MAIN_THREAD_ID);
    
    /* remove messages from socket until it is closed */
    while (1) {

        if (read_available(conn->fd, 100000) < 1)
            continue;

        ret = udp_recvfrom(conn->fd, &datagram, &cliaddr);
        if (ret == -1) {
            if (errno == EAGAIN)
                /* No datagram available, don't block. */
                continue;

            error(errno, "Failed to receive an UDP");
            continue;
        }

        ip = udp_get_ip(cliaddr);
        msg = msg_create(wdp_datagram);
    
        msg->wdp_datagram.source_address = udp_get_ip(cliaddr);
        msg->wdp_datagram.source_port = udp_get_port(cliaddr);
        msg->wdp_datagram.destination_address = udp_get_ip(conn->addr);
        msg->wdp_datagram.destination_port = udp_get_port(conn->addr);
        msg->wdp_datagram.user_data = datagram;

        info(0, "datagram received <%s:%d> -> <%s:%d>",
             octstr_get_cstr(udp_get_ip(cliaddr)), udp_get_port(cliaddr),
             octstr_get_cstr(udp_get_ip(conn->addr)), udp_get_port(conn->addr));

        dump(msg);

        /* 
         * Descide if this is (a) or (b) UDP packet and add them to the
         * corresponding queues
         */
        if (octstr_compare(conn->addr, conn->map_addr) == 0) {
            gwlist_produce(incoming_wdp, msg);
            counter_increase(incoming_wdp_counter);
        } else {
            gwlist_produce(outgoing_wdp, msg);
            counter_increase(outgoing_wdp_counter);
        }        

        octstr_destroy(cliaddr);
        octstr_destroy(ip);
    }    
    gwlist_remove_producer(incoming_wdp);
    gwlist_remove_producer(flow_threads);
}

udp_sender()

static void udp_sender ( void *  arg )

static

Definition at line 367 of file wapproxy.c.

References counter_increase(), dump(), _udpc::fd, flow_threads, gwlist_add_producer(), gwlist_consume(), gwlist_remove_producer(), gwthread_join(), info(), msg, msg_destroy(), octstr_get_cstr, _udpc::outgoing_list, outgoing_wdp_counter, _udpc::receiver, send_udp(), and udpc_destroy().

Referenced by add_service().

{
    Msg *msg;
    Udpc *conn = arg;

    gwlist_add_producer(flow_threads);    
    while (1) {

        if ((msg = gwlist_consume(conn->outgoing_list)) == NULL)
            break;

        info(0, "sending datagram <%s:%ld> -> <%s:%ld>",
              octstr_get_cstr(msg->wdp_datagram.source_address),
              msg->wdp_datagram.source_port,
              octstr_get_cstr(msg->wdp_datagram.destination_address),
              msg->wdp_datagram.destination_port);

        dump(msg);

        if (send_udp(conn->fd, msg) == -1) {
            msg_destroy(msg);
            continue;
        }
        counter_increase(outgoing_wdp_counter);
        msg_destroy(msg);
    }
    gwthread_join(conn->receiver);

    udpc_destroy(conn);
    gwlist_remove_producer(flow_threads);
}

udp_shutdown()

static int udp_shutdown ( void  )

static

Definition at line 634 of file wapproxy.c.

References debug(), gwlist_remove_producer(), incoming_wdp, and udp_running.

Referenced by main().

{
    if (!udp_running) return -1;

    debug("bb.thread", 0, "udp_shutdown: Starting avalanche");
    gwlist_remove_producer(incoming_wdp);
    return 0;
}

udp_start()

static int udp_start ( Cfg *  cfg )

static

Definition at line 485 of file wapproxy.c.

References add_service(), debug(), gwlist_add_producer(), gwlist_create, incoming_wdp, interface_name, octstr_get_cstr, server_port, udp_running, and udpc_list.

Referenced by main().

{

    if (udp_running) return -1;
    
    debug("wap.proxy", 0, "starting UDP sender/receiver module");

    udpc_list = gwlist_create();    /* have a list of running systems */

    add_service(server_port, octstr_get_cstr(interface_name), NULL);  /* wsp/wtp */
    
    gwlist_add_producer(incoming_wdp);
    udp_running = 1;
    return 0;
}

udpc_create()

static Udpc* udpc_create ( int  port, char *  interface_name, Octstr *  map_addr  )

static

Definition at line 404 of file wapproxy.c.

References _udpc::addr, debug(), error(), _udpc::fd, gwlist_create, interface_name, _udpc::map_addr, octstr_create, octstr_destroy(), octstr_get_cstr, _udpc::outgoing_list, udp_bind(), udp_create_address(), udp_get_ip(), and udp_get_port().

Referenced by add_service().

{
    Udpc *udpc;
    Octstr *os;
    int fl;
    
    udpc = gw_malloc(sizeof(Udpc));
    udpc->fd = udp_bind(port, interface_name);
  
    os = octstr_create(interface_name);
    udpc->addr = udp_create_address(os, port);
    udpc->map_addr = map_addr ? map_addr : udpc->addr;

    octstr_destroy(os);
    if (udpc->addr == NULL) {
        error(0, "updc_create: could not resolve interface <%s>", interface_name);
        close(udpc->fd);
        gw_free(udpc);
        return NULL;
    }

    fl = fcntl(udpc->fd, F_GETFL);
    fcntl(udpc->fd, F_SETFL, fl | O_NONBLOCK);

    os = udp_get_ip(udpc->addr);
    debug("wap.proxy",0, "bound to UDP <%s:%d>",
          octstr_get_cstr(os), udp_get_port(udpc->addr));

    octstr_destroy(os);
    
    udpc->outgoing_list = gwlist_create();

    return udpc;
}    

udpc_destroy()

static void udpc_destroy ( Udpc *  udpc )

static

Definition at line 440 of file wapproxy.c.

References _udpc::addr, _udpc::fd, gw_assert(), gwlist_destroy(), gwlist_len(), octstr_destroy(), and _udpc::outgoing_list.

Referenced by add_service(), and udp_sender().

{
    if (udpc == NULL)
        return;

    if (udpc->fd >= 0)
        close(udpc->fd);
    octstr_destroy(udpc->addr);
    gw_assert(gwlist_len(udpc->outgoing_list) == 0);
    gwlist_destroy(udpc->outgoing_list, NULL);

    gw_free(udpc);
}    

udpc_find_mapping()

static Udpc* udpc_find_mapping ( Msg *  msg, int  inbound  )

static

Definition at line 502 of file wapproxy.c.

References _udpc::addr, gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_unlock(), _udpc::map_addr, msg, octstr_compare(), udp_get_ip(), udp_get_port(), and udpc_list.

Referenced by udp_addwdp_from_client(), and udp_addwdp_from_server().

{
    int i;
    Udpc *udpc;
    Octstr *addr;
    
    /* check if there is allready a bound UDP port */
    gwlist_lock(udpc_list);
    for (i=0; i < gwlist_len(udpc_list); i++) {
        udpc = gwlist_get(udpc_list, i);

        /* decide if we compare against inbound or outbound traffic mapping */
        addr = inbound ? udpc->map_addr : udpc->addr;

        if (msg->wdp_datagram.source_port == udp_get_port(addr) &&
            octstr_compare(msg->wdp_datagram.source_address, 
                           udp_get_ip(addr)) == 0) {
            gwlist_unlock(udpc_list);
            return udpc;
        }
    }
    gwlist_unlock(udpc_list);
    return NULL;
}

wdp_event_dump()

static void wdp_event_dump ( Msg *  msg )

static

Definition at line 172 of file wapproxy.c.

References msg, wap_event_destroy(), wap_event_dump(), and wdp_msg2event().

Referenced by dump().

{
    WAPEvent *dgram;

    if ((dgram = wdp_msg2event(msg)) != NULL)
        /* wap_dispatch_datagram(dgram); */
        wap_event_dump(dgram);

    wap_event_destroy(dgram);
}

wdp_msg2event()

static WAPEvent* wdp_msg2event ( Msg *  msg )

static

Definition at line 148 of file wapproxy.c.

References CONNECTION_ORIENTED_PORT, gw_assert(), msg, octstr_duplicate, server_port, WAPEvent::u, wap_addr_tuple_create(), and wap_event_create.

Referenced by wdp_event_dump(), and wtp_event_dump().

{
    WAPEvent *dgram = NULL;

    gw_assert(msg_type(msg) == wdp_datagram);

    if (msg->wdp_datagram.destination_port == server_port ||
        msg->wdp_datagram.source_port == server_port ||
        msg->wdp_datagram.destination_port == CONNECTION_ORIENTED_PORT ||
        msg->wdp_datagram.source_port == CONNECTION_ORIENTED_PORT) {

        dgram = wap_event_create(T_DUnitdata_Ind);
        dgram->u.T_DUnitdata_Ind.addr_tuple = wap_addr_tuple_create(
                msg->wdp_datagram.source_address,
                msg->wdp_datagram.source_port,
                msg->wdp_datagram.destination_address,
                msg->wdp_datagram.destination_port);
        dgram->u.T_DUnitdata_Ind.user_data = 
                octstr_duplicate(msg->wdp_datagram.user_data);
    }
    return dgram;
}

wdp_router()

static void wdp_router ( void *  arg )

static

Definition at line 670 of file wapproxy.c.

References flow_threads, gw_assert(), gwlist_add_producer(), gwlist_consume(), gwlist_remove_producer(), msg, outgoing_wdp, udp_addwdp_from_server(), and udp_die().

Referenced by main().

{
    Msg *msg;

    gwlist_add_producer(flow_threads);
    
    while (1) {

        if ((msg = gwlist_consume(outgoing_wdp)) == NULL)
            break;

        gw_assert(msg_type(msg) == wdp_datagram);
    
        udp_addwdp_from_server(msg);
    }
    udp_die();

    gwlist_remove_producer(flow_threads);
}

wtp_event_dump()

static void wtp_event_dump ( Msg *  msg )

static

Definition at line 184 of file wapproxy.c.

References debug(), error(), gwlist_destroy(), gwlist_extract_first(), gwlist_len(), info(), msg, WAPEvent::type, wap_event_destroy(), wap_event_dump(), wap_event_name(), wdp_msg2event(), wtp_event_is_for_responder(), and wtp_unpack_wdp_datagram().

Referenced by dump().

{
    WAPEvent *dgram;
    List *events;
    long i, n;

    dgram = wdp_msg2event(msg);
    if (dgram == NULL)
        error(0, "dgram is null");

    /*
    pdu = wtp_pdu_unpack(dgram->u.T_DUnitdata_Ind.user_data);
    if (pdu == NULL) {
        error(0, "WTP PDU unpacking failed, WAP event is:");
        wap_event_dump(dgram);
    } else {
        wtp_pdu_dump(pdu, 0);
        wtp_pdu_destroy(pdu);
    }
    */

    events = wtp_unpack_wdp_datagram(dgram);
    n = gwlist_len(events);
    debug("wap.proxy",0,"datagram contains %ld events", n);

    i = 1;
    while (gwlist_len(events) > 0) {
        WAPEvent *event;

        event = gwlist_extract_first(events);
        
        info(0, "WTP: %ld/%ld event %s.", i, n, wap_event_name(event->type));

        if (wtp_event_is_for_responder(event))
            /* wtp_resp_dispatch_event(event); */
            debug("",0,"datagram is for WTP responder");
        else
            /* wtp_initiator_dispatch_event(event); */
            debug("",0,"datagram is for WTP initiator");
 
        wap_event_dump(event);
        /*
        switch (event->type) {
            RcvInvoke:
                debug("",0,"XXX invoke");
                break;
            RcvResult:
                debug("",0,"XXX result");
                break;
            default:
                error(0,"unkown WTP event type while unpacking");
                break;
        }
        */
        i++;
    }           

    wap_event_destroy(dgram);
    gwlist_destroy(events, NULL);
}

Variable Documentation

flow_threads

List* flow_threads

Definition at line 118 of file wapproxy.c.

Referenced by bb_smscconn_killed(), bb_smscconn_ready(), boxc_sender(), main(), run_smsbox(), run_wapbox(), service_router(), sms_router(), sms_to_smsboxes(), smsboxc_run(), udp_receiver(), udp_sender(), wapboxc_run(), wdp_router(), and wdp_to_wapboxes().

incoming_wdp

List* incoming_wdp

Definition at line 116 of file wapproxy.c.

Referenced by main(), run_wapbox(), service_router(), udp_receiver(), udp_shutdown(), udp_start(), wapboxc_run(), and wdp_to_wapboxes().

incoming_wdp_counter

Counter* incoming_wdp_counter

Definition at line 120 of file wapproxy.c.

Referenced by main(), and udp_receiver().

interface_name

Octstr* interface_name = NULL

static

Definition at line 111 of file wapproxy.c.

Referenced by add_service(), main(), make_server_socket(), udp_addwdp_from_client(), udp_addwdp_from_server(), udp_start(), and udpc_create().

outgoing_wdp

List* outgoing_wdp

Definition at line 117 of file wapproxy.c.

Referenced by main(), run_wapbox(), udp_receiver(), wapbox_start(), wapboxc_run(), and wdp_router().

outgoing_wdp_counter

Counter* outgoing_wdp_counter

Definition at line 121 of file wapproxy.c.

Referenced by main(), udp_receiver(), and udp_sender().

server_port

int server_port = 0

static

Definition at line 114 of file wapproxy.c.

Referenced by main(), udp_addwdp_from_server(), udp_start(), and wdp_msg2event().

udp_running

volatile sig_atomic_t udp_running

static

Definition at line 109 of file wapproxy.c.

Referenced by udp_addwdp_from_client(), udp_addwdp_from_server(), udp_die(), udp_shutdown(), and udp_start().

udpc_list

List* udpc_list

static

Definition at line 110 of file wapproxy.c.

Referenced by add_service(), udp_die(), udp_start(), and udpc_find_mapping().

verbose

int verbose = 0

static

Definition at line 113 of file wapproxy.c.

Referenced by dump(), and main().

wapgw

Octstr* wapgw

static

Definition at line 112 of file wapproxy.c.

Referenced by main(), and udp_addwdp_from_client().