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

    18

    /** No value at all */

    19

    CONFIG_NULL,

    20

    21

    /** A plain NUL-terminated string */

    22

    CONFIG_STRING,

    23

    24

    /** A user-defined type, further identified by a string */

    25

    CONFIG_USER,

    26

    27

    /** An IRC channel */

    28

    CONFIG_IRC_CHAN,

    29

};

    30

    31

/**

    32

 * A CONFIG_USER type info

    33

 */

    34

struct config_user_type {

    35

    /** The name of the type */

    36

    const char *name;

    37

};

    38

    39

/**

    40

 * Structure to hold a value as defined by config_type

    41

 */

    42

struct config_value {

    43

    /** The type of the value */

    44

    enum config_type type;

    45

    46

    /** The typed value */

    47

    union {

    48

        /** Value for CONFIG_STRING */

    49

        char *string;

    50

    51

        /** Value for CONFIG_IRC_CHAN */

    52

        struct irc_chan *irc_chan;

    53

    54

        /** Value for CONFIG_USER */

    55

        struct {

    56

            /** The specific user type */

    57

            const struct config_user_type *type;

    58

    59

            /** The pointer value */

    60

            void *ptr;

    61

        } user;

    62

    };

    63

};

    64

    65

/**

    66

 * Structure to define a single parameter for an option

    67

 */

    68

struct config_param {

    69

    /** The name of the arg */

    70

    const char *name;

    71

    72

    /** The type */

    73

    enum config_type type;

    74

    75

    /** The specific type for CONFIG_USER */

    76

    const struct config_user_type *user_type;

    77

    78

    /** Description */

    79

    const char *description;

    80

    81

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

    82

    union {

    83

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

    84

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

    85

    } func;

    86

    87

    /** Use handler function? */

    88

    bool is_handler;

    89

    90

    /** Optional value? */

    91

    bool optional;

    92

};

    93

    94

/**

    95

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

    96

 */

    97

#define CONFIG_PARAMS_MAX (15 + 1)

    98

    99

/**

   100

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

   101

 */

   102

#define CONFIG_VALUES_MAX CONFIG_PARAMS_MAX

   103

   104

/**

   105

 * A more complicated configuration option that can have multiple parameters

   106

 */

   107

struct config_option {

   108

    /** The name of the config option */

   109

    const char *name;

   110

   111

    /** The list of parameters */

   112

    const struct config_param params[CONFIG_PARAMS_MAX];

   113

   114

    /** The handler function */

   115

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

   116

   117

    /** Help text */

   118

    const char *help;

   119

};

   120

   121

#define CONFIG_PARAM(name, type, desc, optional) \

   122

    {   name, type, NULL, desc, { NULL }, false, optional }

   123

   124

#define CONFIG_PARAM_OPTIONAL(name, type, desc) \

   125

    CONFIG_PARAM(name, type, desc, true)

   126

   127

#define CONFIG_PARAM_USER(name, user_type, desc, optional) \

   128

    {   name, CONFIG_USER, user_type, desc, { NULL }, false, optional }

   129

   130

#define CONFIG_PARAM_USER_OPTIONAL(name, user_type, desc) \

   131

    CONFIG_PARAM_USER(name, user_type, desc, true) 

   132

   133

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

   134

    {   name, type, NULL, desc, {._func_name_ = func }, true, false }

   135

   136

#define CONFIG_PARAM_END \

   137

    {   NULL, 0, NULL, NULL, { NULL }, false, false }

   138

   139

#define CONFIG_OPT(name, func, help, ...) \

   140

    {   name, { __VA_ARGS__, CONFIG_PARAM_END }, func, help }

   141

   142

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

   143

    CONFIG_OPT(name, NULL, help, CONFIG_PARAM_HANDLER(name, CONFIG_STRING, desc, string, func))

   144

   145

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

   146

    CONFIG_OPT(name, NULL, help, CONFIG_PARAM_HANDLER(name, CONFIG_IRC_CHAN, desc, irc_chan, func))

   147

   148

#define CONFIG_OPT_END \

   149

    {   NULL,   {}, NULL, NULL }

   150

   151

#define CONFIG_OPTIONS(...) \

   152

    { __VA_ARGS__, CONFIG_OPT_END }

   153

   154

#define CONFIG_VALUE(type, _name_, value) \

   155

    {   (type), { ._name_ = value } }

   156

   157

#define CONFIG_VALUE_STRING(str_value) \

   158

    CONFIG_VALUE(CONFIG_STRING, string, (str_value))

   159

   160

#define CONFIG_VALUE_IRC_CHAN(irc_chan_value) \

   161

    CONFIG_VALUE(CONFIG_IRC_CHAN, irc_chan, (irc_chan_value))

   162

   163

#define CONFIG_VALUE_USER(user_type, user_value) \

   164

    CONFIG_VALUE(CONFIG_USER, user, { user_type, user_value })

   165

   166

#define CONFIG_VALUE_END \

   167

    {   0, { NULL } }

   168

   169

/**

   170

 * Lookup a config option by name.

   171

 *

   172

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

   173

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

   174

 * @param err returned error info if not found

   175

 * @return a direct pointer to the config_option if found

   176

 */

   177

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

   178

   179

/**

   180

 * Returns the number of params that an option has

   181

 *

   182

 * @param option the option to count

   183

 * @return the number of params

   184

 */

   185

int config_params_count (const struct config_option *option);

   186

   187

// XXX: move this into nexus

   188

#include "nexus.h"

   189

/**

   190

 * Parse a raw value into a suitable configuration value for the given param, based on its type.

   191

 *

   192

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

   193

 *

   194

 * Formats supported:

   195

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

   196

 *

   197

 */

   198

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

   199

   200

/**

   201

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

   202

 *

   203

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

   204

 * @param nexus the application state

   205

 * @param value the returned value, if succesfull

   206

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

   207

 * @param err returned error info

   208

 */

   209

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

   210

   211

/**

   212

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

   213

 *

   214

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

   215

 *

   216

 * @param option the option to apply

   217

 * @param ctx the context pointer for the option handler

   218

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

   219

 * @param err returned error info

   220

 */

   221

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

   222

   223

/**

   224

 * Apply a list of parsed configuration values 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 values the NULL-termianted array of parsed values

   230

 * @param err returned error info

   231

 */

   232

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

   233

   234

/**

   235

 * Apply a string value for the named config opt.

   236

 *

   237

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

   238

 * @param ctx the context pointer for the option handler

   239

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

   240

 * @param value the string value

   241

 * @param err returned error info

   242

 */

   243

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

   244

   245

/**

   246

 * Apply an irc_chan value for the named config opt.

   247

 *

   248

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

   249

 * @param ctx the context pointer for the option handler

   250

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

   251

 * @param value the irc_chan value

   252

 * @param err returned error info

   253

 */

   254

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

   255

   256

/**

   257

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

   258

 *

   259

 * See config_parse() for more info.

   260

 *

   261

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

   262

 * @param nexus the application state

   263

 * @param ctx the context pointer for the option handler

   264

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

   265

 * @param raw_value the raw value to parse

   266

 * @param err returned error info

   267

 *

   268

 * @see config_parse

   269

 */

   270

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

   271

   272

/**

   273

 * Lookup a config_value by name from the given list of config_values for the given config_option

   274

 */

   275

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

   276

   277

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

   278

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

   279

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

   280

   281

#endif