1

#include "lua_objs.h"

     2

#include "lua_irc.h"

     3

#include "lua_func.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <string.h>

     8

     9

/**

    10

 * Wrapper for module

    11

 */

    12

struct lua_module {

    13

    struct module *module;

    14

};

    15

    16

static struct lua_type lua_module_type = LUA_TYPE("spbot.module");

    17

    18

/**

    19

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

    20

 *

    21

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

    22

 */

    23

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

    24

{

    25

    // create the new obj

    26

    struct lua_module *lua_module = lua_type_create(L, &lua_module_type, sizeof(*lua_module));

    27

    28

    // initialize

    29

    lua_module->module = module;

    30

    31

    // ok

    32

    return 1;

    33

}

    34

    35

/**

    36

 * module_put() our module reference

    37

 */

    38

static int lua_module__gc (lua_State *L)

    39

{

    40

    struct lua_module *lua_module = lua_type_get(L, &lua_module_type, 1);

    41

    42

    // put it

    43

    module_put(lua_module->module);

    44

    45

    return 0;

    46

}

    47

    48

static int lua_module_conf (lua_State *L)

    49

{

    50

    struct lua_module *lua_module = lua_type_get(L, &lua_module_type, 1);

    51

    const struct config_option *option;

    52

    struct error_info err;

    53

    bool is_err = true;

    54

    55

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

    56

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

    57

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

    58

    59

    // number of arguments given

    60

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

    61

    62

    // init to zero

    63

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

    64

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

    65

    66

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

    67

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

    68

    69

    // the config name

    70

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

    71

    72

    // look it up

    73

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

    74

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

    75

    76

    // maximum number of arguments accepted

    77

    int maxargs = config_params_count(option);

    78

    79

    // too many arguments?

    80

    if (nargs - argidx > maxargs)

    81

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

    82

    83

    // the current param

    84

    const struct config_param *param = option->params;

    85

    86

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

    87

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

    88

        // the given config value

    89

        switch (lua_type(L, argidx)) {

    90

            case LUA_TNONE:

    91

            case LUA_TNIL:

    92

                // no value

    93

                value->type = CONFIG_NULL;

    94

    95

                break;

    96

    97

            case LUA_TSTRING: {

    98

                // string arg

    99

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

   100

   101

                // copy it as a mutable string buffer

   102

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

   103

                    lua_pushfstring(L, "strdup");

   104

                    goto error;

   105

                }

   106

   107

                // parse it as a raw value

   108

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

   109

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

   110

                    goto error;

   111

                }

   112

   113

                // seek to next value_buf

   114

                value_buf++;

   115

   116

            } break;

   117

   118

            case LUA_TUSERDATA:

   119

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

   120

                if (!lua_getmetatable(L, argidx)) {

   121

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

   122

                    goto error;

   123

                }

   124

   125

                // get the target metatable

   126

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

   127

   128

                // is it a chan?

   129

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

   130

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

   131

                    goto error;

   132

                }

   133

   134

                // pop the metatables

   135

                lua_pop(L, 2);

   136

   137

                // get the irc_chan

   138

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

   139

   140

                // build the value

   141

                value->type = CONFIG_IRC_CHAN;

   142

                value->irc_chan = lua_chan->chan;

   143

   144

                break;

   145

   146

            default:

   147

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

   148

                goto error;

   149

   150

        }

   151

    }

   152

   153

    // apply it

   154

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

   155

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

   156

        goto error;

   157

    }

   158

   159

    // ok

   160

    is_err = false;

   161

   162

error:

   163

    // release any allocated strings

   164

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

   165

        free(*value_buf);

   166

   167

    // either error or successful return

   168

    if (is_err)

   169

        return lua_error(L);

   170

    else

   171

        return 0;

   172

}

   173

   174

static int lua_module_unload (lua_State *L)

   175

{

   176

    struct lua_module *lua_module = lua_type_get(L, &lua_module_type, 1);

   177

    struct error_info err;

   178

   179

    // just unload it

   180

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

   181

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

   182

   183

    // ok

   184

    return 0;

   185

}

   186

   187

static struct lua_method lua_module_methods[] = LUA_METHODS(

   188

        LUA_METHOD("__gc",      lua_module__gc,     NULL    ),

   189

        LUA_METHOD("conf",      lua_module_conf,    NULL    ),

   190

        LUA_METHOD("unload",    lua_module_unload,  NULL    )

   191

);

   192

   193

/**

   194

 * Wrapper for modules

   195

 */

   196

struct lua_modules {

   197

    struct modules *modules;

   198

   199

    // strdup'd path for module_path

   200

    // XXX: remove when gc'd

   201

    char *path;

   202

};

   203

   204

static struct lua_type lua_modules_type = LUA_TYPE("spbot.modules");

   205

   206

static int lua_modules__gc (lua_State *L)

   207

{

   208

    struct lua_modules *lua_modules = lua_type_get(L, &lua_modules_type, 1);

   209

   210

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

   211

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

   212

        modules_path(lua_modules->modules, "");

   213

   214

    // release any strdup'd path

   215

    free(lua_modules->path);

   216

   217

    // ok

   218

    return 0;

   219

}

   220

   221

static int lua_modules_path (lua_State *L)

   222

{

   223

    struct lua_modules *lua_modules = lua_type_get(L, &lua_modules_type, 1);

   224

    char *path = NULL;

   225

    const char *old_path;

   226

   227

    if (!lua_isnoneornil(L, 2)) {

   228

        // the new path

   229

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

   230

            return luaL_error(L, "strdup");

   231

    }

   232

   233

    // set or get

   234

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

   235

   236

    // return the old path

   237

    if (old_path)

   238

        lua_pushstring(L, old_path);

   239

    else

   240

        lua_pushnil(L);

   241

   242

    if (path) {

   243

        // replace the old path

   244

        free(lua_modules->path); 

   245

        lua_modules->path = path;

   246

    }

   247

   248

    // ok

   249

    return 1;

   250

}

   251

   252

static int lua_modules_load (lua_State *L)

   253

{

   254

    struct lua_modules *lua_modules = lua_type_get(L, &lua_modules_type, 1);

   255

    struct module *module;

   256

    struct module_info info;

   257

    struct error_info err;

   258

   259

    // the module name/path

   260

    info.name = luaL_checkstring(L, 2);

   261

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

   262

   263

    // load and get a new reference

   264

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

   265

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

   266

   267

    // wrap

   268

    return lua_module_create(L, module);

   269

}

   270

   271

static int lua_modules_module (lua_State *L)

   272

{

   273

    struct lua_modules *lua_modules = lua_type_get(L, &lua_modules_type, 1);

   274

    struct module *module;

   275

   276

    // the module name

   277

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

   278

   279

    // look it up, as a new reference

   280

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

   281

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

   282

   283

    // wrap

   284

    return lua_module_create(L, module);

   285

}

   286

   287

static struct lua_method lua_modules_methods[] = LUA_METHODS(

   288

        LUA_METHOD("__gc",      lua_modules__gc,    NULL    ),

   289

        LUA_METHOD("path",      lua_modules_path,   NULL    ),

   290

        LUA_METHOD("load",      lua_modules_load,   NULL    ),

   291

        LUA_METHOD("module",    lua_modules_module, NULL    )

   292

    );

   293

   294

   295

   296

/**

   297

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

   298

 * 'modules'.

   299

 */

   300

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

   301

{

   302

    // allocate the global "modules" object

   303

    struct lua_modules *lua_modules = lua_type_register_global(L, &lua_modules_type, lua_modules_methods, "modules", sizeof(*lua_modules));

   304

   305

    // initialize it

   306

    lua_modules->modules = modules;

   307

}

   308

   309

/**

   310

 * Wrapper for nexus

   311

 */

   312

struct lua_nexus {

   313

    struct nexus *nexus;

   314

};

   315

   316

static struct lua_type lua_nexus_type = LUA_TYPE("spbot.nexus");

   317

   318

static int lua_nexus_shutdown (lua_State *L)

   319

{

   320

    struct lua_nexus *lua_nexus = lua_type_get(L, &lua_nexus_type, 1);

   321

   322

    // just shut it down

   323

    nexus_shutdown(lua_nexus->nexus);

   324

   325

    return 0;

   326

}

   327

   328

static int lua_nexus_load_config (lua_State *L)

   329

{

   330

    struct lua_nexus *lua_nexus = lua_type_get(L, &lua_nexus_type, 1);

   331

    struct error_info err;

   332

   333

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

   334

   335

    // just load it

   336

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

   337

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

   338

   339

    return 0;

   340

}

   341

   342

static struct lua_func lua_nexus_sleep_func = LUA_FUNC(&lua_nexus_type, "sleep",

   343

        "Schedules itself to resume after the given delay (in seconds) and yields",

   344

   345

        LUA_FUNC_ARG_INT("tv_sec",  LUA_ARG_REQUIRED)

   346

    );

   347

   348

static void lua_nexus_sleep_wakeup (evutil_socket_t fd, short what, void *arg)

   349

{

   350

    lua_State *L = arg;

   351

   352

    (void) fd;

   353

    (void) what;

   354

   355

    // resume the thread that called lua_nexus_sleep

   356

    lua_thread_resume_state(L);

   357

}

   358

   359

static int lua_nexus_sleep (lua_State *L)

   360

{

   361

    struct lua_nexus *lua_nexus;

   362

    long tv_sec;

   363

   364

    // parse args

   365

    lua_args_parse(L, &lua_nexus_sleep_func, (void *) &lua_nexus, &tv_sec);

   366

   367

    // build tv

   368

    struct timeval tv = { tv_sec, 0 };

   369

   370

    // schedule wakeup

   371

    // use a pure-timeout event

   373

        return luaL_error(L, "event_base_once");

   374

   375

    // yield

   376

    return lua_yield(L, 0);

   377

}

   378

   379

static struct lua_method lua_nexus_methods[] = LUA_METHODS(

   380

        LUA_METHOD("shutdown",      lua_nexus_shutdown,     NULL                    ),

   381

        LUA_METHOD("load_config",   lua_nexus_load_config,  NULL                    ),

   382

        LUA_METHOD("sleep",         lua_nexus_sleep,        &lua_nexus_sleep_func   )

   383

    );

   384

   385

/**

   386

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

   387

 * 'nexus'.

   388

 */

   389

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

   390

{

   391

    // allocate the global "nexus" object

   392

    struct lua_nexus *lua_nexus = lua_type_register_global(L, &lua_nexus_type, lua_nexus_methods, "nexus", sizeof(*lua_nexus));

   393

   394

    // initialize it

   395

    lua_nexus->nexus = nexus;

   396

}

   397

   398

   399

/**

   400

 * Global functions

   401

 */

   402

static int lua_log_level (lua_State *L)

   403

{

   404

    // log level as a string

   405

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

   406

   407

    // set it

   408

    set_log_level(new_level);

   409

   410

    // ok

   411

    return 0;

   412

}

   413

   414

static int lua_log (lua_State *L)

   415

{

   416

    // log level as a string

   417

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

   418

   419

    // log message

   420

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

   421

   422

    // log it

   423

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

   424

   425

    // ok

   426

    return 0;

   427

}

   428

   429

static const struct luaL_Reg lua_global_functions[] = {

   430

    {   "log_level",    lua_log_level               },

   431

    {   "log",          lua_log                     },

   432

    {   NULL,           NULL                        }

   433

};

   434

   435

static void lua_global_init (lua_State *L)

   436

{

   437

    const struct luaL_Reg *reg;

   438

   439

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

   440

        // put the function on the stack

   441

        lua_pushcfunction(L, reg->func);

   442

   443

        // set the global

   444

        lua_setglobal(L, reg->name);

   445

    }

   446

}

   447

   448

void lua_objs_init (struct nexus_lua *lua)

   449

{

   450

    // register types

   451

    lua_type_register(lua->st, &lua_module_type, lua_module_methods);

   452

   453

    // globals

   454

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

   455

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

   456

   457

    // global functions

   458

    lua_global_init(lua->st);

   459

}

   460

   461