1

#include "lua_objs.h"

     2

#include "log.h"

     3

     4

#include <string.h>

     5

     6

#include <lua5.1/lua.h>

     7

#include <lua5.1/lualib.h>

     8

#include <lua5.1/lauxlib.h>

     9

    10

/**

    11

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

    12

 */

    13

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

    14

{

    15

    luaL_newmetatable(L, name);

    16

    17

    // set the metatable __index to itself

    18

    lua_pushvalue(L, -1);

    19

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

    20

    21

    // register the methods to the metatable

    22

    luaL_register(L, NULL, methods);

    23

}

    24

    25

/**

    26

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

    27

 * on the stack

    28

 */

    29

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

    30

{

    31

    // create the new userdata on the stack

    32

    void *ud = lua_newuserdata(L, size);

    33

    34

    // get the type and set it

    35

    luaL_getmetatable(L, name);

    36

    lua_setmetatable(L, -2);

    37

    38

    // ok

    39

    return ud;

    40

}

    41

    42

/**

    43

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

    44

 */

    45

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)

    46

{

    47

    // allocate the global object

    48

    void *obj = lua_newuserdata(L, size);

    49

    50

    // create the type metatable

    51

    lua_obj_create_type(L, type_name, methods);

    52

    53

    // set the userdata's metatable

    54

    lua_setmetatable(L, -2);

    55

    56

    // store it as a global

    57

    lua_setglobal(L, global_name);

    58

    59

    // ok

    60

    return obj;

    61

}

    62

    63

/**

    64

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

    65

 */

    66

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

    67

{

    68

    void *ud;

    69

    70

    // validate the userdata arg

    71

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

    72

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

    73

    74

        // XXX: needs a __noreturn__ attribute

    75

        return NULL;

    76

    77

    } else {

    78

        // ok

    79

        return ud;

    80

    81

    }

    82

}

    83

    84

/**

    85

 * Our lua wrapper for irc_chan

    86

 */

    87

struct lua_chan {

    88

    struct irc_chan *chan;

    89

};

    90

    91

/**

    92

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

    93

 */

    94

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

    95

{

    96

    // create the new obj

    97

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

    98

    99

    // initialize

   100

    lua_chan->chan = chan;

   101

   102

    // ok

   103

    return 1;

   104

}

   105

   106

/**

   107

 * Return the channel name as a lua string

   108

 */

   109

static int lua_chan_tostring (lua_State *L)

   110

{

   111

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

   112

   113

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

   114

   115

    return 1;

   116

}

   117

   118

/**

   119

 * Send a PRIVMSG to the channel

   120

 */

   121

static int lua_chan_say (lua_State *L)

   122

{

   123

    err_t err;

   124

   125

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

   126

   127

    // the message

   128

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

   129

   130

    // send

   131

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

   132

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

   133

   134

    // ok

   135

    return 0;

   136

}

   137

   138

static const struct luaL_Reg lua_chan_methods[] = {

   139

    {   "__tostring",       &lua_chan_tostring  },

   140

    {   "say",              &lua_chan_say       },

   141

    {   NULL,               NULL                },

   142

};

   143

   144

/**

   145

 * Initialize the lua_chan object type

   146

 */

   147

static void lua_chan_init (lua_State *L)

   148

{

   149

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

   150

}

   151

   152

/**

   153

 * Our lua wrapper for irc_net

   154

 */

   155

struct lua_net {

   156

    struct irc_net *net;

   157

};

   158

   159

/**

   160

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

   161

 */

   162

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

   163

{

   164

    // create the new obj

   165

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

   166

   167

    // initialize

   168

    lua_net->net = net;

   169

   170

    // ok

   171

    return 1;

   172

}

   173

   174

/**

   175

 * Return the network name as a lua string

   176

 */

   177

static int lua_net_tostring (lua_State *L)

   178

{

   179

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

   180

   181

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

   182

   183

    return 1;

   184

}

   185

   186

/**

   187

 * Join a new channel, returning the lua_chan

   188

 */

   189

static int lua_net_join (lua_State *L)

   190

{

   191

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

   192

    struct irc_chan_info chan_info;

   193

    struct irc_chan *chan;

   194

    struct error_info err;

   195

   196

    // the channel name

   197

    chan_info.channel = luaL_checkstring(L, 2);

   198

   199

    // add it

   200

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

   201

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

   202

   203

    // return it

   204

    return lua_chan_create(L, chan);    

   205

}

   206

   207

/**

   208

 * Look up a channel by name, returning the lua_chan

   209

 */

   210

static int lua_net_get_chan (lua_State *L)

   211

{

   212

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

   213

    struct irc_chan *chan;

   214

   215

    // the channel name

   216

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

   217

   218

    // lookup the irc_chan

   219

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

   220

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

   221

   222

    // wrap it

   223

    return lua_chan_create(L, chan);

   224

}

   225

   226

static const struct luaL_Reg lua_net_methods[] = {

   227

    {   "__tostring",   &lua_net_tostring   },

   228

    {   "join",         &lua_net_join       },

   229

    {   "channel",      &lua_net_get_chan   },

   230

    {   NULL,           NULL                }

   231

};

   232

   233

/**

   234

 * Initialize the lua_net object type

   235

 */

   236

static void lua_net_init (lua_State *L)

   237

{

   238

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

   239

}

   240

   241

/**

   242

 * Wrapper for irc_client

   243

 */

   244

struct lua_client {

   245

    struct irc_client *client;

   246

   247

    struct irc_client_defaults defaults;

   248

};

   249

   250

static int lua_client_set_defaults (lua_State *L)

   251

{

   252

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

   253

   254

    // read the args

   255

    // XXX: need to copy these, really

   256

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

   257

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

   258

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

   259

   260

    // set the non-args

   261

    lua_client->defaults.service = IRC_PORT;

   262

    lua_client->defaults.service_ssl = IRC_SSL_PORT;

   263

   264

    // invoke

   265

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

   266

   267

    // ok

   268

    return 0;

   269

}

   270

   271

static int lua_client_connect (lua_State *L)

   272

{

   273

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

   274

    struct irc_net_info net_info;

   275

    struct irc_net *net;

   276

    struct error_info err;

   277

   278

    // init net_info

   279

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

   280

   281

    // the network name

   282

    net_info.network = luaL_checkstring(L, 2);

   283

   284

    // the hostname

   285

    net_info.hostname = luaL_checkstring(L, 3);

   286

   287

    // service remains default

   288

    net_info.service = "6667";

   289

   290

    // create it

   291

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

   292

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

   293

   294

    // wrap it

   295

    return lua_net_create(L, net);

   296

}

   297

   298

static int lua_client_get_network (lua_State *L)

   299

{

   300

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

   301

    struct irc_net *net;

   302

   303

    // the network name

   304

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

   305

   306

    // lookup the irc_net

   307

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

   308

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

   309

   310

    // wrap it

   311

    return lua_net_create(L, net);

   312

}

   313

   314

static int lua_client_quit (lua_State *L)

   315

{

   316

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

   317

    err_t err;

   318

   319

    // the message

   320

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

   321

   322

    // execute

   323

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

   324

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

   325

   326

    // ok

   327

    return 0;

   328

}

   329

   330

static const struct luaL_Reg lua_client_methods[] = {

   331

    {   "set_defaults", &lua_client_set_defaults    },

   332

    {   "connect",      &lua_client_connect         },

   333

    {   "network",      &lua_client_get_network     },

   334

    {   "quit",         &lua_client_quit            },

   335

    {   NULL,           NULL                        }

   336

};

   337

   338

/**

   339

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

   340

 * 'client'.

   341

 */

   342

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

   343

{

   344

    // allocate the global "client" object

   345

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

   346

   347

    // initialize it

   348

    lua_client->client = client;

   349

}

   350

   351

/**

   352

 * Wrapper for module

   353

 */

   354

struct lua_module {

   355

    struct module *module;

   356

};

   357

   358

/**

   359

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

   360

 */

   361

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

   362

{

   363

    // create the new obj

   364

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

   365

   366

    // initialize

   367

    lua_module->module = module;

   368

   369

    // ok

   370

    return 1;

   371

}

   372

   398

static int lua_module_conf (lua_State *L)

   399

{

   400

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

   401

    const struct config_option *option;

   402

    struct config_value value;

   403

    struct error_info err;

   404

   405

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

   406

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

   407

   408

    // the config name

   409

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

   410

   411

    // look it up

   412

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

   413

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

   449

   450

    // apply it

   451

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

   454

    // ok

   455

    return 0;

   456

}

   457

   458

static const struct luaL_Reg lua_module_methods[] = {

   459

    {   "conf",         &lua_module_conf            },

   460

    {   NULL,           NULL                        }

   461

};

   462

   463

/**

   464

 * Initialize the lua_module object type

   465

 */

   466

static void lua_module_init (lua_State *L)

   467

{

   468

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

   469

}

   470

   471

/**

   472

 * Wrapper for modules

   473

 */

   474

struct lua_modules {

   475

    struct modules *modules;

   476

};

   477

   478

static int lua_modules_load (lua_State *L)

   479

{

   480

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

   481

    struct module *module;

   482

    struct module_info info;

   483

    struct error_info err;

   484

   485

    // the module name/path

   486

    info.name = luaL_checkstring(L, 2);

   487

    info.path = luaL_checkstring(L, 3);

   488

   489

    // load

   490

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

   491

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

   492

   493

    // wrap

   494

    return lua_module_create(L, module);