1

#include "lua_objs.h"

     2

#include "lua_irc.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

     8

/**

     9

 * Wrapper for module

    10

 */

    11

struct lua_module {

    12

    struct module *module;

    13

};

    14

    15

/**

    16

 * Create a lua_module userdata from the given module and push it onto the stack, returning 1.

    17

 *

    18

 * The given module should be a reference of its own right.

    19

 */

    20

static int lua_module_create (lua_State *L, struct module *module)

    21

{

    22

    // create the new obj

    23

    struct lua_module *lua_module = lua_obj_create_obj(L, "spbot.module", sizeof(*lua_module));

    24

    25

    // initialize

    26

    lua_module->module = module;

    27

    28

    // ok

    29

    return 1;

    30

}

    31

    32

/**

    33

 * module_put() our module reference

    34

 */

    35

static int lua_module__gc (lua_State *L)

    36

{

    37

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

    38

    39

    // put it

    40

    module_put(lua_module->module);

    41

    42

    return 0;

    43

}

    44

    45

static int lua_module_conf (lua_State *L)

    46

{

    47

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

    48

    const struct config_option *option;

    49

    struct error_info err;

    50

    bool is_err = true;

    51

    52

    // the list of given config values, and temporary storage for string values

    53

    struct config_value values[CONFIG_VALUES_MAX], *value = values;

    54

    char *value_bufs[CONFIG_VALUES_MAX], **value_buf = value_bufs;

    55

    56

    // number of arguments given

    57

    int nargs = lua_gettop(L), argidx = 2;

    58

    59

    // init to zero

    60

    memset(values, 0, sizeof(values));

    61

    memset(value_bufs, 0, sizeof(value_bufs));

    62

    63

    // XXX: come up with some better way...

    64

    struct nexus *nexus = lua_module->module->modules->nexus;

    65

    66

    // the config name

    67

    const char *conf_name = luaL_checkstring(L, argidx++);

    68

    69

    // look it up

    70

    if ((option = module_conf_lookup(lua_module->module, conf_name, &err)) == NULL)

    71

        return luaL_error(L, "module_conf_lookup: %s/%s: %s", module_name(lua_module->module), conf_name, error_msg(&err));

    72

    73

    // maximum number of arguments accepted

    74

    int maxargs = config_params_count(option);

    75

    76

    // too many arguments?

    77

    if (nargs - argidx > maxargs)

    78

        return luaL_error(L, "lua_module_conf: too many arguments (>%d) given (%d)", maxargs, nargs - argidx);

    79

    80

    // the current param

    81

    const struct config_param *param = option->params;

    82

    83

    // apply each given argument to the correct param, storing it in value

    84

    for (; argidx <= nargs; argidx++, value++, param++) {

    85

        // the given config value

    86

        switch (lua_type(L, argidx)) {

    87

            case LUA_TNONE:

    88

            case LUA_TNIL:

    89

                // no value

    90

                value->type = CONFIG_NULL;

    91

    92

                break;

    93

    94

            case LUA_TSTRING: {

    95

                // string arg

    96

                const char *arg_str = lua_tostring(L, argidx);

    97

    98

                // copy it as a mutable string buffer

    99

                if ((*value_buf = strdup(arg_str)) == NULL) {

   100

                    lua_pushfstring(L, "strdup");

   101

                    goto error;

   102

                }

   103

   104

                // parse it as a raw value

   105

                if (config_parse_param(param, nexus, value, *value_buf, &err)) {

   106

                    lua_pushfstring(L, "config_parse: %s/%s: %s", option->name, *value_buf, error_msg(&err));

   107

                    goto error;

   108

                }

   109

   110

                // seek to next value_buf

   111

                value_buf++;

   112

   113

            } break;

   114

   115

            case LUA_TUSERDATA:

   116

                // some kind of userdata, use its metatable to figure out what type it is

   117

                if (!lua_getmetatable(L, argidx)) {

   118

                    lua_pushfstring(L, "config value is userdata without metatable");

   119

                    goto error;

   120

                }

   121

   122

                // get the target metatable

   123

                lua_getfield(L, LUA_REGISTRYINDEX, "evirc.chan");

   124

   125

                // is it a chan?

   126

                if (!lua_rawequal(L, -1, -2)) {

   127

                    lua_pushfstring(L, "config value is userdata of unknown type");

   128

                    goto error;

   129

                }

   130

   131

                // pop the metatables

   132

                lua_pop(L, 2);

   133

   134

                // get the irc_chan

   135

                struct lua_chan *lua_chan = lua_touserdata(L, argidx);

   136

   137

                // build the value

   138

                value->type = CONFIG_IRC_CHAN;

   139

                value->irc_chan = lua_chan->chan;

   140

   141

                break;

   142

   143

            default:

   144

                lua_pushfstring(L, "config value is of unknown lua type '%s'", lua_typename(L, argidx));

   145

                goto error;

   146

   147

        }

   148

    }

   149

   150

    // apply it

   151

    if (module_conf(lua_module->module, option, values, &err)) {

   152

        lua_pushfstring(L, "module_conf: %s/%s: %s", module_name(lua_module->module), option->name, error_msg(&err));

   153

        goto error;

   154

    }

   155

   156

    // ok

   157

    is_err = false;

   158

   159

error:

   160

    // release any allocated strings

   161

    for (value_buf = value_bufs; value_buf <= value_bufs + CONFIG_VALUES_MAX && *value_buf; value_buf++)

   162

        free(*value_buf);

   163

   164

    // either error or successful return

   165

    if (is_err)

   166

        return lua_error(L);

   167

    else

   168

        return 0;

   169

}

   170

   171

static int lua_module_unload (lua_State *L)

   172

{

   173

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

   174

    struct error_info err;

   175

   176

    // just unload it

   177

    if ((ERROR_CODE(&err) = module_unload(lua_module->module)))

   178

        return luaL_error(L, "module_unload: %s: %s", module_name(lua_module->module), error_msg(&err));

   179

   180

    // ok

   181

    return 0;

   182

}

   183

   184

static const struct luaL_Reg lua_module_methods[] = {

   185

    {   "__gc",         &lua_module__gc             },

   186

    {   "conf",         &lua_module_conf            },

   187

    {   "unload",       &lua_module_unload          },

   188

    {   NULL,           NULL                        }

   189

};

   190

   191

/**

   192

 * Initialize the lua_module object type

   193

 */

   194

static void lua_module_init (lua_State *L)

   195

{

   196

    lua_obj_create_type(L, "spbot.module", lua_module_methods);

   197

}

   198

   199

/**

   200

 * Wrapper for modules

   201

 */

   202

struct lua_modules {

   203

    struct modules *modules;

   204

   205

    // strdup'd path for module_path

   206

    // XXX: remove when gc'd

   207

    char *path;

   208

};

   209

   210

static int lua_modules__gc (lua_State *L)

   211

{

   212

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   213

   214

    // remove the modules path if it was set by us

   215

    if (lua_modules->path && modules_path(lua_modules->modules, NULL) == lua_modules->path)

   216

        modules_path(lua_modules->modules, "");

   217

   218

    // release any strdup'd path

   219

    free(lua_modules->path);

   220

   221

    // ok

   222

    return 0;

   223

}

   224

   225

static int lua_modules_path (lua_State *L)

   226

{

   227

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   228

    char *path = NULL;

   229

    const char *old_path;

   230

   231

    if (!lua_isnoneornil(L, 2)) {

   232

        // the new path

   233

        if ((path = strdup(luaL_checkstring(L, 2))) == NULL)

   234

            return luaL_error(L, "strdup");

   235

    }

   236

   237

    // set or get

   238

    old_path = modules_path(lua_modules->modules, path);

   239

   240

    // return the old path

   241

    if (old_path)

   242

        lua_pushstring(L, old_path);

   243

    else

   244

        lua_pushnil(L);

   245

   246

    if (path) {

   247

        // replace the old path

   248

        free(lua_modules->path); 

   249

        lua_modules->path = path;

   250

    }

   251

   252

    // ok

   253

    return 1;

   254

}

   255

   256

static int lua_modules_load (lua_State *L)

   257

{

   258

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   259

    struct module *module;

   260

    struct module_info info;

   261

    struct error_info err;

   262

   263

    // the module name/path

   264

    info.name = luaL_checkstring(L, 2);

   265

    info.path = lua_isnoneornil(L, 3) ? NULL : luaL_checkstring(L, 3);

   266

   267

    // load and get a new reference

   268

    if (module_load(lua_modules->modules, &module, &info, &err))

   269

        return luaL_error(L, "module_load: %s/%s: %s", info.name, info.path, error_msg(&err));

   270

   271

    // wrap

   272

    return lua_module_create(L, module);

   273

}

   274

   275

static int lua_modules_module (lua_State *L)

   276

{

   277

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   278

    struct module *module;

   279

   280

    // the module name

   281

    const char *name = luaL_checkstring(L, 2);

   282

   283

    // look it up, as a new reference

   284

    if ((module = modules_get(lua_modules->modules, name)) == NULL)

   285

        return luaL_error(L, "module_get: %s: no such module", name);

   286

   287

    // wrap

   288

    return lua_module_create(L, module);

   289

}

   290

   291

static const struct luaL_Reg lua_modules_methods[] = {

   292

    {   "__gc",         &lua_modules__gc            },

   293

    {   "path",         &lua_modules_path           },

   294

    {   "load",         &lua_modules_load           },

   295

    {   "module",       &lua_modules_module         },

   296

    {   NULL,           NULL                        }

   297

};

   298

   299

/**

   300

 * Initialize the spbot.modules type for lua_modules, and registers an instance bound to the given modules list at

   301

 * 'modules'.

   302

 */

   303

static void lua_modules_init (lua_State *L, struct modules *modules)

   304

{

   305

    // allocate the global "modules" object

   306

    struct lua_modules *lua_modules = lua_obj_create_global_type(L, "spbot.modules", lua_modules_methods, "modules", sizeof(*lua_modules));

   307

   308

    // initialize it

   309

    lua_modules->modules = modules;

   310

}

   311

   312

/**

   313

 * Wrapper for nexus

   314

 */

   315

struct lua_nexus {

   316

    struct nexus *nexus;

   317

};

   318

   319

static int lua_nexus_shutdown (lua_State *L)

   320

{

   321

    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");

   322

   323

    // just shut it down

   324

    nexus_shutdown(lua_nexus->nexus);

   325

   326

    return 0;

   327

}

   328

   329

static int lua_nexus_load_config (lua_State *L)

   330

{

   331

    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");

   332

    struct error_info err;

   333

   334

    const char *path = luaL_checkstring(L, 2);

   335

   336

    // just load it

   337

    if (nexus_load_config(lua_nexus->nexus, path, &err))

   338

        return luaL_error(L, "nexus_load_config(%s): %s", path, error_msg(&err));

   339

   340

    return 0;

   341

}

   342

   343

static const struct luaL_Reg lua_nexus_methods[] = {

   344

    {   "shutdown",     &lua_nexus_shutdown         },

   345

    {   "load_config",  &lua_nexus_load_config      },

   346

    {   NULL,           NULL                        }

   347

};

   348

   349

/**

   350

 * Initialize the spbot.nexus type for lua_nexus, and registers an instance bound to the given nexus list at

   351

 * 'nexus'.

   352

 */

   353

static void lua_nexus_init (lua_State *L, struct nexus *nexus)

   354

{

   355

    // allocate the global "nexus" object

   356

    struct lua_nexus *lua_nexus = lua_obj_create_global_type(L, "spbot.nexus", lua_nexus_methods, "nexus", sizeof(*lua_nexus));

   357

   358

    // initialize it

   359

    lua_nexus->nexus = nexus;

   360

}

   361

   362

/**

   363

 * Global functions

   364

 */

   365

static int lua_log_level (lua_State *L)

   366

{

   367

    // log level as a string

   368

    enum log_level new_level = luaL_checkoption(L, 1, NULL, log_level_names);

   369

   370

    // set it

   371

    set_log_level(new_level);

   372

   373

    // ok

   374

    return 0;

   375

}

   376

   377

static int lua_log (lua_State *L)

   378

{

   379

    // log level as a string

   380

    enum log_level level = luaL_checkoption(L, 1, NULL, log_level_names);

   381

   382

    // log message

   383

    const char *msg = luaL_checkstring(L, 2);

   384

   385

    // log it

   386

    log_msg(level, "lua", "%s", msg);

   387

   388

    // ok

   389

    return 0;

   390

}

   391

   392

static const struct luaL_Reg lua_global_functions[] = {

   393

    {   "log_level",    &lua_log_level              },

   394

    {   "log",          &lua_log                    },

   395

    {   NULL,           NULL                        }

   396

};

   397

   398

static void lua_global_init (lua_State *L)

   399

{

   400

    const struct luaL_Reg *reg;

   401

   402

    for (reg = lua_global_functions; reg->name && reg->func; reg++) {

   403

        // put the function on the stack

   404

        lua_pushcfunction(L, reg->func);

   405

   406

        // set the global

   407

        lua_setglobal(L, reg->name);

   408

    }

   409

}

   410

   411

void lua_objs_init (struct nexus_lua *lua)

   412

{

   413

    // init the various bits

   414

    lua_global_init(lua->st);

   415

    lua_nexus_init(lua->st, lua->nexus);

   416

    lua_modules_init(lua->st, lua->nexus->modules);

   417

    lua_module_init(lua->st);

   418

}

   419