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

    17

/**

    18

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

    19

 *

    20

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

    21

 */

    22

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

    23

{

    24

    // create the new obj

    26

    27

    // initialize

    28

    lua_module->module = module;

    29

    30

    // ok

    31

    return 1;

    32

}

    33

    34

/**

    35

 * module_put() our module reference

    36

 */

    37

static int lua_module__gc (lua_State *L)

    38

{

    40

    41

    // put it

    42

    module_put(lua_module->module);

    43

    44

    return 0;

    45

}

    46

    47

static int lua_module_conf (lua_State *L)

    48

{

    50

    const struct config_option *option;

    51

    struct error_info err;

    52

    bool is_err = true;

    53

    54

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

    55

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

    56

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

    57

    58

    // number of arguments given

    59

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

    60

    61

    // init to zero

    62

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

    63

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

    64

    65

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

    66

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

    67

    68

    // the config name

    69

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

    70

    71

    // look it up

    72

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

    73

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

    74

    75

    // maximum number of arguments accepted

    76

    int maxargs = config_params_count(option);

    77

    78

    // too many arguments?

    79

    if (nargs - argidx > maxargs)

    80

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

    81

    82

    // the current param

    83

    const struct config_param *param = option->params;

    84

    85

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

    86

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

    87

        // the given config value

    88

        switch (lua_type(L, argidx)) {

    89

            case LUA_TNONE:

    90

            case LUA_TNIL:

    91

                // no value

    92

                value->type = CONFIG_NULL;

    93

    94

                break;

    95

    96

            case LUA_TSTRING: {

    97

                // string arg

    98

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

    99

   100

                // copy it as a mutable string buffer

   101

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

   102

                    lua_pushfstring(L, "strdup");

   103

                    goto error;

   104

                }

   105

   106

                // parse it as a raw value

   107

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

   108

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

   109

                    goto error;

   110

                }

   111

   112

                // seek to next value_buf

   113

                value_buf++;

   114

   115

            } break;

   116

   117

            case LUA_TUSERDATA:

   118

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

   119

                if (!lua_getmetatable(L, argidx)) {

   120

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

   121

                    goto error;

   122

                }

   123

   124

                // get the target metatable

   125

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

   126

   127

                // is it a chan?

   128

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

   129

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

   130

                    goto error;

   131

                }

   132

   133

                // pop the metatables

   134

                lua_pop(L, 2);

   135

   136

                // get the irc_chan

   137

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

   138

   139

                // build the value

   140

                value->type = CONFIG_IRC_CHAN;

   141

                value->irc_chan = lua_chan->chan;

   142

   143

                break;

   144

   145

            default:

   146

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

   147

                goto error;

   148

   149

        }

   150

    }

   151

   152

    // apply it

   153

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

   154

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

   155

        goto error;

   156

    }

   157

   158

    // ok

   159

    is_err = false;

   160

   161

error:

   162

    // release any allocated strings

   163

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

   164

        free(*value_buf);

   165

   166

    // either error or successful return

   167

    if (is_err)

   168

        return lua_error(L);

   169

    else

   170

        return 0;

   171

}

   172

   173

static int lua_module_unload (lua_State *L)

   174

{

   176

    struct error_info err;

   177

   178

    // just unload it

   179

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

   180

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

   181

   182

    // ok

   183

    return 0;

   184

}

   185

   191

   192

/**

   193

 * Wrapper for modules

   194

 */

   195

struct lua_modules {

   196

    struct modules *modules;

   197

   198

    // strdup'd path for module_path

   199

    // XXX: remove when gc'd

   200

    char *path;

   201

};

   202

   205

static int lua_modules__gc (lua_State *L)

   206

{

   208

   209

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

   210

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

   211

        modules_path(lua_modules->modules, "");

   212

   213

    // release any strdup'd path

   214

    free(lua_modules->path);

   215

   216

    // ok

   217

    return 0;

   218

}

   219

   220

static int lua_modules_path (lua_State *L)

   221

{

   223

    char *path = NULL;

   224

    const char *old_path;

   225

   226

    if (!lua_isnoneornil(L, 2)) {

   227

        // the new path

   228

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

   229

            return luaL_error(L, "strdup");

   230

    }

   231

   232

    // set or get

   233

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

   234

   235

    // return the old path

   236

    if (old_path)

   237

        lua_pushstring(L, old_path);

   238

    else

   239

        lua_pushnil(L);

   240

   241

    if (path) {

   242

        // replace the old path

   243

        free(lua_modules->path); 

   244

        lua_modules->path = path;

   245

    }

   246

   247

    // ok

   248

    return 1;

   249

}

   250

   251

static int lua_modules_load (lua_State *L)

   252

{

   254

    struct module *module;

   255

    struct module_info info;

   256

    struct error_info err;

   257

   258

    // the module name/path

   259

    info.name = luaL_checkstring(L, 2);

   260

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

   261

   262

    // load and get a new reference

   263

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

   264

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

   265

   266

    // wrap

   267

    return lua_module_create(L, module);

   268

}

   269

   270

static int lua_modules_module (lua_State *L)

   271

{

   273

    struct module *module;

   274

   275

    // the module name

   276

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

   277

   278

    // look it up, as a new reference

   279

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

   280

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

   281

   282

    // wrap

   283

    return lua_module_create(L, module);

   284

}

   285

   294

   295

/**

   296

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

   297

 * 'modules'.

   298

 */

   299

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

   300

{

   301

    // allocate the global "modules" object

   303

   304

    // initialize it

   305

    lua_modules->modules = modules;

   306

}

   307

   308

/**

   309

 * Wrapper for nexus

   310

 */

   311

struct lua_nexus {

   312

    struct nexus *nexus;

   313

};

   314

   317

static int lua_nexus_shutdown (lua_State *L)

   318

{

   320

   321

    // just shut it down

   322

    nexus_shutdown(lua_nexus->nexus);

   323

   324

    return 0;

   325

}

   326

   327

static int lua_nexus_load_config (lua_State *L)

   328

{

   330

    struct error_info err;

   331

   332

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

   333

   334

    // just load it

   335

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

   336

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

   337

   338

    return 0;

   339

}

   340

   346

   347

/**

   348

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

   349

 * 'nexus'.

   350

 */

   351

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

   352

{

   353

    // allocate the global "nexus" object

   355

   356

    // initialize it

   357

    lua_nexus->nexus = nexus;

   358

}

   359

   361

/**

   362

 * Global functions

   363

 */

   364

static int lua_log_level (lua_State *L)

   365

{

   366

    // log level as a string

   367

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

   368

   369

    // set it

   370

    set_log_level(new_level);

   371

   372

    // ok

   373

    return 0;

   374

}

   375

   376

static int lua_log (lua_State *L)

   377

{

   378

    // log level as a string

   379

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

   380

   381

    // log message

   382

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

   383

   384

    // log it

   385

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

   386

   387

    // ok

   388

    return 0;

   389

}

   390

   391

static const struct luaL_Reg lua_global_functions[] = {

   392

    {   "log_level",    &lua_log_level              },

   393

    {   "log",          &lua_log                    },

   394

    {   NULL,           NULL                        }

   395

};

   396

   397

static void lua_global_init (lua_State *L)

   398

{

   399

    const struct luaL_Reg *reg;

   400

   401

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

   402

        // put the function on the stack

   403

        lua_pushcfunction(L, reg->func);

   404

   405

        // set the global

   406

        lua_setglobal(L, reg->name);

   407

    }

   408

}

   409

   410

void lua_objs_init (struct nexus_lua *lua)

   411

{

   416

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

   417

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

   421

}

   422