1

#include "config.h"

     2

     3

#include <string.h>

     4

#include <assert.h>

     5

     6

const struct config_option* config_lookup (const struct config_option *options, const char *name, struct error_info *err)

     7

{

     8

    const struct config_option *option;

     9

    10

    // find the matching config opt

    11

    for (option = options; option->name; option++) {

    12

        if (strcmp(option->name, name) == 0)

    13

            return option;

    14

    }

    15

    16

    // not found

    17

    SET_ERROR_STR(err, ERR_MODULE_CONF, "unknown configuration option");

    18

    19

    return NULL;

    20

}

    21

    22

int config_params_count (const struct config_option *option)

    23

{

    24

    const struct config_param *param;

    25

    int count = 0;

    26

    27

    // handle each param

    28

    for (param = option->params; param->name && param->type; param++)

    29

        count++;

    30

    31

    return count;

    32

}

    33

    34

/**

    35

 * Parse a raw value for a CONFIG_IRC_CHAN into an irc_chan

    36

 */

    37

static struct irc_chan* config_parse_irc_chan (struct nexus *nexus, char *raw_value, struct error_info *err)

    38

{

    39

    const char *network, *channel;

    40

    struct irc_chan *chan;

    41

    42

    // XXX: wrong error code

    43

    44

    // parse required args

    45

    if ((network = strsep(&raw_value, "/")) == NULL)

    46

        JUMP_SET_ERROR_STR(err, ERR_CONFIG_VALUE, "invalid <network> for CONFIG_IRC_CHAN value");

    47

    48

    if ((channel = strsep(&raw_value, "/")) == NULL)

    49

        JUMP_SET_ERROR_STR(err, ERR_CONFIG_VALUE, "invalid <channel> for CONFIG_IRC_CHAN value");

    50

    51

    // extraneous stuff?

    52

    if (raw_value)

    53

        JUMP_SET_ERROR_STR(err, ERR_CONFIG_VALUE, "trailing data for CONFIG_IRC_CHAN value");

    54

    55

    // get the channel?

    56

    if ((chan = irc_client_get_chan(nexus->client, network, channel)) == NULL)

    57

        JUMP_SET_ERROR_STR(err, ERR_CONFIG_VALUE, "unknown network/channel name for CONFIG_IRC_CHAN value");

    58

    59

    // ok

    60

    return chan;

    61

    62

error:

    63

    return NULL;    

    64

}

    65

    66

err_t config_parse_param (const struct config_param *param, struct nexus *nexus, struct config_value *value, char *raw_value, struct error_info *err)

    67

{

    68

    // parse the value 

    69

    switch (param->type) {

    70

        case CONFIG_INVALID:

    71

            RETURN_SET_ERROR_STR(err, ERR_CONFIG_TYPE, "invalid value for invalid type (too many values?)");

    72

    73

        case CONFIG_STRING:

    74

            // simple!

    75

            value->string = raw_value;

    76

            break;

    77

    78

        case CONFIG_IRC_CHAN:

    79

            // parse the value

    80

            if (!(value->irc_chan = config_parse_irc_chan(nexus, raw_value, err)))

    81

                return ERROR_CODE(err);

    82

    83

            break;

    84

    85

        case CONFIG_USER:

    86

            // fail

    87

            RETURN_SET_ERROR_STR(err, ERR_CONFIG_TYPE, "user type can't be parsed");

    88

    89

        default:

    90

            NOT_REACHED();

    91

    }

    92

    93

    // copy the type

    94

    value->type = param->type;

    95

    96

    // ok

    97

    return SUCCESS; 

    98

}

    99

   100

err_t config_parse (const struct config_option *option, struct nexus *nexus, struct config_value *value, char *raw_value, struct error_info *err)

   101

{

   102

    // use the first param

   103

    const struct config_param *param = &option->params[0];

   104

   105

    // must have exactly one param

   106

    if (!param->type || (param + 1)->type)

   107

        return SET_ERROR(err, ERR_CONFIG_PARAMS);

   108

   109

    // parse it

   110

    return config_parse_param(param, nexus, value, raw_value, err);

   111

}

   112

   113

err_t config_apply_opt (const struct config_option *option, void *ctx, const struct config_value values[], struct error_info *err)

   114

{

   115

    const struct config_param *param;

   116

    const struct config_value *value;

   117

   118

    // handle each param

   119

    for (param = option->params, value = values; param->name && param->type; param++) {

   120

        // no value given, or value given as NULL?

   121

        if (!value->type || value->type == CONFIG_NULL) {

   122

            if (param->optional) {

   123

                // optional, so just ignore the value 

   124

   125

            } else {

   126

                // required

   127

                JUMP_SET_ERROR_STR(err, ERR_CONFIG_REQUIRED, param->name);

   128

   129

            }

   130

   131

        } else if (param->type != value->type) {

   132

            // invalid type, XXX: also report correct type name?

   133

            JUMP_SET_ERROR(err, ERR_CONFIG_TYPE);

   134

   135

        } else if (param->is_handler) {

   136

            // only applicable for non-optional args

   137

            err_t tmp;

   138

   139

            // invoke the handler

   140

            switch (param->type) {

   141

                case CONFIG_STRING:     tmp = param->func.string(ctx, value->string, err); break;

   142

                case CONFIG_IRC_CHAN:   tmp = param->func.irc_chan(ctx, value->irc_chan, err); break;

   143

                default:                NOT_REACHED();

   144

            }

   145

   146

            // abort on errors

   147

            if (tmp)

   148

                goto error;

   149

        }

   150

   151

        // the values list is NULL-terminated, and optional params can be left off

   152

        if (value->type)

   153

            value++;

   154

    }

   155

   156

    // the option's handler?

   157

    if (option->func && option->func(ctx, option, values, err))

   158

        goto error;

   159

   160

    // ok

   161

    return SUCCESS;

   162

   163

error:

   164

    return ERROR_CODE(err);

   165

}

   166

   167

err_t config_apply (const struct config_option *options, void *ctx, const char *name, const struct config_value values[], struct error_info *err)

   168

{

   169

    const struct config_option *option;

   170

   171

    // no matching option found?

   172

    if (!(option = config_lookup(options, name, err)))

   173

        return ERROR_CODE(err);

   174

   175

    // apply it    

   176

    return config_apply_opt(option, ctx, values, err);

   177

}

   178

   179

err_t config_apply_string (const struct config_option *options, void *ctx, const char *name, char *value, struct error_info *err)

   180

{

   181

    struct config_value conf_value[] = {

   182

        CONFIG_VALUE_STRING(value),

   183

        CONFIG_VALUE_END,

   184

    };

   185

   186

    return config_apply(options, ctx, name, conf_value, err);

   187

}

   188

   189

err_t config_apply_irc_chan (const struct config_option *options, void *ctx, const char *name, struct irc_chan *value, struct error_info *err)

   190

{

   191

    struct config_value conf_value[] = {

   192

        CONFIG_VALUE_IRC_CHAN(value),

   193

        CONFIG_VALUE_END,

   194

    };

   195

   196

    return config_apply(options, ctx, name, conf_value, err);

   197

}

   198

   199

err_t config_apply_raw (const struct config_option options[], struct nexus *nexus, void *ctx, const char *name, char *raw_value, struct error_info *err)

   200

{

   201

    const struct config_option *option;

   202

    struct config_value value[2] = {

   203

        CONFIG_VALUE_END,

   204

        CONFIG_VALUE_END,

   205

    };

   206

   207

    // no matching option found?

   208

    if (!(option = config_lookup(options, name, err)))

   209

        return ERROR_CODE(err);

   210

   211

    // parse it

   212

    if (config_parse(option, nexus, &value[0], raw_value, err))

   213

        return ERROR_CODE(err);

   214

   215

    // apply it

   216

    return config_apply_opt(option, ctx, value, err);

   217

}

   218

   219

const struct config_value* config_get_value (const struct config_option *option, const struct config_value values[], const char *name)

   220

{

   221

    const struct config_param *param;

   222

    const struct config_value *value;

   223

   224

    // go through the (param, value) pairs

   225

    for (param = option->params, value = values; param->name && param->type && value->type; param++, value++) {

   226

        if (strcmp(param->name, name) == 0) {

   227

            // not NULL?

   228

            if (value->type != CONFIG_NULL)

   229

                return value;

   230

   231

            else

   232

                return NULL;

   233

        }

   234

    }

   235

   236

    // not found

   237

    return NULL;

   238

}

   239

   240

const char* config_get_string (const struct config_option *option, const struct config_value values[], const char *name)

   241

{

   242

    const struct config_value *value;

   243

   244

    return (value = config_get_value(option, values, name)) ? value->string : NULL;

   245

}

   246

   247

struct irc_chan* config_get_irc_chan (const struct config_option *option, const struct config_value values[], const char *name)

   248

{

   249

    const struct config_value *value;

   250

   251

    return (value = config_get_value(option, values, name)) ? value->irc_chan : NULL;

   252

}

   253

   254

void* config_get_user (const struct config_option *option, const struct config_value values[], const char *name, const struct config_user_type *user_type)

   255

{

   256

    const struct config_value *value;

   257

   258

    return ((value = config_get_value(option, values, name)) && value->user.type == user_type) ? value->user.ptr : NULL;

   259

}

   260