drive_smpp.c File Reference

#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "gwlib/gwlib.h"
#include "gw/smsc/smpp_pdu.h"
#include "gw/msg.h"

Go to the source code of this file.

Data Structures
struct	ESME

Macros
#define	HANDLER(name)   { name, handle_ ## name },

Functions
static void	quit (void)
static ESME *	esme_create (Connection *conn)
static void	esme_destroy (ESME *esme)
static SMPP_PDU *	handle_bind_transmitter (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_bind_receiver (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_submit_sm (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_deliver_sm_resp (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_unbind (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_enquire_link (ESME *esme, SMPP_PDU *pdu)
static SMPP_PDU *	handle_enquire_link_resp (ESME *esme, SMPP_PDU *pdu)
static void	handle_pdu (ESME *esme, SMPP_PDU *pdu)
static void	send_smpp_thread (void *arg)
static void	receive_smpp_thread (void *arg)
static void	smsbox_thread (void *arg)
static void	accept_thread (void *arg)
static void	handler (int signal)
static void	help (void)
int	main (int argc, char **argv)

Variables
static int	quitting = 0
static Octstr *	smsc_system_id
static Octstr *	smsc_source_addr
static Counter *	message_id_counter
static Octstr *	bearerbox_host
static int	port_for_smsbox
static Counter *	num_to_esme
static long	max_to_esme
static Counter *	num_from_bearerbox
static Counter *	num_to_bearerbox
static Counter *	num_from_esme
static time_t	start_time = (time_t) -1
static time_t	first_to_esme = (time_t) -1
static time_t	last_to_esme = (time_t) -1
static time_t	last_from_esme = (time_t) -1
static time_t	first_from_bb = (time_t) -1
static time_t	last_to_bb = (time_t) -1
static long	enquire_interval = 1
struct {
unsigned long   type
SMPP_PDU *(*   handler )(ESME *, SMPP_PDU *)
}	handlers []
static int	num_handlers = sizeof(handlers) / sizeof(handlers[0])

Macro Definition Documentation

HANDLER

#define HANDLER

(

name

)

{ name, handle_ ## name },

Function Documentation

accept_thread()

static void accept_thread ( void *  arg )

static

Definition at line 422 of file drive_smpp.c.

References conn_wrap_fd(), debug(), esme_create(), gwthread_create, gwthread_pollfd(), make_server_socket(), panic, POLLIN, port, receive_smpp_thread(), smsbox_thread(), and start_time.

Referenced by main().

{
    int fd;
    int new_fd;
    int port;
    socklen_t addrlen;
    struct sockaddr addr;
    long smsbox_thread_id;
    
    port = *(int *) arg;
    fd = make_server_socket(port, NULL);
    if (fd == -1)
        panic(0, "Couldn't create SMPP listen port.");
    
    smsbox_thread_id = -1;
    for (;;) {
    if (gwthread_pollfd(fd, POLLIN, -1.0) != POLLIN)
        break;
    addrlen = sizeof(addr);
    new_fd = accept(fd, &addr, &addrlen);
        if (start_time == (time_t) -1)
        time(&start_time);
    gwthread_create(receive_smpp_thread, 
            esme_create(conn_wrap_fd(new_fd, 0)));
    if (smsbox_thread_id == -1)
        smsbox_thread_id = gwthread_create(smsbox_thread, NULL);
    }
    
    debug("test.smpp", 0, "%s terminates.", __func__);
}

esme_create()

static ESME* esme_create ( Connection *  conn )

static

Definition at line 109 of file drive_smpp.c.

References ESME::conn, ESME::receiver, ESME::transmitter, and ESME::version.

Referenced by accept_thread().

{
    ESME *esme;
    
    esme = gw_malloc(sizeof(*esme));
    esme->conn = conn;
    esme->transmitter = 0;
    esme->receiver = 0;
    esme->version = 0;
    return esme;
}

esme_destroy()

static void esme_destroy ( ESME *  esme )

static

Definition at line 122 of file drive_smpp.c.

References ESME::conn, and conn_destroy().

Referenced by receive_smpp_thread().

{
    if (esme != NULL) {
    conn_destroy(esme->conn);
    gw_free(esme);
    }
}

handle_bind_receiver()

static SMPP_PDU* handle_bind_receiver ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 147 of file drive_smpp.c.

References octstr_duplicate, ESME::receiver, smpp_pdu_create(), smsc_system_id, SMPP_PDU::u, and ESME::version.

{
    SMPP_PDU *resp;
    
    esme->receiver = 1;
    esme->version = pdu->u.bind_receiver.interface_version;
    resp = smpp_pdu_create(bind_receiver_resp,
                            pdu->u.bind_receiver.sequence_number);
#if 0 /* XXX system_id is not implemented in the PDU at the moment */
    resp->u.bind_receiver_resp.system_id = octstr_duplicate(smsc_system_id);
#endif
    return resp;
}

handle_bind_transmitter()

static SMPP_PDU* handle_bind_transmitter ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 131 of file drive_smpp.c.

References octstr_duplicate, smpp_pdu_create(), smsc_system_id, ESME::transmitter, SMPP_PDU::u, and ESME::version.

{
    SMPP_PDU *resp;
    
    esme->transmitter = 1;
    esme->version = pdu->u.bind_transmitter.interface_version;
    resp = smpp_pdu_create(bind_transmitter_resp,
                            pdu->u.bind_transmitter.sequence_number);
#if 0 /* XXX system_id is not implemented in the PDU at the moment */
    resp->u.bind_transmitter_resp.system_id = 
        octstr_duplicate(smsc_system_id);
#endif
    return resp;
}

handle_deliver_sm_resp()

static SMPP_PDU* handle_deliver_sm_resp ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 183 of file drive_smpp.c.

{
    return NULL;
}

handle_enquire_link()

static SMPP_PDU* handle_enquire_link ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 198 of file drive_smpp.c.

References smpp_pdu_create(), and SMPP_PDU::u.

{
    return smpp_pdu_create(enquire_link_resp, 
                           pdu->u.enquire_link.sequence_number);
}

handle_enquire_link_resp()

static SMPP_PDU* handle_enquire_link_resp ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 205 of file drive_smpp.c.

{
    return NULL;
}

handle_pdu()

static void handle_pdu ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 228 of file drive_smpp.c.

References ESME::conn, conn_write(), debug(), error(), handlers, num_handlers, octstr_destroy(), octstr_imm(), smpp_pdu_destroy(), smpp_pdu_dump(), smpp_pdu_pack(), SMPP_PDU::type, type, and SMPP_PDU::type_name.

Referenced by receive_smpp_thread().

{
    SMPP_PDU *resp;
    Octstr *os;
    int i;

    debug("test.smpp", 0, "Handling SMPP PDU of type %s", pdu->type_name);
    for (i = 0; i < num_handlers; ++i) {
        if (handlers[i].type == pdu->type) {
        resp = handlers[i].handler(esme, pdu);
        if (resp != NULL) {
            os = smpp_pdu_pack(NULL, resp);
        conn_write(esme->conn, os);
        octstr_destroy(os);
        smpp_pdu_destroy(resp);
        }
        return;
    }
    }

    error(0, "Unhandled SMPP PDU.");
    smpp_pdu_dump(octstr_imm(""), pdu);
}

handle_submit_sm()

static SMPP_PDU* handle_submit_sm ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 162 of file drive_smpp.c.

References counter_increase(), debug(), info(), last_from_esme, max_to_esme, message_id_counter, num_from_esme, octstr_format(), octstr_get_cstr, smpp_pdu_create(), and SMPP_PDU::u.

{
    SMPP_PDU *resp;
    unsigned long id;
    
    debug("test.smpp", 0, "submit_sm: short_message = <%s>",
          octstr_get_cstr(pdu->u.submit_sm.short_message));
    id = counter_increase(num_from_esme) + 1;
    if (id == max_to_esme)
        info(0, "ESME has submitted all messages to SMSC.");
    time(&last_from_esme);

    resp = smpp_pdu_create(submit_sm_resp, pdu->u.submit_sm.sequence_number);
#if 0 /* XXX message_id is not implemented in the PDU at the moment */
    resp->u.submit_sm_resp.message_id = 
        octstr_format("%ld", counter_increase(message_id_counter));
#endif
    return resp;
}

handle_unbind()

static SMPP_PDU* handle_unbind ( ESME *  esme, SMPP_PDU *  pdu  )

static

Definition at line 189 of file drive_smpp.c.

References smpp_pdu_create(), and SMPP_PDU::u.

{
    SMPP_PDU *resp;
    
    resp = smpp_pdu_create(unbind_resp, pdu->u.unbind.sequence_number);
    return resp;
}

handler()

static void handler ( int  signal )

static

Definition at line 454 of file drive_smpp.c.

References panic.

{
    panic(0, "Caught signal %d.", signal);
}

help()

static void help ( void  )

static

Definition at line 460 of file drive_smpp.c.

References info().

Referenced by main().

{
    info(0, "drive_smpp [-h] [-v level][-l logfile][-p port][-m msgs][-c config]");
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 466 of file drive_smpp.c.

References accept_thread(), bearerbox_host, cfg, cfg_create(), cfg_destroy(), cfg_read(), counter_create(), counter_destroy(), counter_value(), debug(), error(), first_from_bb, first_to_esme, getopt(), GW_DEBUG, GW_NON_EXCL, gwlib_init(), gwlib_shutdown(), gwthread_create, gwthread_join_all(), handler, help(), info(), last_from_esme, last_to_bb, last_to_esme, log_open(), log_set_output_level(), max_to_esme, message_id_counter, num_from_bearerbox, num_from_esme, num_to_bearerbox, num_to_esme, octstr_create, octstr_destroy(), optarg, panic, port, port_for_smsbox, smpp_pdu_init(), smsc_source_addr, smsc_system_id, and start_time.

{
    struct sigaction act;
    int port;
    int opt;
    double run_time;
    char *log_file;
    char *config_file;

    gwlib_init();

    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGTERM, &act, NULL);
    sigaction(SIGINT, &act, NULL);

    port = 2345;
    smsc_system_id = octstr_create("kannel_smpp");
    smsc_source_addr = octstr_create("123456");
    message_id_counter = counter_create();
    bearerbox_host = octstr_create("127.0.0.1");
    port_for_smsbox = 13001;
    max_to_esme = 1;
    num_to_esme = counter_create();
    num_from_esme = counter_create();
    num_to_bearerbox = counter_create();
    num_from_bearerbox = counter_create();
    log_file = config_file = NULL;

    while ((opt = getopt(argc, argv, "hv:p:m:l:c:")) != EOF) {
    switch (opt) {
    case 'v':
        log_set_output_level(atoi(optarg));
        break;

    case 'h':
        help();
        exit(0);

    case 'm':
        max_to_esme = atoi(optarg);
        break;

    case 'p':
        port = atoi(optarg);
        break;

    case 'l':
        log_file = optarg;
        break;
    
    case 'c':
        config_file = optarg;
        break;

    case '?':
    default:
        error(0, "Invalid option %c", opt);
        help();
        panic(0, "Stopping.");
    }
    }

    if (log_file != NULL)
        log_open(log_file, GW_DEBUG, GW_NON_EXCL);

    if (config_file != NULL) {
        Cfg *cfg;
        Octstr *tmp = octstr_create(config_file);
        
        cfg = cfg_create(tmp);
        octstr_destroy(tmp);
        if (cfg_read(cfg) == -1)
            panic(0, "Errors in config file.");
        smpp_pdu_init(cfg);
        cfg_destroy(cfg);
    }
            
    info(0, "Starting drive_smpp test.");
    gwthread_create(accept_thread, &port);
    gwthread_join_all();
    debug("test.smpp", 0, "Program exiting normally.");

    run_time = difftime(last_from_esme, first_to_esme);

    info(0, "Number of messages sent to ESME: %ld",
         counter_value(num_to_esme));
    info(0, "Number of messages sent to smsbox: %ld",
         counter_value(num_from_bearerbox));
    info(0, "Number of messages sent to bearerbox: %ld",
         counter_value(num_to_bearerbox));
    info(0, "Number of messages sent to SMSC: %ld",
         counter_value(num_from_esme));
    info(0, "Time: %.0f secs", run_time);
    info(0, "Time until all sent to ESME: %.0f secs", 
         difftime(last_to_esme, start_time));
    info(0, "Time from first from bb to last to bb: %.0f secs", 
         difftime(last_to_bb, first_from_bb));
    info(0, "Time until all sent to SMSC: %.0f secs", 
         difftime(last_from_esme, start_time));
    info(0, "SMPP messages SMSC to ESME: %.1f msgs/sec",
         counter_value(num_to_esme) / run_time);
    info(0, "SMPP messages ESME to SMSC: %.1f msgs/sec",
         counter_value(num_from_esme) / run_time);

    octstr_destroy(smsc_system_id);
    octstr_destroy(smsc_source_addr);
    octstr_destroy(bearerbox_host);
    counter_destroy(num_to_esme);
    counter_destroy(num_from_esme);
    counter_destroy(num_to_bearerbox);
    counter_destroy(num_from_bearerbox);
    counter_destroy(message_id_counter);

    gwlib_shutdown();
    return 0;
}

quit()

static void quit ( void  )

static

Definition at line 94 of file drive_smpp.c.

References gwthread_wakeup_all(), and quitting.

Referenced by receive_smpp_thread().

{
    quitting = 1;
    gwthread_wakeup_all();
}

receive_smpp_thread()

static void receive_smpp_thread ( void *  arg )

static

Definition at line 300 of file drive_smpp.c.

References ESME::conn, conn_eof(), conn_error(), conn_wait(), debug(), error(), esme_destroy(), gw_assert(), gwthread_create, gwthread_join(), handle_pdu(), octstr_destroy(), octstr_dump, quit(), quitting, ESME::receiver, send_smpp_thread(), smpp_pdu_destroy(), smpp_pdu_read_data(), smpp_pdu_read_len(), and smpp_pdu_unpack().

Referenced by accept_thread().

{
    ESME *esme;
    Octstr *os;
    long len;
    long sender_id;
    SMPP_PDU *pdu;

    esme = arg;
    
    sender_id = -1;
    len = 0;
    while (!quitting && conn_wait(esme->conn, -1.0) != -1) {
        for (;;) {
        if (len == 0) {
        len = smpp_pdu_read_len(esme->conn);
        if (len == -1) {
            error(0, "Client sent garbage, closing connection.");
            goto error;
        } else if (len == 0) {
            if (conn_eof(esme->conn) || conn_error(esme->conn))
                goto error;
            break;
        }
        }
    
            gw_assert(len > 0);
        os = smpp_pdu_read_data(esme->conn, len);
        if (os != NULL) {
                len = 0;
        pdu = smpp_pdu_unpack(NULL, os);
        if (pdu == NULL) {
            error(0, "PDU unpacking failed!");
            octstr_dump(os, 0);
        } else {
            handle_pdu(esme, pdu);
            smpp_pdu_destroy(pdu);
        }
        octstr_destroy(os);
        } else if (conn_eof(esme->conn) || conn_error(esme->conn))
            goto error;
        else
        break;
    }

        if (!quitting && esme->receiver && sender_id == -1)
        sender_id = gwthread_create(send_smpp_thread, esme);
    }

error:
    if (sender_id != -1) {
    quit();
    gwthread_join(sender_id);
    }
    esme_destroy(esme);
    quit();
    debug("test.smpp", 0, "%s terminates.", __func__);
}

send_smpp_thread()

static void send_smpp_thread ( void *  arg )

static

Definition at line 253 of file drive_smpp.c.

References ESME::conn, conn_write(), counter_increase(), counter_value(), debug(), enquire_interval, first_to_esme, gwthread_sleep(), info(), last_to_esme, max_to_esme, message_id_counter, num_from_esme, num_to_esme, octstr_create, octstr_destroy(), octstr_format(), quitting, smpp_pdu_create(), smpp_pdu_destroy(), smpp_pdu_pack(), SMPP_PDU::u, and ESME::version.

Referenced by receive_smpp_thread().

{
    ESME *esme;
    Octstr *os;
    SMPP_PDU *pdu;
    unsigned long id;

    esme = arg;
    
    id = 0;
    while (!quitting && counter_value(num_to_esme) < max_to_esme) {
        id = counter_increase(num_to_esme) + 1;
        while (!quitting && counter_value(num_from_esme) + 500 < id)
            gwthread_sleep(1.0);
        if (quitting)
            break;
        pdu = smpp_pdu_create(deliver_sm, counter_increase(message_id_counter));
        pdu->u.deliver_sm.source_addr = octstr_create("456");
        pdu->u.deliver_sm.destination_addr = octstr_create("123");
        pdu->u.deliver_sm.short_message = octstr_format("%ld", id);
        if (esme->version > 0x33)
            pdu->u.deliver_sm.receipted_message_id = octstr_create("receipted_message_id\0");
        os = smpp_pdu_pack(NULL, pdu);
        conn_write(esme->conn, os);
        octstr_destroy(os);
        smpp_pdu_destroy(pdu);
        if (first_to_esme == (time_t) -1)
            time(&first_to_esme);
        debug("test.smpp", 0, "Delivered SMS %ld of %ld to bearerbox via SMPP.",
              id, max_to_esme);

        if ((id % enquire_interval) == 0) {
            pdu = smpp_pdu_create(enquire_link, counter_increase(message_id_counter));
            os = smpp_pdu_pack(NULL, pdu);
            conn_write(esme->conn, os);
            octstr_destroy(os);
            smpp_pdu_destroy(pdu);
            debug("test.smpp", 0, "Sent enquire_link to bearerbox.");
        }
    }
    time(&last_to_esme);
    if (id == max_to_esme)
    info(0, "All messages sent to ESME.");
    debug("test.smpp", 0, "%s terminates.", __func__);
}

smsbox_thread()

static void smsbox_thread ( void *  arg )

static

Definition at line 360 of file drive_smpp.c.

References bearerbox_host, conn_destroy(), conn_eof(), conn_error(), conn_open_tcp(), conn_read_withlen(), conn_wait(), conn_write_withlen(), counter_increase(), debug(), error(), first_from_bb, gwthread_sleep(), info(), last_to_bb, max_to_esme, msg, msg_create, msg_destroy(), msg_pack(), msg_unpack, num_from_bearerbox, num_to_bearerbox, octstr_create, octstr_destroy(), octstr_get_cstr, panic, port_for_smsbox, and quitting.

Referenced by accept_thread().

{
    Connection *conn;
    Msg *msg;
    Octstr *os;
    Octstr *reply_msg;
    unsigned long count;
    
    msg = msg_create(sms);
    msg->sms.sender = octstr_create("123");
    msg->sms.receiver = octstr_create("456");
    msg->sms.msgdata = octstr_create("hello world");
    reply_msg = msg_pack(msg);
    msg_destroy(msg);

    gwthread_sleep(1.0);
    conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
    if (conn == NULL) {
    gwthread_sleep(2.0);
    conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
        if (conn == NULL)
        panic(0, "Couldn't connect to bearerbox as smsbox");
    }

    while (!quitting && conn_wait(conn, -1.0) != -1) {
        for (;;) {
        os = conn_read_withlen(conn);
        if (os == NULL) {
        if (conn_eof(conn) || conn_error(conn))
            goto error;
        break;
        }
        
        msg = msg_unpack(os);
        if (msg == NULL || msg->type == wdp_datagram)
        error(0, "Bearerbox sent garbage to smsbox");

        if (msg->type == sms) {
        if (first_from_bb == (time_t) -1)
            time(&first_from_bb);
        count = counter_increase(num_from_bearerbox) + 1;
        debug("test.smpp", 0, 
              "Bearerbox sent sms #%ld <%s> to smsbox, sending reply.",
              count, octstr_get_cstr(msg->sms.msgdata));
        if (count == max_to_esme)
            info(0, "Bearerbox has sent all messages to smsbox.");
        conn_write_withlen(conn, reply_msg);
        counter_increase(num_to_bearerbox);
        }
        msg_destroy(msg);
        octstr_destroy(os);
        time(&last_to_bb);
    }
    }
    
error:
    conn_destroy(conn);
    octstr_destroy(reply_msg);
    debug("test.smpp", 0, "%s terminates.", __func__);
}

Variable Documentation

bearerbox_host

Octstr* bearerbox_host

static

Definition at line 78 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

enquire_interval

long enquire_interval = 1

static

Definition at line 91 of file drive_smpp.c.

Referenced by send_smpp_thread().

first_from_bb

time_t first_from_bb = (time_t) -1

static

Definition at line 89 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

first_to_esme

time_t first_to_esme = (time_t) -1

static

Definition at line 86 of file drive_smpp.c.

Referenced by main(), and send_smpp_thread().

handler

SMPP_PDU*(* handler) (ESME *, SMPP_PDU *)

Definition at line 213 of file drive_smpp.c.

Referenced by charset_from_utf8(), charset_to_utf8(), and main().

handlers

struct { ... } handlers[]

Initial value:

= {
#define HANDLER(name) 








}

Referenced by handle_pdu().

last_from_esme

time_t last_from_esme = (time_t) -1

static

Definition at line 88 of file drive_smpp.c.

Referenced by handle_submit_sm(), and main().

last_to_bb

time_t last_to_bb = (time_t) -1

static

Definition at line 90 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

last_to_esme

time_t last_to_esme = (time_t) -1

static

Definition at line 87 of file drive_smpp.c.

Referenced by main(), and send_smpp_thread().

max_to_esme

long max_to_esme

static

Definition at line 81 of file drive_smpp.c.

Referenced by handle_submit_sm(), main(), send_smpp_thread(), and smsbox_thread().

message_id_counter

Counter* message_id_counter

static

Definition at line 77 of file drive_smpp.c.

Referenced by handle_submit_sm(), main(), and send_smpp_thread().

num_from_bearerbox

Counter* num_from_bearerbox

static

Definition at line 82 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

num_from_esme

Counter* num_from_esme

static

Definition at line 84 of file drive_smpp.c.

Referenced by handle_submit_sm(), main(), and send_smpp_thread().

num_handlers

int num_handlers = sizeof(handlers) / sizeof(handlers[0])

static

Definition at line 225 of file drive_smpp.c.

Referenced by handle_pdu().

num_to_bearerbox

Counter* num_to_bearerbox

static

Definition at line 83 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

num_to_esme

Counter* num_to_esme

static

Definition at line 80 of file drive_smpp.c.

Referenced by main(), and send_smpp_thread().

port_for_smsbox

int port_for_smsbox

static

Definition at line 79 of file drive_smpp.c.

Referenced by main(), and smsbox_thread().

quitting

int quitting = 0

static

Definition at line 74 of file drive_smpp.c.

Referenced by quit(), receive_smpp_thread(), send_smpp_thread(), and smsbox_thread().

smsc_source_addr

Octstr* smsc_source_addr

static

Definition at line 76 of file drive_smpp.c.

Referenced by main().

smsc_system_id

Octstr* smsc_system_id

static

Definition at line 75 of file drive_smpp.c.

Referenced by handle_bind_receiver(), handle_bind_transmitter(), and main().

start_time

time_t start_time = (time_t) -1

static

Definition at line 85 of file drive_smpp.c.

Referenced by accept_thread(), and main().

type

unsigned long type

Definition at line 212 of file drive_smpp.c.

Referenced by handle_pdu().