1

#ifndef CONFIG_H

     2

#define CONFIG_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Support for module configuration parameters

     8

 */

     9

#include "error.h"

    10

#include <stdbool.h>

    11

    12

/** 

    13

 * Different types of configuration parameters

    14

 */

    15

enum config_type {

    16

    CONFIG_INVALID,

    17

    21

    /** A plain NUL-terminated string */

    22

    CONFIG_STRING,

    23

    27

    /** An IRC channel */

    28

    CONFIG_IRC_CHAN,

    29

};

    30

    31

/**

    32

 * Structure to hold a value as defined by config_type

    33

 */

    34

struct config_value {

    35

    /** The type of the value */

    36

    enum config_type type;

    37

    38

    /** The typed value */

    39

    union {

    40

        /** Value for CONFIG_STRING */

    41

        char *string;

    42

    43

        /** Value for CONFIG_IRC_CHAN */

    44

        struct irc_chan *irc_chan;

    54

    };

    55

};

    56

    57

/**

    58

 * Structure to define a single parameter for an option

    59

 */

    60

struct config_param {

    61

    /** The name of the arg */

    62

    const char *name;

    63

    64

    /** The type */

    65

    enum config_type type;

    66

    70

    /** Description */

    71

    const char *description;

    72

    73

    /** Optional value handler function, by type */

    74

    union {

    75

        err_t (*string) (void *ctx, char *value, struct error_info *err);

    76

        err_t (*irc_chan) (void *ctx, struct irc_chan *chan, struct error_info *err);

    77

    } func;

    78

    79

    /** Use handler function? */

    80

    bool is_handler;

    84

};

    85

    86

/**

    87

 * The maximum number of parameters that a single option can have, although this includes the terminating NULL

    88

 */

    89

#define CONFIG_PARAMS_MAX (15 + 1)

    90

    91

/**

    92

 * The maximum number of values that an option can access, including the terminating NULL

    93

 */

    94

#define CONFIG_VALUES_MAX CONFIG_PARAMS_MAX

    95

    96

/**

    97

 * A more complicated configuration option that can have multiple parameters

    98

 */

    99

struct config_option {

   100

    /** The name of the config option */

   101

    const char *name;

   102

   103

    /** The list of parameters */

   104

    const struct config_param params[CONFIG_PARAMS_MAX];

   105

   106

    /** The handler function */

   108

   109

    /** Help text */

   110

    const char *help;

   111

};

   112

   124

   125

#define CONFIG_PARAM_HANDLER(name, type, desc, _func_name_, func) \

   127

   133

   134

#define CONFIG_OPT_STRING(name, func, desc, help) \

   136

   137

#define CONFIG_OPT_IRC_CHAN(name, func, desc, help) \

   139

   140

#define CONFIG_OPT_END \

   141

    {   NULL,   {}, NULL, NULL }

   142

   146

#define CONFIG_VALUE(type, _name_, value) \

   148

   149

#define CONFIG_VALUE_STRING(str_value) \

   151

   152

#define CONFIG_VALUE_IRC_CHAN(irc_chan_value) \

   157

   158

#define CONFIG_VALUE_END \

   159

    {   0, { NULL } }

   160

   161

/**

   162

 * Lookup a config option by name.

   163

 *

   164

 * @param options a CONFIG_OPT_END-terminated array of config_option's

   165

 * @param name the config_option::name to look up

   166

 * @param err returned error info if not found

   167

 * @return a direct pointer to the config_option if found

   168

 */

   169

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

   170

   171

// XXX: move this into nexus

   172

#include "nexus.h"

   173

/**

   174

 * Parse a raw value into a suitable configuration value for a single-param option, based on the config option type.

   175

 *

   176

 * Since this needs to access the application state, you need to pass in the nexus as an argument.

   177

 *

   178

 * Formats supported:

   179

 *  CONFIG_IRC_CHAN         - uses a '<network>/<channel>' format and irc_client_get_chan

   180

 *

   181

 * @param option the option to parse the value for, use config_lookup to find it

   182

 * @param nexus the application state

   183

 * @param value the returned value, if succesfull

   184

 * @param raw_value the raw value to parse based on the type

   185

 * @param err returned error info

   186

 */

   187

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

   188

   189

/**

   190

 * Apply a list of parsed configuration values to the given config_option struct.

   191

 *

   192

 * The config option handlers take a context argument; the value of this depends on the implementor of the config_option.

   193

 *

   194

 * @param option the option to apply

   195

 * @param ctx the context pointer for the option handler

   196

 * @param values the NULL-terminated array of parsed values

   197

 * @param err returned error info

   198

 */

   199

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

   200

   201

/**

   202

 * Apply a list of parsed configuration values for the named config opt.

   203

 *

   204

 * @param options a CONFIG_OPT_END-terminated array of config_option's

   205

 * @param ctx the context pointer for the option handler

   206

 * @param name the config_option::name to look up

   207

 * @param values the NULL-termianted array of parsed values

   208

 * @param err returned error info

   209

 */

   210

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

   211

   212

/**

   213

 * Apply a string value for the named config opt.

   214

 *

   215

 * @param options a CONFIG_OPT_END-terminated array of config_option's

   216

 * @param ctx the context pointer for the option handler

   217

 * @param name the config_option::name to look up

   218

 * @param value the string value

   219

 * @param err returned error info

   220

 */

   221

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

   222

   223

/**

   224

 * Apply an irc_chan value for the named config opt.

   225

 *

   226

 * @param options a CONFIG_OPT_END-terminated array of config_option's

   227

 * @param ctx the context pointer for the option handler

   228

 * @param name the config_option::name to look up

   229

 * @param value the irc_chan value

   230

 * @param err returned error info

   231

 */

   232

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

   233

   234

/**

   235

 * Parse and apply a configuration value for the named config opt.

   236

 *

   237

 * See config_parse() for more info.

   238

 *

   239

 * @param options a CONFIG_OPT_END-terminated array of config_option's

   240

 * @param nexus the application state

   241

 * @param ctx the context pointer for the option handler

   242

 * @param name the config_option::name to look up

   243

 * @param raw_value the raw value to parse

   244

 * @param err returned error info

   245

 *

   246

 * @see config_parse

   247

 */

   258

   259

#endif