1

#include "lua_objs.h"

     2

#include "lua_irc.h"

     3

#include "lua_func.h"

     5

#include "log.h"

     6

     7

#include <stdlib.h>

     8

#include <string.h>

     9

    10

/**

    11

 * Wrapper for module

    12

 */

    13

struct lua_module {

    14

    struct module *module;

    15

};

    16

    17

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

    18

    19

/**

    20

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

    21

 *

    22

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

    23

 */

    24

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

    25

{

    26

    // create the new obj

    27

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

    28

    29

    // initialize

    30

    lua_module->module = module;

    31

    32

    // ok

    33

    return 1;

    34

}

    35

    36

/**

    37

 * module_put() our module reference

    38

 */

    39

static int lua_module__gc (lua_State *L)

    40

{

    41

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

    42

    43

    // put it

    44

    module_put(lua_module->module);

    45

    46

    return 0;

    47

}

    48

    49

static int lua_module_conf (lua_State *L)

    50

{

    51

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

    52

    const struct config_option *option;

    53

    struct error_info err;

    54

    bool is_err = true;

    55

    56

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

    57

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

    58

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

    59

    60

    // number of arguments given

    61

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

    62

    63

    // init to zero

    64

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

    65

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

    66

    67

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

    68

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

    69

    70

    // the config name

    71

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

    72

    73

    // look it up

    74

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

    75

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

    76

    77

    // maximum number of arguments accepted

    78

    int maxargs = config_params_count(option);

    79

    80

    // too many arguments?

    81

    if (nargs - argidx > maxargs)

    82

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

    83

    84

    // the current param

    85

    const struct config_param *param = option->params;

    86

    87

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

    88

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

    89

        // the given config value

    90

        switch (lua_type(L, argidx)) {

    91

            case LUA_TNONE:

    92

            case LUA_TNIL:

    93

                // no value

    94

                value->type = CONFIG_NULL;

    95

    96

                break;

    97

    98

            case LUA_TSTRING: {

    99

                // string arg

   100

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

   101

   102

                // copy it as a mutable string buffer

   103

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

   104

                    lua_pushfstring(L, "strdup");

   105

                    goto error;

   106

                }

   107

   108

                // parse it as a raw value

   109

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

   110

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

   111

                    goto error;

   112

                }

   113

   114

                // seek to next value_buf

   115

                value_buf++;

   116

   117

            } break;

   118

   119

            case LUA_TUSERDATA:

   120

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

   121

                if (!lua_getmetatable(L, argidx)) {

   122

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

   123

                    goto error;

   124

                }

   125

   126

                // get the target metatable

   127

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

   128

   129

                // is it a chan?

   130

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

   131

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

   132

                    goto error;

   133

                }

   134

   135

                // pop the metatables

   136

                lua_pop(L, 2);

   137

   138

                // get the irc_chan

   139

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

   140

   141

                // build the value

   142

                value->type = CONFIG_IRC_CHAN;

   143

                value->irc_chan = lua_chan->chan;

   144

   145

                break;

   146

   147

            default:

   148

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

   149

                goto error;

   150

   151

        }

   152

    }

   153

   154

    // apply it

   155

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

   156

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

   157

        goto error;

   158

    }

   159

   160

    // ok

   161

    is_err = false;

   162

   163

error:

   164

    // release any allocated strings

   165

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

   166

        free(*value_buf);

   167

   168

    // either error or successful return

   169

    if (is_err)

   170

        return lua_error(L);

   171

    else

   172

        return 0;

   173

}

   174

   175

static int lua_module_unload (lua_State *L)

   176

{

   177

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

   178

    struct error_info err;

   179

   180

    // just unload it

   181

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

   182

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

   183

   184

    // ok

   185

    return 0;

   186

}

   187

   188

static struct lua_method lua_module_methods[] = LUA_METHODS(

   189

        LUA_METHOD("__gc",      lua_module__gc,     NULL    ),

   190

        LUA_METHOD("conf",      lua_module_conf,    NULL    ),

   191

        LUA_METHOD("unload",    lua_module_unload,  NULL    )

   192

);

   193

   194

/**

   195

 * Wrapper for modules

   196

 */

   197

struct lua_modules {

   198

    struct modules *modules;

   199

   200

    // strdup'd path for module_path

   201

    // XXX: remove when gc'd

   202

    char *path;

   203

};

   204

   205

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

   206

   207

static int lua_modules__gc (lua_State *L)

   208

{

   209

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

   210

   211

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

   212

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

   213

        modules_path(lua_modules->modules, "");

   214

   215

    // release any strdup'd path

   216

    free(lua_modules->path);

   217

   218

    // ok

   219

    return 0;

   220

}

   221

   222

static int lua_modules_path (lua_State *L)

   223

{

   224

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

   225

    char *path = NULL;

   226

    const char *old_path;

   227

   228

    if (!lua_isnoneornil(L, 2)) {

   229

        // the new path

   230

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

   231

            return luaL_error(L, "strdup");

   232

    }

   233

   234

    // set or get

   235

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

   236

   237

    // return the old path

   238

    if (old_path)

   239

        lua_pushstring(L, old_path);

   240

    else

   241

        lua_pushnil(L);

   242

   243

    if (path) {

   244

        // replace the old path

   245

        free(lua_modules->path); 

   246

        lua_modules->path = path;

   247

    }

   248

   249

    // ok

   250

    return 1;

   251

}

   252

   253

static int lua_modules_load (lua_State *L)

   254

{

   255

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

   256

    struct module *module;

   257

    struct module_info info;

   258

    struct error_info err;

   259

   260

    // the module name/path

   261

    info.name = luaL_checkstring(L, 2);

   262

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

   263

   264

    // load and get a new reference

   265

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

   266

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

   267

   268

    // wrap

   269

    return lua_module_create(L, module);

   270

}

   271

   272

static int lua_modules_module (lua_State *L)

   273

{

   274

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

   275

    struct module *module;

   276

   277

    // the module name

   278

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

   279

   280

    // look it up, as a new reference

   281

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

   282

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

   283

   284

    // wrap

   285

    return lua_module_create(L, module);

   286

}

   287

   288

static struct lua_method lua_modules_methods[] = LUA_METHODS(

   289

        LUA_METHOD("__gc",      lua_modules__gc,    NULL    ),

   290

        LUA_METHOD("path",      lua_modules_path,   NULL    ),

   291

        LUA_METHOD("load",      lua_modules_load,   NULL    ),

   292

        LUA_METHOD("module",    lua_modules_module, NULL    )

   293

    );

   294

   295

   296

   297

/**

   298

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

   299

 * 'modules'.

   300

 */

   301

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

   302

{

   303

    // allocate the global "modules" object

   304

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

   305

   306

    // initialize it

   307

    lua_modules->modules = modules;

   308

}

   309

   310

/**

   311

 * Wrapper for nexus

   312

 */

   313

struct lua_nexus {

   314

    struct nexus *nexus;

   315

};

   316

   317

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

   318

   319

static int lua_nexus_shutdown (lua_State *L)

   320

{

   321

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

   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_type_get(L, &lua_nexus_type, 1);

   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 struct lua_func lua_nexus_sleep_func = LUA_FUNC(&lua_nexus_type, "sleep",

   344

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

   345

   346

        LUA_FUNC_ARG_INT("tv_sec",  LUA_ARG_REQUIRED)

   347

    );

   348

   349

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

   350

{

   351

    lua_State *L = arg;

   352

   353

    (void) fd;

   354

    (void) what;

   355

   356

    // resume the thread that called lua_nexus_sleep

   357

    lua_thread_resume_state(L);

   358

}

   359

   360

static int lua_nexus_sleep (lua_State *L)

   361

{

   362

    struct lua_nexus *lua_nexus;

   363

    long tv_sec;

   364

   365

    // parse args

   366

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

   367

   368

    // build tv

   369

    struct timeval tv = { tv_sec, 0 };

   370

   371

    // schedule wakeup

   372

    // use a pure-timeout event

   373

    if (event_base_once(lua_nexus->nexus->ev_base, -1, EV_TIMEOUT, lua_nexus_sleep_wakeup, L, &tv))

   374

        return luaL_error(L, "event_base_once");

   375

   376

    // yield

   378

}

   379

   380

static struct lua_method lua_nexus_methods[] = LUA_METHODS(

   381

        LUA_METHOD("shutdown",      lua_nexus_shutdown,     NULL                    ),

   382

        LUA_METHOD("load_config",   lua_nexus_load_config,  NULL                    ),

   383

        LUA_METHOD("sleep",         lua_nexus_sleep,        &lua_nexus_sleep_func   )

   384

    );

   385

   386

/**

   387

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

   388

 * 'nexus'.

   389

 */

   390

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

   391

{

   392

    // allocate the global "nexus" object

   393

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

   394

   395

    // initialize it

   396

    lua_nexus->nexus = nexus;

   397

}

   398

   399

   400

/**

   401

 * Global functions

   402

 */

   403

static int lua_log_level (lua_State *L)

   404

{

   405

    // log level as a string

   406

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

   407

   408

    // set it

   409

    set_log_level(new_level);

   410

   411

    // ok

   412

    return 0;

   413

}

   414

   415

static int lua_log (lua_State *L)

   416

{

   417

    // log level as a string

   418

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

   419

   420

    // log message

   421

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

   422

   423

    // log it

   424

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

   425

   426

    // ok

   427

    return 0;

   428

}

   429

   430

static const struct luaL_Reg lua_global_functions[] = {

   431

    {   "log_level",    lua_log_level               },

   432

    {   "log",          lua_log                     },

   433

    {   NULL,           NULL                        }

   434

};

   435

   436

static void lua_global_init (lua_State *L)

   437

{

   438

    const struct luaL_Reg *reg;

   439

   440

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

   441

        // put the function on the stack

   442

        lua_pushcfunction(L, reg->func);

   443

   444

        // set the global

   445

        lua_setglobal(L, reg->name);

   446

    }

   447

}

   448

   449

void lua_objs_init (struct nexus_lua *lua)

   450

{

   451

    // register types

   452

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

   453

   454

    // globals

   455

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

   456

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

   457

   458

    // global functions

   459

    lua_global_init(lua->st);

   460

}

   461

   462