1

#include "lua_irc.h"

     2

#include "lua_func.h"

     3

     4

#include <stdlib.h>

     5

#include <string.h>

     6

     7

static struct lua_type lua_chan_type = LUA_TYPE("evirc.chan");

     8

     9

/**

    10

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

    11

 */

    12

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

    13

{

    14

    // create the new obj

    15

    struct lua_chan *lua_chan = lua_type_create(L, &lua_chan_type, sizeof(*lua_chan));

    16

    17

    // initialize

    18

    lua_chan->chan = chan;

    19

    20

    // ok

    21

    return 1;

    22

}

    23

    24

/**

    25

 * Return the channel name as a lua string

    26

 */

    27

static struct lua_func lua_chan__tostring_func = LUA_FUNC(&lua_chan_type, "__tostring",

    28

        "format using channel name",

    29

    30

        LUA_FUNC_ARG_END

    31

    );

    32

    33

static int lua_chan__tostring (lua_State *L)

    34

{

    35

    struct lua_chan *lua_chan;

    36

    37

    lua_args_parse(L, &lua_chan__tostring_func, (void *) &lua_chan);

    38

    39

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

    40

    41

    return 1;

    42

}

    43

    44

/**

    45

 * Send a PRIVMSG to the channel

    46

 */

    47

static struct lua_func lua_chan_say_func = LUA_FUNC(&lua_chan_type, "evirc.chan.say",

    48

        "send a message to a channel",

    49

    50

        LUA_FUNC_ARG_STRING("message",      LUA_ARG_STRING_REQUIRED )

    51

    );

    52

    53

static int lua_chan_say (lua_State *L)

    54

{

    55

    struct lua_chan *lua_chan;

    56

    err_t err;

    57

    const char *message;

    58

    59

    // parse args

    60

    lua_args_parse(L, &lua_chan_say_func, (void *) &lua_chan,

    61

            &message

    62

        );

    63

    64

    // send

    65

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

    66

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

    67

    68

    // ok

    69

    return 0;

    70

}

    71

    72

static struct lua_method lua_chan_methods[] = LUA_METHODS(

    73

        LUA_METHOD("__tostring",    lua_chan__tostring, &lua_chan__tostring_func    ),

    74

        LUA_METHOD("say",           lua_chan_say,       &lua_chan_say_func          )

    75

    );

    76

    77

    78

    79

static struct lua_type lua_net_type = LUA_TYPE("evirc.net");

    80

    81

/**

    82

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

    83

 */

    84

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

    85

{

    86

    // create the new obj

    87

    struct lua_net *lua_net = lua_type_create(L, &lua_net_type, sizeof(*lua_net));

    88

    89

    // initialize

    90

    lua_net->net = net;

    91

    92

    // ok

    93

    return 1;

    94

}

    95

    96

/**

    97

 * Return the network name as a lua string

    98

 */

    99

static struct lua_func lua_net__tostring_func = LUA_FUNC(&lua_net_type, "__tostring",

   100

        "format using network name",

   101

   102

        LUA_FUNC_ARG_END

   103

    );

   104

   105

static int lua_net__tostring (lua_State *L)

   106

{

   107

    struct lua_net *lua_net;

   108

   109

    lua_args_parse(L, &lua_net__tostring_func, (void *) &lua_net);

   110

   111

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

   112

   113

    return 1;

   114

}

   115

   116

/**

   117

 * Join a new channel, returning the lua_chan

   118

 */

   119

static struct lua_func lua_net_join_func = LUA_FUNC(&lua_net_type, "join",

   120

        "create a new channel and join it",

   121

   122

        LUA_FUNC_ARG_STRING("channel",      LUA_ARG_STRING_REQUIRED)

   123

    );

   124

   125

   126

static int lua_net_join (lua_State *L)

   127

{

   128

    struct lua_net *lua_net;

   129

    struct irc_chan_info chan_info;

   130

    struct irc_chan *chan;

   131

    struct error_info err;

   132

   133

    // the channel name

   134

    lua_args_parse(L, &lua_net_join_func, (void *) &lua_net,

   135

            &chan_info.channel

   136

        );

   137

   138

    // add it

   139

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

   140

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

   141

   142

    // return it

   143

    return lua_chan_create(L, chan);    

   144

}

   145

   146

/**

   147

 * Look up a channel by name, returning the lua_chan

   148

 */

   149

static struct lua_func lua_net_get_chan_func = LUA_FUNC(&lua_net_type, "channel",

   150

        "look up a channel by name",

   151

   152

        LUA_FUNC_ARG_STRING("channel",      LUA_ARG_STRING_REQUIRED)

   153

    );

   154

   155

static int lua_net_get_chan (lua_State *L)

   156

{

   157

    struct lua_net *lua_net;

   158

    struct irc_chan *chan;

   159

    const char *channel;

   160

   161

    // parse args

   162

    lua_args_parse(L, &lua_net_get_chan_func, (void *) &lua_net,

   163

            &channel

   164

        );

   165

   166

    // lookup the irc_chan

   167

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

   168

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

   169

   170

    // wrap it

   171

    return lua_chan_create(L, chan);

   172

}

   173

   174

static struct lua_func lua_net_channels_func = LUA_FUNC(&lua_net_type, "channels",

   175

        "Return an iterater over the network's channels",

   176

   177

        LUA_FUNC_ARG_END

   178

    );

   179

   180

static int lua_net_channels_iter (lua_State *L)

   181

{

   182

    int nargs = lua_gettop(L);

   183

    struct lua_net *lua_net = lua_arg_obj(L, nargs, 1, &lua_net_type, false);

   184

    struct lua_chan *lua_chan = lua_arg_obj(L, nargs, 2, &lua_chan_type, true);

   185

    struct irc_chan *chan_next;

   186

   187

    // get next item from current

   188

    if (lua_chan)

   189

        chan_next = TAILQ_NEXT(lua_chan->chan, net_channels);

   190

    else

   191

        chan_next = TAILQ_FIRST(&lua_net->net->channels);

   192

   193

    // push return value - next item

   194

    if (chan_next)

   195

        lua_chan_create(L, chan_next);

   196

    else

   197

        lua_pushnil(L);

   198

   199

    return 1;

   200

}

   201

   202

static int lua_net_channels (lua_State *L)

   203

{

   204

    struct lua_net *lua_net;

   205

   206

    // parse args

   207

    lua_args_parse(L, &lua_net_channels_func, (void *) &lua_net);

   208

   209

    // push iter func

   210

    lua_pushcfunction(L, lua_net_channels_iter);

   211

   212

    // push invariant state - the lua_net

   213

    lua_pushvalue(L, 1);

   214

   215

    // return iter three-tuple

   216

    return 2;

   217

}

   218

   219

static struct lua_method lua_net_methods[] = LUA_METHODS(

   220

        LUA_METHOD("__tostring",    lua_net__tostring,  &lua_net__tostring_func ),

   221

        LUA_METHOD("join",          lua_net_join,       &lua_net_join_func      ),

   222

        LUA_METHOD("channel",       lua_net_get_chan,   &lua_net_get_chan_func  ),

   223

        LUA_METHOD("channels",      lua_net_channels,   &lua_net_channels_func  )

   224

    );

   225

   226

   227

   228

   229

static struct lua_type lua_client_type = LUA_TYPE("evirc.client");

   230

   231

   232

static struct lua_func lua_client_set_defaults_func = LUA_FUNC(&lua_client_type, "set_defaults", 

   233

        "set the default settings to use for evirc.client.connect",

   234

   235

        LUA_FUNC_ARG_STRING("nickname",     LUA_ARG_STRING_REQUIRED ),

   236

        LUA_FUNC_ARG_STRING("username",     LUA_ARG_STRING_REQUIRED ),

   237

        LUA_FUNC_ARG_STRING("realname",     LUA_ARG_STRING_REQUIRED ),

   238

        LUA_FUNC_ARG_STRING("service",      IRC_PORT                ),

   239

        LUA_FUNC_ARG_STRING("service_ssl",  IRC_SSL_PORT            )

   240

    );

   241

   242

static int lua_client_set_defaults (lua_State *L)

   243

{

   244

    struct lua_client *lua_client;

   245

    const char *nickname, *username, *realname, *service, *service_ssl;

   246

   247

    // parse args

   248

    lua_args_parse(L, &lua_client_set_defaults_func, (void *) &lua_client,

   249

            &nickname, &username, &realname, &service, &service_ssl

   250

        );

   251

   252

    // set

   253

    struct irc_client_defaults defaults = {

   254

        .register_info = {

   255

            .nickname   = nickname,

   256

            .username   = username,

   257

            .realname   = realname

   258

        },

   259

        .service        = service,

   260

        .service_ssl    = service_ssl

   261

    };

   262

   263

    // invoke

   264

    // XXX: needs to be copied

   265

    irc_client_set_defaults(lua_client->client, &defaults);

   266

   267

    // ok

   268

    return 0;

   269

}

   270

   271

static struct lua_func lua_client_connect_func = LUA_FUNC(&lua_client_type, "connect",

   272

        "Create and return a new IRC network",

   273

   274

        LUA_FUNC_ARG_STRING("network",      LUA_ARG_STRING_REQUIRED ),

   275

        LUA_FUNC_ARG_STRING("hostname",     LUA_ARG_STRING_REQUIRED ),

   276

        LUA_FUNC_ARG_STRING("service",      NULL                    ),

   277

        LUA_FUNC_ARG_BOOL(  "ssl",          false                   ),

   278

        LUA_FUNC_ARG_STRING("ssl_cafile",   NULL                    ),

   279

        LUA_FUNC_ARG_BOOL(  "ssl_verify",   false                   ),

   280

        LUA_FUNC_ARG_STRING("ssl_cert",     NULL                    ),

   281

        LUA_FUNC_ARG_STRING("ssl_pkey",     NULL                    )

   282

);

   283

   284

static int lua_client_connect (lua_State *L)

   285

{

   286

    struct lua_client *lua_client;

   287

    struct irc_net_info net_info;

   288

    const char *ssl_cafile = NULL, *ssl_cert = NULL, *ssl_pkey = NULL;

   289

    bool use_ssl = false, ssl_verify = false;

   290

    struct irc_net *net;

   291

    struct error_info err;

   292

   293

    // init net_info

   294

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

   295

   296

    // parse args

   297

    lua_args_parse(L, &lua_client_connect_func, (void *) &lua_client,

   298

        &net_info.network, &net_info.hostname, &net_info.service,

   299

        &use_ssl, &ssl_cafile, &ssl_verify, &ssl_cert, &ssl_pkey

   300

    );

   301

   302

    // SSL?

   303

    if (use_ssl || ssl_cafile || ssl_verify || ssl_cert || ssl_pkey) {

   304

        // verify

   305

        if ((ssl_cert || ssl_pkey) && !(ssl_cert && ssl_pkey))

   306

            return luaL_error(L, "must give both ssl_cert and ssl_pkey");

   307

   308

        // create

   309

        if (ssl_client_cred_create(&net_info.ssl_cred, ssl_cafile, ssl_verify, ssl_cert, ssl_pkey, &err))

   310

            return luaL_error(L, "sock_ssl_client_cred_create(ssl_cafile=%s, ssl_verify=%b, ssl_cert=%s, ssl_pkey=%s): %s", 

   311

                    ssl_cafile, ssl_verify, ssl_cert, ssl_pkey, error_msg(&err)

   312

                );

   313

    }

   314

   315

    // create it

   316

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

   317

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

   318

   319

    // wrap it

   320

    return lua_net_create(L, net);

   321

}

   322

   323

static struct lua_func lua_client_get_network_func = LUA_FUNC(&lua_client_type, "network",

   324

        "Lookup an existing network by name",

   325

   326

        LUA_FUNC_ARG_STRING("network",  LUA_ARG_STRING_REQUIRED)

   327

    );

   328

   329

static int lua_client_get_network (lua_State *L)

   330

{

   331

    struct lua_client *lua_client;

   332

    struct irc_net *net;

   333

    const char *network;

   334

   335

    // parse args

   336

    lua_args_parse(L, &lua_client_get_network_func, (void *) &lua_client,

   337

            &network

   338

        );

   339

   340

    // lookup the irc_net

   341

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

   342

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

   343

   344

    // wrap it

   345

    return lua_net_create(L, net);

   346

}

   347

   348

static struct lua_func lua_client_networks_func = LUA_FUNC(&lua_client_type, "channels",

   349

        "Return an iterator over the client's networks",

   350

   351

        LUA_FUNC_ARG_END

   352

    );

   353

   354

static int lua_client_networks_iter (lua_State *L)

   355

{

   356

    int nargs = lua_gettop(L);

   357

    struct lua_client *lua_client = lua_arg_obj(L, nargs, 1, &lua_client_type, false);

   358

    struct lua_net *lua_net = lua_arg_obj(L, nargs, 2, &lua_net_type, true);

   359

    struct irc_net *net_next;

   360

   361

    if (lua_net)

   362

        // return next

   363

        net_next = TAILQ_NEXT(lua_net->net, client_networks);

   364

    else

   365

        // return first

   366

        net_next = TAILQ_FIRST(&lua_client->client->networks);

   367

   368

    // build and return next value

   369

    if (net_next)

   370

        lua_net_create(L, net_next);

   371

    else

   372

        lua_pushnil(L);

   373

   374

    return 1;

   375

}

   376

   377

static int lua_client_networks (lua_State *L)

   378

{

   379

    struct lua_client *lua_client;

   380

   381

    // parse args

   382

    lua_args_parse(L, &lua_client_networks_func, (void *) &lua_client);

   383

   384

    // push iter func

   385

    lua_pushcfunction(L, lua_client_networks_iter);

   386

   387

    // push invariant state - the lua_client

   388

    lua_pushvalue(L, 1);

   389

   390

    // return three-tuple

   391

    return 2;

   392

}

   393

   394

static struct lua_func lua_client_quit_func = LUA_FUNC(&lua_client_type, "quit",

   395

        "Disconnect from all networks",

   396

   397

        LUA_FUNC_ARG_STRING("message",  "Bye")

   398

    );

   399

   400

static int lua_client_quit (lua_State *L)

   401

{

   402

    struct lua_client *lua_client;

   403

    err_t err;

   404

    const char *message;

   405

   406

    // parse args

   407

    lua_args_parse(L, &lua_client_quit_func, (void *) &lua_client,

   408

            &message

   409

        );

   410

   411

    // execute

   412

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

   413

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

   414

   415

    // ok

   416

    return 0;

   417

}

   418

   419

static struct lua_method lua_client_methods[] = LUA_METHODS(

   420

        LUA_METHOD("set_defaults",  lua_client_set_defaults,    &lua_client_set_defaults_func   ),

   421

        LUA_METHOD("connect",       lua_client_connect,         &lua_client_connect_func        ),

   422

        LUA_METHOD("network",       lua_client_get_network,     &lua_client_get_network_func    ),

   423

        LUA_METHOD("networks",      lua_client_networks,        &lua_client_networks_func       ),

   424

        LUA_METHOD("quit",          lua_client_quit,            &lua_client_quit_func           )

   425

    );

   426

   427

void lua_irc_init (struct nexus_lua *lua)

   428

{

   429

    // register types

   430

    lua_type_register(lua->st, &lua_chan_type, lua_chan_methods);

   431

    lua_type_register(lua->st, &lua_net_type, lua_net_methods);

   432

   433

    // register the global "client" object

   434

    struct lua_client *lua_client = lua_type_register_global(lua->st, &lua_client_type, lua_client_methods, "client", sizeof(*lua_client));

   435

   436

    // initialize it

   437

    lua_client->client = lua->nexus->client;

   438

}

   439