1

#include "lua_objs.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <string.h>

     6

     7

#include <lua5.1/lua.h>

     8

#include <lua5.1/lualib.h>

     9

#include <lua5.1/lauxlib.h>

    10

    11

/**

    12

 * Convenience function to register a new metatable for a type, this leaves the metatable on the stack

    13

 */

    14

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

    15

{

    16

    luaL_newmetatable(L, name);

    17

    18

    // set the metatable __index to itself

    19

    lua_pushvalue(L, -1);

    20

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

    21

    22

    // register the methods to the metatable

    23

    luaL_register(L, NULL, methods);

    24

}

    25

    26

/**

    27

 * Convenience function to create a new userdata with the given type metatable name, return the pointer, and keep it

    28

 * on the stack

    29

 */

    30

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

    31

{

    32

    // create the new userdata on the stack

    33

    void *ud = lua_newuserdata(L, size);

    34

    35

    // get the type and set it

    36

    luaL_getmetatable(L, name);

    37

    lua_setmetatable(L, -2);

    38

    39

    // ok

    40

    return ud;

    41

}

    42

    43

/**

    44

 * Convenience function to create a new metatable for a type, a userdata for that type, and register it as a global

    45

 */

    46

static 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)

    47

{

    48

    // allocate the global object

    49

    void *obj = lua_newuserdata(L, size);

    50

    51

    // create the type metatable

    52

    lua_obj_create_type(L, type_name, methods);

    53

    54

    // set the userdata's metatable

    55

    lua_setmetatable(L, -2);

    56

    57

    // store it as a global

    58

    lua_setglobal(L, global_name);

    59

    60

    // ok

    61

    return obj;

    62

}

    63

    64

/**

    65

 * Convenience function to get a userdata with the given type metatable name as the first argument for a function

    66

 */

    67

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

    68

{

    69

    void *ud;

    70

    71

    // validate the userdata arg

    72

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

    73

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

    74

    75

        // XXX: needs a __noreturn__ attribute

    76

        return NULL;

    77

    78

    } else {

    79

        // ok

    80

        return ud;

    81

    82

    }

    83

}

    84

    85

/**

    86

 * Our lua wrapper for irc_chan

    87

 */

    88

struct lua_chan {

    89

    struct irc_chan *chan;

    90

};

    91

    92

/**

    93

 * Create a lua_chan userdata from the given irc_chan and leave it on the stack, returning 1

    94

 */

    95

static int lua_chan_create (lua_State *L, struct irc_chan *chan)

    96

{

    97

    // create the new obj

    98

    struct lua_chan *lua_chan = lua_obj_create_obj(L, "evirc.chan", sizeof(*lua_chan));

    99

   100

    // initialize

   101

    lua_chan->chan = chan;

   102

   103

    // ok

   104

    return 1;

   105

}

   106

   107

/**

   108

 * Return the channel name as a lua string

   109

 */

   110

static int lua_chan_tostring (lua_State *L)

   111

{

   112

    struct lua_chan *lua_chan = lua_obj_get_obj(L, __func__, "evirc.chan");

   113

   114

    lua_pushfstring(L, "<irc_chan %s>", irc_chan_name(lua_chan->chan));

   115

   116

    return 1;

   117

}

   118

   119

/**

   120

 * Send a PRIVMSG to the channel

   121

 */

   122

static int lua_chan_say (lua_State *L)

   123

{

   124

    err_t err;

   125

   126

    struct lua_chan *lua_chan = lua_obj_get_obj(L, __func__, "evirc.chan");

   127

   128

    // the message

   129

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

   130

   131

    // send

   132

    if ((err = irc_chan_PRIVMSG(lua_chan->chan, message)))

   133

        return luaL_error(L, "irc_chan_PRIVMSG: '%s': %s", message, error_name(err));

   134

   135

    // ok

   136

    return 0;

   137

}

   138

   139

static const struct luaL_Reg lua_chan_methods[] = {

   140

    {   "__tostring",       &lua_chan_tostring  },

   141

    {   "say",              &lua_chan_say       },

   142

    {   NULL,               NULL                },

   143

};

   144

   145

/**

   146

 * Initialize the lua_chan object type

   147

 */

   148

static void lua_chan_init (lua_State *L)

   149

{

   150

    lua_obj_create_type(L, "evirc.chan", lua_chan_methods);

   151

}

   152

   153

/**

   154

 * Our lua wrapper for irc_net

   155

 */

   156

struct lua_net {

   157

    struct irc_net *net;

   158

};

   159

   160

/**

   161

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

   162

 */

   163

static int lua_net_create (lua_State *L, struct irc_net *net)

   164

{

   165

    // create the new obj

   166

    struct lua_net *lua_net = lua_obj_create_obj(L, "evirc.net", sizeof(*lua_net));

   167

   168

    // initialize

   169

    lua_net->net = net;

   170

   171

    // ok

   172

    return 1;

   173

}

   174

   175

/**

   176

 * Return the network name as a lua string

   177

 */

   178

static int lua_net_tostring (lua_State *L)

   179

{

   180

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   181

   182

    lua_pushfstring(L, "<irc_net %s>", irc_net_name(lua_net->net));

   183

   184

    return 1;

   185

}

   186

   187

/**

   188

 * Join a new channel, returning the lua_chan

   189

 */

   190

static int lua_net_join (lua_State *L)

   191

{

   192

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   193

    struct irc_chan_info chan_info;

   194

    struct irc_chan *chan;

   195

    struct error_info err;

   196

   197

    // the channel name

   198

    chan_info.channel = luaL_checkstring(L, 2);

   199

   200

    // add it

   201

    if (irc_net_add_chan(lua_net->net, &chan, &chan_info, &err))

   202

        return luaL_error(L, "irc_net_add_chan: %s: %s", chan_info.channel, error_msg(&err));

   203

   204

    // return it

   205

    return lua_chan_create(L, chan);    

   206

}

   207

   208

/**

   209

 * Look up a channel by name, returning the lua_chan

   210

 */

   211

static int lua_net_get_chan (lua_State *L)

   212

{

   213

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   214

    struct irc_chan *chan;

   215

   216

    // the channel name

   217

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

   218

   219

    // lookup the irc_chan

   220

    if ((chan = irc_net_get_chan(lua_net->net, channel)) == NULL)

   221

        return luaL_error(L, "irc_net_get_chan: no such channel: %s", channel);

   222

   223

    // wrap it

   224

    return lua_chan_create(L, chan);

   225

}

   226

   227

static const struct luaL_Reg lua_net_methods[] = {

   228

    {   "__tostring",   &lua_net_tostring   },

   229

    {   "join",         &lua_net_join       },

   230

    {   "channel",      &lua_net_get_chan   },

   231

    {   NULL,           NULL                }

   232

};

   233

   234

/**

   235

 * Initialize the lua_net object type

   236

 */

   237

static void lua_net_init (lua_State *L)

   238

{

   239

    lua_obj_create_type(L, "evirc.net", lua_net_methods);

   240

}

   241

   242

/**

   243

 * Wrapper for irc_client

   244

 */

   245

struct lua_client {

   246

    struct irc_client *client;

   247

   248

    struct irc_client_defaults defaults;

   249

};

   250

   251

static int lua_client_set_defaults (lua_State *L)

   252

{

   253

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   254

   255

    // read the args

   256

    // XXX: need to copy these, really

   257

    lua_client->defaults.register_info.nickname = luaL_checkstring(L, 2);

   258

    lua_client->defaults.register_info.username = luaL_checkstring(L, 3);

   259

    lua_client->defaults.register_info.realname = luaL_checkstring(L, 4);

   260

   261

    // set the non-args

   262

    lua_client->defaults.service = IRC_PORT;

   263

    lua_client->defaults.service_ssl = IRC_SSL_PORT;

   264

   265

    // invoke

   266

    irc_client_set_defaults(lua_client->client, &lua_client->defaults);

   267

   268

    // ok

   269

    return 0;

   270

}

   271

   272

static int lua_client_connect (lua_State *L)

   273

{

   274

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   275

    struct irc_net_info net_info;

   276

    struct irc_net *net;

   277

    struct error_info err;

   278

   279

    // init net_info

   280

    memset(&net_info, 0, sizeof(net_info));

   281

   282

    // the network name

   283

    net_info.network = luaL_checkstring(L, 2);

   284

   285

    // the hostname

   286

    net_info.hostname = luaL_checkstring(L, 3);

   287

   288

    // service remains default

   289

    net_info.service = "6667";

   290

   291

    // create it

   292

    if (irc_client_add_net(lua_client->client, &net, &net_info, &err))

   293

        return luaL_error(L, "irc_client_add_net: %s/%s: %s", net_info.network, net_info.hostname, error_msg(&err));

   294

   295

    // wrap it

   296

    return lua_net_create(L, net);

   297

}

   298

   299

static int lua_client_get_network (lua_State *L)

   300

{

   301

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   302

    struct irc_net *net;

   303

   304

    // the network name

   305

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

   306

   307

    // lookup the irc_net

   308

    if ((net = irc_client_get_net(lua_client->client, network)) == NULL)

   309

        return luaL_error(L, "irc_client_get_net: no such network: %s", network);

   310

   311

    // wrap it

   312

    return lua_net_create(L, net);

   313

}

   314

   315

static int lua_client_quit (lua_State *L)

   316

{

   317

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   318

    err_t err;

   319

   320

    // the message

   321

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

   322

   323

    // execute

   324

    if ((err = irc_client_quit(lua_client->client, message)))

   325

        return luaL_error(L, "irc_client_quit: %s", error_name(err));

   326

   327

    // ok

   328

    return 0;

   329

}

   330

   331

static const struct luaL_Reg lua_client_methods[] = {

   332

    {   "set_defaults", &lua_client_set_defaults    },

   333

    {   "connect",      &lua_client_connect         },

   334

    {   "network",      &lua_client_get_network     },

   335

    {   "quit",         &lua_client_quit            },

   336

    {   NULL,           NULL                        }

   337

};

   338

   339

/**

   340

 * Initialize the evirc.client type for lua_client, and registers an instance bound to the given irc_client at

   341

 * 'client'.

   342

 */

   343

static void lua_client_init (lua_State *L, struct irc_client *client)

   344

{

   345

    // allocate the global "client" object

   346

    struct lua_client *lua_client = lua_obj_create_global_type(L, "evirc.client", lua_client_methods, "client", sizeof(*lua_client));

   347

   348

    // initialize it

   349

    lua_client->client = client;

   350

}

   351

   352

/**

   353

 * Wrapper for module

   354

 */

   355

struct lua_module {

   356

    struct module *module;

   357

};

   358

   359

/**

   360

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

   361

 */

   362

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

   363

{

   364

    // create the new obj

   365

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

   366

   367

    // initialize

   368

    lua_module->module = module;

   369

   370

    // ok

   371

    return 1;

   372

}

   373

   374

/**

   375

 * Parse and apply the given config option value as a raw value to the given module's option

   376

 */

   377

static int _lua_module_conf_raw_str (lua_State *L, struct lua_module *lua_module, struct nexus *nexus, 

   378

        const struct config_option *option, const char *conf_value)

   379

{

   380

    struct config_value value;

   381

    struct error_info err;

   382

   383

    // mutable version of the conf_value

   384

    char conf_value_buf[strlen(conf_value) + 1];

   385

    strcpy(conf_value_buf, conf_value);

   386

   387

    // parse it as a raw value

   388

    if (config_parse(option, nexus, &value, conf_value_buf, &err))

   389

        return luaL_error(L, "config_parse: %s/%s: %s", option->name, conf_value_buf, error_msg(&err));

   390

   391

    // apply it while conf_value_buf is still in scope

   392

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

   393

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

   394

   395

    // ok

   396

    return 0;

   397

}

   398

   399

static int lua_module_conf (lua_State *L)

   400

{

   401

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

   402

    const struct config_option *option;

   403

    struct config_value value;

   404

    struct error_info err;

   405

   406

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

   407

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

   408

   409

    // the config name

   410

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

   411

   412

    // look it up

   413

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

   414

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

   415

   416

    // the config value

   417

    switch (lua_type(L, 3)) {

   418

        case LUA_TSTRING:

   419

            // parse+apply it as a raw string

   420

            return _lua_module_conf_raw_str(L, lua_module, nexus, option, lua_tostring(L, 3));

   421

   422

        case LUA_TUSERDATA:

   423

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

   424

            if (!lua_getmetatable(L, 3))

   425

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

   426

   427

            // get the target metatable

   428

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

   429

   430

            // is it a chan?

   431

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

   432

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

   433

   434

            // pop the metatables

   435

            lua_pop(L, 2);

   436

   437

            // get the irc_chan

   438

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

   439

   440

            // build the value

   441

            value.type = CONFIG_IRC_CHAN;

   442

            value.irc_chan = lua_chan->chan;

   443

   444

            break;

   445

   446

        default:

   447

            return luaL_error(L, "config value is of unknown lua type '%s'", lua_typename(L, 3));

   448

   449

    }

   450

   451

    // apply it

   452

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

   453

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

   454

   455

    // ok

   456

    return 0;

   457

}

   458

   459

static const struct luaL_Reg lua_module_methods[] = {

   460

    {   "conf",         &lua_module_conf            },

   461

    {   NULL,           NULL                        }

   462

};

   463

   464

/**

   465

 * Initialize the lua_module object type

   466

 */

   467

static void lua_module_init (lua_State *L)

   468

{

   469

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

   470

}

   471

   472

/**

   473

 * Wrapper for modules

   474

 */

   475

struct lua_modules {

   476

    struct modules *modules;

   477

   478

    // strdup'd path for module_path

   479

    // XXX: remove when gc'd

   480

    char *path;

   481

};

   482

   483

static int lua_modules_path (lua_State *L)

   484

{

   485

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

   486

    char *path = NULL;

   487

    const char *old_path;

   488

   489

    if (!lua_isnoneornil(L, 2)) {

   490

        // the new path

   491

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

   492

            return luaL_error(L, "strdup");

   493

    }

   494