1

#include "irc_client.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <string.h>

     6

     7

err_t irc_client_create (struct irc_client **client_ptr, error_t *err)

     8

{

     9

    struct irc_client *client;

    10

    11

    // allocate

    12

    if ((client = calloc(1, sizeof(*client))) == NULL)

    13

        return SET_ERROR(err, ERR_CALLOC);

    14

    15

    // init

    16

    TAILQ_INIT(&client->networks);

    17

    18

    // ok

    19

    *client_ptr = client;

    20

    21

    return SUCCESS;

    22

}

    23

    24

void irc_client_destroy (struct irc_client *client)

    25

{

    26

    struct irc_net *next = TAILQ_FIRST(&client->networks), *net;

    27

    28

    // our networks

    29

    while (next) {

    30

        net = next;

    31

        next = TAILQ_NEXT(net, client_networks);

    32

    33

        irc_net_destroy(net);

    34

    }

    35

    36

    // ourselves

    37

    free(client);

    38

}

    39

    40

void irc_client_set_defaults (struct irc_client *client, const struct irc_client_defaults *defaults)

    41

{

    42

    client->defaults = *defaults;

    43

}

    44

    45

#define APPLY_REGISTER_INFO_DEFAULT(out, value, def, _field_) ( \

    46

        ((out)->register_info._field_ = (    \

    47

            (value)->register_info._field_ ? (value)->register_info._field_ : (  \

    48

                (def)->register_info._field_ \

    49

            )   \

    50

        )) == NULL   \

    51

    )

    52

    53

err_t irc_client_add_net (struct irc_client *client, struct irc_net **net_ptr, const struct irc_net_info *_net_info, error_t *err)

    54

{

    55

    struct irc_net *net;

    56

    struct irc_net_info net_info = {

    57

        .ssl_cred   = _net_info->ssl_cred,

    58

    };

    59

    60

    // combine _net_info and defaults to get net_info

    61

    if (_net_info->transport)

    62

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "transport");

    63

    64

    if ((net_info.network = _net_info->network) == NULL)

    65

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "network");

    66

    67

    if ((net_info.hostname = _net_info->hostname) == NULL)

    68

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "hostname");

    69

    70

    if ((net_info.service = (_net_info->service ? _net_info->service : (

    71

                    _net_info->ssl_cred ? client->defaults.service_ssl : client->defaults.service

    72

            ))) == NULL)

    73

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "service");

    74

    75

    if (APPLY_REGISTER_INFO_DEFAULT(&net_info, _net_info, &client->defaults, nickname))

    76

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "nickname");

    77

    78

    if (APPLY_REGISTER_INFO_DEFAULT(&net_info, _net_info, &client->defaults, username))

    79

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "username");

    80

    81

    if (APPLY_REGISTER_INFO_DEFAULT(&net_info, _net_info, &client->defaults, realname))

    82

        RETURN_SET_ERROR_STR(err, ERR_IRC_NET_INFO, "realname");

    83

    84

    // create the new irc_chan struct

    85

    if (irc_net_create(&net, &net_info, err))

    86

        return ERROR_CODE(err);

    87

    88

    // add to network list

    89

    TAILQ_INSERT_TAIL(&client->networks, net, client_networks);

    90

    91

    // ok

    92

    if (net_ptr)

    93

        *net_ptr = net;

    94

    95

    return SET_ERROR(err, SUCCESS);

    96

}

    97

    98

struct irc_net* irc_client_get_net (struct irc_client *client, const char *network)

    99

{

   100

    struct irc_net *net = NULL;

   101

   102

    // look for it...

   103

    TAILQ_FOREACH(net, &client->networks, client_networks) {

   104

        if (strcasecmp(net->info.network, network) == 0)

   105

            // found it

   106

            return net;

   107

    }

   108

   109

    // no such network

   110

    return NULL;

   111

}

   112

   113

struct irc_chan* irc_client_get_chan (struct irc_client *client, const char *network, const char *channel)

   114

{

   115

    struct irc_net *net;

   116

   117

    // lookup network

   118

    if ((net = irc_client_get_net(client, network)) == NULL)

   119

        return NULL;

   120

   121

    // and then return channel lookup

   122

    return irc_net_get_chan(net, channel);

   123

}

   124

   125

err_t irc_client_quit (struct irc_client *client, const char *message)

   126

{

   127

    struct irc_net *net;

   128

    err_t err;

   129

   130

    // quit each network

   131

    TAILQ_FOREACH(net, &client->networks, client_networks) {

   132

        if ((err = irc_net_quit(net, message))) {

   133

            log_err(err, "irc_net_quit: %s [%s]", net->info.network, message);

   134

   135

            // XXX: destroy it?

   136

        }

   137

    }

   138

   139

    // state

   140

    client->quitting = true;

   141

   142

    // ok

   143

    return SUCCESS;

   144

}