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

void lua_obj_create_type (lua_State *L, const char *name, const struct luaL_Reg methods[])

     9

{

    10

    luaL_newmetatable(L, name);

    11

    12

    // set the metatable __index to itself

    13

    lua_pushvalue(L, -1);

    14

    lua_setfield(L, -1, "__index");

    15

    16

    // register the methods to the metatable

    17

    luaL_register(L, NULL, methods);

    18

}

    19

    20

void* lua_obj_create_obj (lua_State *L, const char *name, size_t size)

    21

{

    22

    // create the new userdata on the stack

    23

    void *ud = lua_newuserdata(L, size);

    24

    25

    // get the type and set it

    26

    luaL_getmetatable(L, name);

    27

    lua_setmetatable(L, -2);

    28

    29

    // ok

    30

    return ud;

    31

}

    32

    33

void* lua_obj_create_global_type (lua_State *L, const char *type_name, const struct luaL_Reg methods[], const char *global_name, size_t size)

    34

{

    35

    // allocate the global object

    36

    void *obj = lua_newuserdata(L, size);

    37

    38

    // create the type metatable

    39

    lua_obj_create_type(L, type_name, methods);

    40

    41

    // set the userdata's metatable

    42

    lua_setmetatable(L, -2);

    43

    44

    // store it as a global

    45

    lua_setglobal(L, global_name);

    46

    47

    // ok

    48

    return obj;

    49

}

    50

    51

void* lua_obj_get_obj (lua_State *L, const char *func, const char *name)

    52

{

    53

    void *ud;

    54

    55

    // validate the userdata arg

    56

    if ((ud = luaL_checkudata(L, 1, name)) == NULL) {

    57

        luaL_error(L, "bad type argument to %s: `%s` expected", func, name);

    58

    59

        // XXX: needs a __noreturn__ attribute

    60

        return NULL;

    61

    62

    } else {

    63

        // ok

    64

        return ud;

    65

    66

    }

    67

}

    68

   102

/**

   103

 * Wrapper for module

   104

 */

   105

struct lua_module {

   106

    struct module *module;

   107

};

   108

   109

/**

   110

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

   111

 *

   112

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

   113

 */

   114

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

   115

{

   116

    // create the new obj

   117

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

   118

   119

    // initialize

   120

    lua_module->module = module;

   121

   122

    // ok

   123

    return 1;

   124

}

   125

   126

/**

   127

 * module_put() our module reference

   128

 */

   129

static int lua_module__gc (lua_State *L)

   130

{

   131

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

   132

   133

    // put it

   134

    module_put(lua_module->module);

   135

   136

    return 0;

   137

}

   138

   139

static int lua_module_conf (lua_State *L)

   140

{

   141

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

   142

    const struct config_option *option;

   143

    struct error_info err;

   144

    bool is_err = true;

   145

   146

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

   147

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

   148

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

   149

   150

    // number of arguments given

   151

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

   152

   153

    // init to zero

   154

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

   155

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

   156

   157

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

   158

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

   159

   160

    // the config name

   161

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

   162

   163

    // look it up

   164

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

   165

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

   166

   167

    // maximum number of arguments accepted

   168

    int maxargs = config_params_count(option);

   169

   170

    // too many arguments?

   171

    if (nargs - argidx > maxargs)

   172

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

   173

   174

    // the current param

   175

    const struct config_param *param = option->params;

   176

   177

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

   178

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

   179

        // the given config value

   180

        switch (lua_type(L, argidx)) {

   181

            case LUA_TNONE:

   182

            case LUA_TNIL:

   183

                // no value

   184

                value->type = CONFIG_NULL;

   185

   186

                break;

   187

   188

            case LUA_TSTRING: {

   189

                // string arg

   190

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

   191

   192

                // copy it as a mutable string buffer

   193

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

   194

                    lua_pushfstring(L, "strdup");

   195

                    goto error;

   196

                }

   197

   198

                // parse it as a raw value

   199

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

   200

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

   201

                    goto error;

   202

                }

   203

   204

                // seek to next value_buf

   205

                value_buf++;

   206

   207

            } break;

   208

   209

            case LUA_TUSERDATA:

   210

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

   211

                if (!lua_getmetatable(L, argidx)) {

   212

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

   213

                    goto error;

   214

                }

   215

   216

                // get the target metatable

   217

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

   218

   219

                // is it a chan?

   220

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

   221

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

   222

                    goto error;

   223

                }

   224

   225

                // pop the metatables

   226

                lua_pop(L, 2);

   227

   228

                // get the irc_chan

   229

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

   230

   231

                // build the value

   232

                value->type = CONFIG_IRC_CHAN;

   233

                value->irc_chan = lua_chan->chan;

   234

   235

                break;

   236

   237

            default:

   238

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

   239

                goto error;

   240

   241

        }

   242

    }

   243

   244

    // apply it

   245

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

   246

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

   247

        goto error;

   248

    }

   249

   250

    // ok

   251

    is_err = false;

   252

   253

error:

   254

    // release any allocated strings

   255

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

   256

        free(*value_buf);

   257

   258

    // either error or successful return

   259

    if (is_err)

   260

        return lua_error(L);

   261

    else

   262

        return 0;

   263

}

   264

   265

static int lua_module_unload (lua_State *L)

   266

{

   267

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

   268

    struct error_info err;

   269

   270

    // just unload it

   271

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

   272

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

   273

   274

    // ok

   275

    return 0;

   276

}

   277

   278

static const struct luaL_Reg lua_module_methods[] = {

   279

    {   "__gc",         &lua_module__gc             },

   280

    {   "conf",         &lua_module_conf            },

   281

    {   "unload",       &lua_module_unload          },

   282

    {   NULL,           NULL                        }

   283

};

   284

   285

/**

   286

 * Initialize the lua_module object type

   287

 */

   288

static void lua_module_init (lua_State *L)

   289

{

   290

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

   291

}

   292

   293

/**

   294

 * Wrapper for modules

   295

 */

   296

struct lua_modules {

   297

    struct modules *modules;

   298

   299

    // strdup'd path for module_path

   300

    // XXX: remove when gc'd

   301

    char *path;

   302

};

   303

   304

static int lua_modules__gc (lua_State *L)

   305

{

   306

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

   307

   308

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

   309

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

   310

        modules_path(lua_modules->modules, "");

   311

   312

    // release any strdup'd path

   313

    free(lua_modules->path);

   314

   315

    // ok

   316

    return 0;

   317

}

   318

   319

static int lua_modules_path (lua_State *L)

   320

{

   321

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

   322

    char *path = NULL;

   323

    const char *old_path;

   324

   325

    if (!lua_isnoneornil(L, 2)) {

   326

        // the new path

   327

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

   328

            return luaL_error(L, "strdup");

   329

    }

   330

   331

    // set or get

   332

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

   333

   334

    // return the old path

   335

    if (old_path)

   336

        lua_pushstring(L, old_path);

   337

    else

   338

        lua_pushnil(L);

   339

   340

    if (path) {

   341

        // replace the old path

   342

        free(lua_modules->path); 

   343

        lua_modules->path = path;

   344

    }

   345

   346

    // ok

   347

    return 1;

   348

}

   349

   350

static int lua_modules_load (lua_State *L)

   351

{

   352

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

   353

    struct module *module;

   354

    struct module_info info;

   355

    struct error_info err;

   356

   357

    // the module name/path

   358

    info.name = luaL_checkstring(L, 2);

   359

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

   360

   361

    // load and get a new reference

   362

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

   363

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

   364

   365

    // wrap

   366

    return lua_module_create(L, module);

   367

}

   368

   369

static int lua_modules_module (lua_State *L)

   370

{

   371

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

   372

    struct module *module;

   373

   374

    // the module name

   375

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

   376

   377

    // look it up, as a new reference

   378

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

   379

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

   380

   381

    // wrap

   382

    return lua_module_create(L, module);

   383

}

   384

   385

static const struct luaL_Reg lua_modules_methods[] = {

   386

    {   "__gc",         &lua_modules__gc            },

   387

    {   "path",         &lua_modules_path           },

   388

    {   "load",         &lua_modules_load           },

   389

    {   "module",       &lua_modules_module         },

   390

    {   NULL,           NULL                        }

   391

};

   392

   393

/**

   394

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

   395

 * 'modules'.

   396

 */

   397

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

   398

{

   399

    // allocate the global "modules" object

   400

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

   401

   402

    // initialize it

   403

    lua_modules->modules = modules;

   404

}

   405

   406

/**

   407

 * Wrapper for nexus

   408

 */

   409

struct lua_nexus {

   410

    struct nexus *nexus;

   411

};

   412

   413

static int lua_nexus_shutdown (lua_State *L)

   414

{

   415

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

   416

   417

    // just shut it down

   418

    nexus_shutdown(lua_nexus->nexus);

   419

   420

    return 0;

   421

}

   422

   423

static int lua_nexus_load_config (lua_State *L)

   424

{

   425

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

   426

    struct error_info err;

   427

   428

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

   429

   430

    // just load it

   431

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

   432

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

   433

   434

    return 0;

   435

}

   436

   437

static const struct luaL_Reg lua_nexus_methods[] = {

   438

    {   "shutdown",     &lua_nexus_shutdown         },

   439

    {   "load_config",  &lua_nexus_load_config      },

   440

    {   NULL,           NULL                        }

   441

};

   442

   443

/**

   444

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

   445

 * 'nexus'.

   446

 */

   447

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

   448

{

   449

    // allocate the global "nexus" object

   450

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

   451

   452

    // initialize it

   453

    lua_nexus->nexus = nexus;

   454

}

   455

   456

/**

   457

 * Global functions

   458

 */

   459

static int lua_log_level (lua_State *L)

   460

{

   461

    // log level as a string

   462

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

   463

   464

    // set it

   465

    set_log_level(new_level);

   466

   467

    // ok

   468

    return 0;

   469

}

   470

   471

static int lua_log (lua_State *L)

   472

{

   473

    // log level as a string

   474

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

   475

   476

    // log message

   477

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

   478

   479

    // log it

   480

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

   481

   482

    // ok

   483

    return 0;

   484

}

   485

   486

static const struct luaL_Reg lua_global_functions[] = {

   487

    {   "log_level",    &lua_log_level              },

   488

    {   "log",          &lua_log                    },

   489

    {   NULL,           NULL                        }

   490

};

   491

   492

static void lua_global_init (lua_State *L)