src/luaixp/lixp_instance.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <time.h>
   7 #include <signal.h>
   8
   9 #include <ixp.h>
  10 #include <lua.h>
  11 #include <lauxlib.h>
  12
  13 #include "lixp_debug.h"
  14 #include "lixp_util.h"
  15 #include "lixp_instance.h"
  16
  17
  18 /* ------------------------------------------------------------------------
  19  * utility functions
  20  */
  21
  22 struct ixp *lixp_checkixp (lua_State *L, int narg)
  23 {
  24         void *ud = luaL_checkudata (L, narg, L_IXP_MT);
  25         luaL_argcheck (L, ud != NULL, 1, "`ixp' expected");
  26         return (struct ixp*)ud;
  27 }
  28
  29 int l_ixp_tostring (lua_State *L)
  30 {
  31         struct ixp *ixp = lixp_checkixp (L, 1);
  32         lua_pushfstring (L, "ixp instance %p", ixp);
  33         return 1;
  34 }
  35
  36 static int nil_iter (lua_State *L)
  37 {
  38         return 0;
  39 }
  40
  41 /* ------------------------------------------------------------------------
  42  * lua: write(file, data) -- writes data to a file
  43  */
  44
  45 int l_ixp_write (lua_State *L)
  46 {
  47         struct ixp *ixp;
  48         IxpCFid *fid;
  49         const char *file;
  50         const char *data;
  51         size_t data_len;
  52         int rc;
  53
  54         ixp = lixp_checkixp (L, 1);
  55         file = luaL_checkstring (L, 2);
  56         data = luaL_checklstring (L, 3, &data_len);
  57
  58         fid = ixp_open(ixp->client, file, P9_OWRITE);
  59         if(fid == NULL)
  60                 return lixp_pusherror (L, "count not open p9 file");
  61
  62         DBGF("** ixp.write (%s,%s) **\n", file, data);
  63
  64         rc = lixp_write_data (fid, data, data_len);
  65         if (rc < 0) {
  66                 ixp_close(fid);
  67                 return lixp_pusherror (L, "failed to write to p9 file");
  68         }
  69
  70         ixp_close(fid);
  71         return 0;
  72 }
  73
  74 /* ------------------------------------------------------------------------
  75  * lua: data [,short_read]  = read(file, [max_buffer_size])
  76  *      -- returns contents of file
  77  *
  78  * max_buffer_size limits the read to IXP_READ_MAX_BUFFER_SIZE by default, but
  79  * can be configured to a different value.  Setting max_buffer_size to zero
  80  * means no limit will be applied.
  81  *
  82  * On return data holds the data read, and short_read indicates if there was
  83  * more data that was not read.
  84  *
  85  * If the file contents are expected to be large use l_ixp_iread(), which
  86  * iterates over the file.
  87  */
  88 int l_ixp_read (lua_State *L)
  89 {
  90         struct ixp *ixp;
  91         IxpCFid *fid;
  92         const char *file;
  93         char *buf, *_buf;
  94         size_t buf_ofs, buf_size;
  95         lua_Number max_buffer_size;
  96         size_t realloc_size;
  97         int short_read = 1;
  98
  99         ixp = lixp_checkixp (L, 1);
 100         file = luaL_checkstring (L, 2);
 101         max_buffer_size = luaL_optnumber (L, 3, IXP_READ_MAX_BUFFER_SIZE);
 102
 103         fid = ixp_open(ixp->client, file, P9_OREAD);
 104         if(fid == NULL)
 105                 return lixp_pusherror (L, "count not open p9 file");
 106
 107         buf_size = fid->iounit;
 108         if (max_buffer_size && buf_size > max_buffer_size)
 109                 buf_size = max_buffer_size;
 110         buf = malloc (buf_size);
 111         if (!buf) {
 112                 ixp_close(fid);
 113                 return lixp_pusherror (L, "count not allocate memory");
 114         }
 115         buf_ofs = 0;
 116
 117         DBGF("** ixp.read (%s) **\n", file);
 118
 119         for (;;) {
 120                 int rc = ixp_read (fid, buf+buf_ofs, buf_size-buf_ofs);
 121                 if (rc==0) {
 122                         short_read = 0;
 123                         break;
 124
 125                 } else if (rc<0) {
 126                         ixp_close(fid);
 127                         return lixp_pusherror (L, "failed to read from p9 file");
 128                 }
 129
 130                 buf_ofs += rc;
 131
 132                 if (buf_ofs > buf_size)
 133                         return lixp_pusherror (L, "internal error while reading");
 134
 135                 if (buf_ofs == buf_size)
 136                         break;
 137
 138                 if (max_buffer_size && buf_size >= max_buffer_size)
 139                         break;
 140
 141                 realloc_size = max_buffer_size;
 142                 if (!max_buffer_size)
 143                         realloc_size = buf_size * 2;
 144
 145                 _buf = NULL;
 146                 if (realloc_size > buf_size)
 147                         _buf = realloc (buf, realloc_size);
 148
 149                 if (!_buf) {
 150                         ixp_close(fid);
 151                         free(buf);
 152                         return lixp_pusherrorf(L, "failed to allocate %u bytes",
 153                                         realloc_size);
 154                 }
 155                 buf = _buf;
 156                 buf_size = realloc_size;
 157         }
 158
 159         ixp_close(fid);
 160
 161         if (memchr(buf, '\0', buf_ofs))
 162                 fprintf(stderr, "** WARNING: ixp.read (%s): result contains null characters **\n", file);
 163
 164         lua_pushlstring(L, buf, buf_ofs);
 165         lua_pushboolean(L, short_read);
 166         return 2;
 167 }
 168
 169 /* ------------------------------------------------------------------------
 170  * lua: create(file, [data]) -- create a file, optionally write data to it
 171  */
 172 int l_ixp_create (lua_State *L)
 173 {
 174         struct ixp *ixp;
 175         IxpCFid *fid;
 176         const char *file;
 177         const char *data;
 178         size_t data_len = 0;
 179
 180         ixp = lixp_checkixp (L, 1);
 181         file = luaL_checkstring (L, 2);
 182         data = luaL_optlstring (L, 3, NULL, &data_len);
 183
 184         DBGF("** ixp.create (%s) **\n", file);
 185
 186         fid = ixp_create (ixp->client, file, 0777, P9_OWRITE);
 187         if (!fid)
 188                 return lixp_pusherror (L, "count not create file");
 189
 190         if (data && data_len
 191                         && !(fid->qid.type & P9_DMDIR)) {
 192                 int rc = lixp_write_data (fid, data, data_len);
 193                 if (rc < 0) {
 194                         ixp_close(fid);
 195                         return lixp_pusherror (L, "failed to write to p9 file");
 196                 }
 197         }
 198
 199         ixp_close(fid);
 200         return 0;
 201 }
 202
 203 /* ------------------------------------------------------------------------
 204  * lua: remove(file) -- remove a file
 205  */
 206 int l_ixp_remove (lua_State *L)
 207 {
 208         struct ixp *ixp;
 209         int rc;
 210         const char *file;
 211
 212         ixp = lixp_checkixp (L, 1);
 213         file = luaL_checkstring (L, 2);
 214
 215         DBGF("** ixp.remove (%s) **\n", file);
 216
 217         rc = ixp_remove (ixp->client, file);
 218         if (!rc)
 219                 return lixp_pusherror (L, "failed to remove p9 file");
 220
 221         return 0;
 222 }
 223
 224 /* ------------------------------------------------------------------------
 225  * lua: itr = iread(file) -- returns a line iterator
 226  */
 227
 228 struct l_ixp_iread_s {
 229         IxpCFid *fid;
 230         char *buf;
 231         size_t buf_pos;
 232         size_t buf_len;
 233         size_t buf_size;
 234 };
 235
 236 static int iread_iter (lua_State *L);
 237
 238 int l_ixp_iread (lua_State *L)
 239 {
 240         struct ixp *ixp;
 241         const char *file;
 242         struct l_ixp_iread_s *ctx;
 243
 244         ixp = lixp_checkixp (L, 1);
 245         file = luaL_checkstring (L, 2);
 246
 247         ctx = (struct l_ixp_iread_s*)lua_newuserdata (L, sizeof(*ctx));
 248         if (!ctx) {
 249                 DBGF("** ixp.iread (%s) - count not allocate context", file);
 250                 lua_pushcclosure (L, nil_iter, 1);
 251                 return 1;
 252         }
 253         memset (ctx, 0, sizeof (*ctx));
 254
 255         ctx->fid = ixp_open(ixp->client, file, P9_OREAD);
 256         if(ctx->fid == NULL) {
 257                 DBGF("** ixp.iread (%s) - count not open p9 file", file);
 258                 lua_pushcclosure (L, nil_iter, 1);
 259                 return 1;
 260         }
 261
 262         // set the metatable for the new userdata
 263         luaL_getmetatable (L, L_IXP_IREAD_MT);
 264         lua_setmetatable (L, -2);
 265
 266         DBGF("** ixp.iread (%s) - iterator ready **\n", file);
 267
 268         // create and return the iterator function
 269         // the only argument is the userdata
 270         lua_pushcclosure (L, iread_iter, 1);
 271         return 1;
 272 }
 273
 274 static int iread_iter (lua_State *L)
 275 {
 276         struct l_ixp_iread_s *ctx;
 277         char *s, *cr;
 278
 279         ctx = (struct l_ixp_iread_s*)lua_touserdata (L, lua_upvalueindex(1));
 280
 281         DBGF("** ixp.iread - iter **\n");
 282
 283         if (!ctx->buf) {
 284                 ctx->buf = malloc (ctx->fid->iounit);
 285                 if (!ctx->buf)
 286                         return lixp_pusherror (L, "count not allocate memory");
 287                 ctx->buf_size = ctx->fid->iounit;
 288                 ctx->buf_len = 0;
 289         }
 290
 291         if (!ctx->buf_len) {
 292                 int rc;
 293                 ctx->buf_pos = 0;
 294                 rc = ixp_read (ctx->fid, ctx->buf, ctx->buf_size);
 295                 if (rc <= 0) {
 296                         return 0; // we are done
 297                 }
 298                 ctx->buf_len = rc;
 299         }
 300
 301         s = ctx->buf + ctx->buf_pos;
 302
 303         cr = strchr (s, '\n');
 304         if (!cr) {
 305                 // no match, just return the whole thing
 306                 // TODO: should read more upto a cr or some limit
 307                 if (memchr(s, '\0', ctx->buf_len))
 308                         fprintf(stderr, "** WARNING: ixp.iread - iter: result contains null characters **\n");
 309                 lua_pushlstring (L, s, ctx->buf_len);
 310                 ctx->buf_len = 0;
 311                 return 1;
 312
 313         } else {
 314                 // we have a match s..cr is our sub string
 315                 int len = cr-s;
 316                 if (memchr(s, '\0', len))
 317                         fprintf(stderr, "** WARNING: ixp.iread - iter: result contains null characters **\n");
 318                 lua_pushlstring (L, s, len);
 319                 len++;
 320                 ctx->buf_pos += len;
 321                 ctx->buf_len -= len;
 322                 return 1;
 323         }
 324 }
 325
 326 static int iread_gc (lua_State *L)
 327 {
 328         struct l_ixp_iread_s *ctx;
 329
 330         ctx = (struct l_ixp_iread_s*)lua_touserdata (L, 1);
 331
 332         DBGF("** ixp.iread - gc **\n");
 333
 334         ixp_close (ctx->fid);
 335
 336         if (ctx->buf)
 337                 free (ctx->buf);
 338
 339         return 0;
 340 }
 341
 342 void lixp_init_iread_mt (lua_State *L)
 343 {
 344         luaL_newmetatable(L, L_IXP_IREAD_MT);
 345
 346         // setup the __gc field
 347         lua_pushstring (L, "__gc");
 348         lua_pushcfunction (L, iread_gc);
 349         lua_settable (L, -3);
 350 }
 351
 352 /* ------------------------------------------------------------------------
 353  * lua: stat = stat(file) -- returns a status table
 354  */
 355
 356 int l_ixp_stat (lua_State *L)
 357 {
 358         struct ixp *ixp;
 359         struct IxpStat *stat;
 360         const char *file;
 361         int rc;
 362
 363         ixp = lixp_checkixp (L, 1);
 364         file = luaL_checkstring (L, 2);
 365
 366         DBGF("** ixp.stat (%s) **\n", file);
 367
 368         stat = ixp_stat(ixp->client, file);
 369         if(!stat)
 370                 return lixp_pusherror(L, "cannot stat file");
 371
 372         rc = lixp_pushstat (L, stat);
 373
 374         ixp_freestat (stat);
 375
 376         return rc;
 377 }
 378
 379 /* ------------------------------------------------------------------------
 380  * lua: itr = idir(dir) -- returns a file name iterator
 381  */
 382
 383 struct l_ixp_idir_s {
 384         IxpCFid *fid;
 385         unsigned char *buf;
 386         IxpMsg m;
 387 };
 388
 389 static int idir_iter (lua_State *L);
 390
 391 int l_ixp_idir (lua_State *L)
 392 {
 393         struct ixp *ixp;
 394         const char *file;
 395         struct l_ixp_idir_s *ctx;
 396
 397         ixp = lixp_checkixp (L, 1);
 398         file = luaL_checkstring (L, 2);
 399
 400         DBGF("** ixp.idir (%s) **\n", file);
 401
 402         ctx = (struct l_ixp_idir_s*)lua_newuserdata (L, sizeof(*ctx));
 403         if (!ctx) {
 404                 DBGF("** ixp.idir (%s) - count not allocate context", file);
 405                 lua_pushcclosure (L, nil_iter, 1);
 406                 return 1;
 407         }
 408         memset(ctx, 0, sizeof (*ctx));
 409
 410         ctx->fid = ixp_open(ixp->client, file, P9_OREAD);
 411         if(ctx->fid == NULL) {
 412                 DBGF("** ixp.idir (%s) - count not open p9 file", file);
 413                 lua_pushcclosure (L, nil_iter, 1);
 414                 return 1;
 415         }
 416
 417         ctx->buf = malloc (ctx->fid->iounit);
 418         if (!ctx->buf) {
 419                 ixp_close (ctx->fid);
 420                 ctx->fid = NULL;
 421                 DBGF("** ixp.idir (%s) - count not allocate memory", file);
 422                 lua_pushcclosure (L, nil_iter, 1);
 423                 return 1;
 424         }
 425
 426         // set the metatable for the new userdata
 427         luaL_getmetatable (L, L_IXP_IDIR_MT);
 428         lua_setmetatable (L, -2);
 429
 430         DBGF("** ixp.idir (%s) - iterator ready **\n", file);
 431
 432         // create and return the iterator function
 433         // the only argument is the userdata
 434         lua_pushcclosure (L, idir_iter, 1);
 435         return 1;
 436 }
 437
 438 static int idir_iter (lua_State *L)
 439 {
 440         struct l_ixp_idir_s *ctx;
 441         IxpStat stat;
 442
 443         ctx = (struct l_ixp_idir_s*)lua_touserdata (L, lua_upvalueindex(1));
 444
 445         DBGF("** ixp.idir - iter **\n");
 446
 447         if (ctx->m.pos >= ctx->m.end) {
 448                 int rc = ixp_read (ctx->fid, ctx->buf, ctx->fid->iounit);
 449                 if (rc <= 0) {
 450                         return 0;
 451                 }
 452
 453                 ctx->m = ixp_message(ctx->buf, rc, MsgUnpack);
 454                 if (ctx->m.pos >= ctx->m.end)
 455                         return 0;
 456         }
 457
 458         ixp_pstat(&ctx->m, &stat);
 459
 460         return lixp_pushstat (L, &stat);
 461 }
 462
 463 static int idir_gc (lua_State *L)
 464 {
 465         struct l_ixp_idir_s *ctx;
 466
 467         ctx = (struct l_ixp_idir_s*)lua_touserdata (L, 1);
 468
 469         DBGF("** ixp.idir - gc **\n");
 470
 471         free (ctx->buf);
 472
 473         ixp_close (ctx->fid);
 474
 475         return 0;
 476 }
 477
 478 void lixp_init_idir_mt (lua_State *L)
 479 {
 480         luaL_newmetatable(L, L_IXP_IDIR_MT);
 481
 482         // setup the __gc field
 483         lua_pushstring (L, "__gc");
 484         lua_pushcfunction (L, idir_gc);
 485         lua_settable (L, -3);
 486 }
 487