1

#ifndef CONFIG_H

     2

#define CONFIG_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Support for module configuration parameters

     8

 */

    10

#include <stdbool.h>

    11

    23

/** 

    24

 * Different types of configuration parameters

    25

 */

    26

enum config_type {

    27

    CONFIG_INVALID,

    28

    29

    /** No value at all */

    30

    CONFIG_NULL,

    31

    32

    /** A plain NUL-terminated string */

    33

    CONFIG_STRING,

    34

    35

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

    36

    CONFIG_USER,

    37

    38

    /** An IRC channel */

    39

    CONFIG_IRC_CHAN,

    40

};

    41

    42

/**

    43

 * A CONFIG_USER type info

    44

 */

    45

struct config_user_type {

    46

    /** The name of the type */

    47

    const char *name;

    48

};

    49

    50

/**

    51

 * Structure to hold a value as defined by config_type

    52

 */

    53

struct config_value {

    54

    /** The type of the value */

    55

    enum config_type type;

    56

    57

    /** The typed value */

    58

    union {

    59

        /** Value for CONFIG_STRING */

    60

        char *string;

    61

    62

        /** Value for CONFIG_IRC_CHAN */

    63

        struct irc_chan *irc_chan;

    64

    65

        /** Value for CONFIG_USER */

    66

        struct {

    67

            /** The specific user type */

    68

            const struct config_user_type *type;

    69

    70

            /** The pointer value */

    71

            void *ptr;

    72

        } user;

    73

    };

    74

};

    75

    76

/**

    77

 * Structure to define a single parameter for an option

    78

 */

    79

struct config_param {

    80

    /** The name of the arg */

    81

    const char *name;

    82

    83

    /** The type */

    84

    enum config_type type;

    85

    86

    /** The specific type for CONFIG_USER */

    87

    const struct config_user_type *user_type;

    88

    89

    /** Description */

    90

    const char *description;

    91

    92

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

    93

    union {

    96

    } func;

    97

    98

    /** Use handler function? */

    99

    bool is_handler;

   100

   101

    /** Optional value? */

   102

    bool optional;

   103

};

   104

   105

/**

   106

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

   107

 */

   108

#define CONFIG_PARAMS_MAX (15 + 1)

   109

   110

/**

   111

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

   112

 */

   113

#define CONFIG_VALUES_MAX CONFIG_PARAMS_MAX

   114

   115

/**

   116

 * A more complicated configuration option that can have multiple parameters

   117

 */

   118

struct config_option {

   119

    /** The name of the config option */

   120

    const char *name;

   121

   122

    /** The list of parameters */

   123

    const struct config_param params[CONFIG_PARAMS_MAX];

   124

   125

    /** The handler function */

   127

   128

    /** Help text */

   129

    const char *help;

   130

};

   131

   132

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

   133

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

   134

   135

#define CONFIG_PARAM_OPTIONAL(name, type, desc) \

   136

    CONFIG_PARAM(name, type, desc, true)

   137

   138

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

   139

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

   140

   141

#define CONFIG_PARAM_USER_OPTIONAL(name, user_type, desc) \

   142

    CONFIG_PARAM_USER(name, user_type, desc, true) 

   143

   144

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

   145

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

   146

   147

#define CONFIG_PARAM_END \

   148

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

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

   156

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

   157

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

   158

   159

#define CONFIG_OPT_END \

   160

    {   NULL,   {}, NULL, NULL }

   161

   162

#define CONFIG_OPTIONS(...) \

   163

    { __VA_ARGS__, CONFIG_OPT_END }

   164

   165

#define CONFIG_VALUE(type, _name_, value) \

   166

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

   167

   168

#define CONFIG_VALUE_STRING(str_value) \

   169

    CONFIG_VALUE(CONFIG_STRING, string, (str_value))

   170

   171

#define CONFIG_VALUE_IRC_CHAN(irc_chan_value) \

   172

    CONFIG_VALUE(CONFIG_IRC_CHAN, irc_chan, (irc_chan_value))

   173

   174

#define CONFIG_VALUE_USER(user_type, user_value) \

   175

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

   176

   177

#define CONFIG_VALUE_END \

   178

    {   0, { NULL } }

   179

   180

/**

   181

 * Lookup a config option by name.

   182

 *

   183

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

   184

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

   185

 * @param err returned error info if not found

   186

 * @return a direct pointer to the config_option if found

   187

 */

   189

   190

/**

   191

 * Returns the number of params that an option has

   192

 *

   193

 * @param option the option to count

   194

 * @return the number of params

   195

 */

   196

int config_params_count (const struct config_option *option);

   197

   198

// XXX: move this into nexus

   199

#include "nexus.h"

   200

/**

   201

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

   202

 *

   203

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

   204

 *

   205

 * Formats supported:

   206

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

   207

 *

   208

 */

   210

   211

/**

   212

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

   213

 *

   214

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

   215

 * @param nexus the application state

   216

 * @param value the returned value, if succesfull

   217

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

   218

 * @param err returned error info

   219

 */

   221

   222

/**

   223

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

   224

 *

   225

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

   226

 *

   227

 * @param option the option to apply

   228

 * @param ctx the context pointer for the option handler

   229

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

   230

 * @param err returned error info

   231

 */

   233

   234

/**

   235

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

   241

 * @param err returned error info

   242

 */

   244

   245

/**

   246

 * Apply a string 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 string value

   252

 * @param err returned error info

   253

 */

   255

   256

/**

   257

 * Apply an irc_chan value for the named config opt.

   258

 *

   259

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

   260

 * @param ctx the context pointer for the option handler

   261

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

   262

 * @param value the irc_chan value

   263

 * @param err returned error info

   264

 */

   266

   267

/**

   268

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

   269

 *

   270

 * See config_parse() for more info.

   271

 *

   272

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

   273

 * @param nexus the application state

   274

 * @param ctx the context pointer for the option handler

   275

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

   276

 * @param raw_value the raw value to parse

   277

 * @param err returned error info

   278

 *

   279

 * @see config_parse

   280

 */

   282

   283

/**

   284

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

   285

 */

   286

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

   287

   288

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

   289

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

   290

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

   291

   292

#endif