mpdm_f.c

   1 /*
   2
   3     MPDM - Minimum Profit Data Manager
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     mpdm_f.c - File management
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #ifdef CONFOPT_CANONICALIZE_FILE_NAME
  29 #define _GNU_SOURCE
  30 #endif
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <wchar.h>
  36
  37 #ifdef CONFOPT_UNISTD_H
  38 #include <unistd.h>
  39 #endif
  40
  41 #ifdef CONFOPT_GLOB_H
  42 #include <glob.h>
  43 #endif
  44
  45 #ifdef CONFOPT_WIN32
  46
  47 #include <windows.h>
  48 #include <commctrl.h>
  49 #include <shlobj.h>
  50
  51 #endif
  52
  53 #ifdef CONFOPT_SYS_TYPES_H
  54 #include <sys/types.h>
  55 #endif
  56
  57 #ifdef CONFOPT_SYS_WAIT_H
  58 #include <sys/wait.h>
  59 #endif
  60
  61 #ifdef CONFOPT_SYS_STAT_H
  62 #include <sys/stat.h>
  63 #endif
  64
  65 #ifdef CONFOPT_PWD_H
  66 #include <pwd.h>
  67 #endif
  68
  69 #include "mpdm.h"
  70
  71 #ifdef CONFOPT_ICONV
  72 #include <iconv.h>
  73 #endif
  74
  75 /* file structure */
  76 struct mpdm_file {
  77         FILE *in;
  78         FILE *out;
  79
  80         wchar_t * (* f_read) (const struct mpdm_file *, int *);
  81         int       (* f_write)(const struct mpdm_file *, const wchar_t *);
  82
  83 #ifdef CONFOPT_ICONV
  84         iconv_t ic_enc;
  85         iconv_t ic_dec;
  86 #endif                          /* CONFOPT_ICONV */
  87
  88 #ifdef CONFOPT_WIN32
  89         HANDLE hin;
  90         HANDLE hout;
  91 #endif                          /* CONFOPT_WIN32 */
  92 };
  93
  94 #include <errno.h>
  95 extern int errno;
  96
  97
  98 /*******************
  99         Code
 100 ********************/
 101
 102
 103 static void store_syserr(void)
 104 /* stores the system error inside the global ERRNO */
 105 {
 106         mpdm_hset_s(mpdm_root(), L"ERRNO", MPDM_MBS(strerror(errno)));
 107 }
 108
 109
 110 static int get_char(const struct mpdm_file *f)
 111 /* reads a character from a file structure */
 112 {
 113         int c = EOF;
 114
 115 #ifdef CONFOPT_WIN32
 116
 117         if (f->hin != NULL) {
 118                 char tmp;
 119                 DWORD n;
 120
 121                 if (ReadFile(f->hin, &tmp, 1, &n, NULL) && n > 0)
 122                         c = (int) tmp;
 123         }
 124
 125 #endif                          /* CONFOPT_WIN32 */
 126
 127         if (f->in != NULL) {
 128                 /* read (converting to positive if needed) */
 129                 if ((c = fgetc(f->in)) < 0 && !feof(f->in))
 130                         c += 256;
 131         }
 132
 133         return c;
 134 }
 135
 136
 137 static int put_buf(const char *ptr, int s, const struct mpdm_file *f)
 138 /* writes s bytes in the buffer in ptr to f */
 139 {
 140 #ifdef CONFOPT_WIN32
 141
 142         if (f->hout != NULL) {
 143                 DWORD n;
 144
 145                 if (WriteFile(f->hout, ptr, s, &n, NULL) && n > 0)
 146                         s = n;
 147         }
 148         else
 149 #endif                          /* CONFOPT_WIN32 */
 150
 151         if (f->out != NULL)
 152                 s = fwrite(ptr, s, 1, f->out);
 153
 154         return s;
 155 }
 156
 157
 158 static int put_char(int c, const struct mpdm_file *f)
 159 /* writes a character in a file structure */
 160 {
 161         char tmp = c;
 162
 163         if (put_buf(&tmp, 1, f) != 1)
 164                 c = EOF;
 165
 166         return c;
 167 }
 168
 169
 170 static wchar_t *read_mbs(const struct mpdm_file *f, int *s)
 171 /* reads a multibyte string from a mpdm_file into a dynamic string */
 172 {
 173         wchar_t *ptr = NULL;
 174         char *auxptr = NULL;
 175         char tmp[100];
 176         int c, i = 0, n = 0;
 177
 178         while ((c = get_char(f)) != EOF) {
 179                 tmp[i++] = c;
 180
 181                 if (c == '\n')
 182                         break;
 183
 184                 if (i == sizeof(tmp) - 1) {
 185                         /* out of space; start allocating */
 186                         if ((auxptr = mpdm_poke(auxptr, &n, tmp, i, sizeof(char))) == NULL)
 187                                 return NULL;
 188
 189                         i = 0;
 190                 }
 191         }
 192
 193         /* is there something to return? */
 194         if (i || n) {
 195                 /* NULL-terminate */
 196                 tmp[i++] = '\0';
 197
 198                 if (n) {
 199                         /* auxiliary space used; concat all */
 200                         if ((auxptr = mpdm_poke(auxptr, &n, tmp, i, sizeof(char))) == NULL)
 201                                 return NULL;
 202
 203                         /* do the conversion */
 204                         ptr = mpdm_mbstowcs(auxptr, s, -1);
 205
 206                         free(auxptr);
 207                 }
 208                 else
 209                         ptr = mpdm_mbstowcs(tmp, s, -1);
 210         }
 211
 212         return ptr;
 213 }
 214
 215
 216 static int write_wcs(const struct mpdm_file *f, const wchar_t * str)
 217 /* writes a wide string to an struct mpdm_file */
 218 {
 219         int s;
 220         char *ptr;
 221
 222         ptr = mpdm_wcstombs(str, &s);
 223         s = put_buf(ptr, s, f);
 224         free(ptr);
 225
 226         return s;
 227 }
 228
 229
 230 #ifdef CONFOPT_ICONV
 231
 232 static wchar_t *read_iconv(const struct mpdm_file *f, int *s)
 233 /* reads a multibyte string transforming with iconv */
 234 {
 235         char tmp[128];
 236         wchar_t *ptr = NULL;
 237         int c, i;
 238         wchar_t wc;
 239
 240         *s = i = 0;
 241
 242         /* resets the decoder */
 243         iconv(f->ic_dec, NULL, NULL, NULL, NULL);
 244
 245         while ((c = get_char(f)) != EOF) {
 246                 size_t il, ol;
 247                 char *iptr, *optr;
 248
 249                 tmp[i++] = c;
 250
 251                 /* too big? shouldn't happen */
 252                 if (i == sizeof(tmp))
 253                         break;
 254
 255                 il = i;
 256                 iptr = tmp;
 257                 ol = sizeof(wchar_t);
 258                 optr = (char *) &wc;
 259
 260                 /* write to file */
 261                 if (iconv(f->ic_dec, &iptr, &il, &optr, &ol) == (size_t) -1) {
 262                         /* found incomplete multibyte character */
 263                         if (errno == EINVAL)
 264                                 continue;
 265
 266                         /* otherwise, return '?' */
 267                         wc = L'?';
 268                 }
 269
 270                 i = 0;
 271
 272                 if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 273                         break;
 274
 275                 /* if it's an end of line, finish */
 276                 if (wc == L'\n')
 277                         break;
 278         }
 279
 280         if (ptr != NULL) {
 281                 ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 282                 (*s)--;
 283         }
 284
 285         return ptr;
 286 }
 287
 288
 289 static int write_iconv(const struct mpdm_file *f, const wchar_t * str)
 290 /* writes a wide string to a stream using iconv */
 291 {
 292         char tmp[128];
 293         int cnt = 0;
 294
 295         /* resets the encoder */
 296         iconv(f->ic_enc, NULL, NULL, NULL, NULL);
 297
 298         /* convert char by char */
 299         for (; *str != L'\0'; str++) {
 300                 size_t il, ol;
 301                 char *iptr, *optr;
 302                 int n;
 303
 304                 il = sizeof(wchar_t);
 305                 iptr = (char *) str;
 306                 ol = sizeof(tmp);
 307                 optr = tmp;
 308
 309                 /* write to file */
 310                 if (iconv(f->ic_enc, &iptr, &il, &optr, &ol) == (size_t) -1) {
 311                         /* error converting; convert a '?' instead */
 312                         wchar_t q = L'?';
 313
 314                         il = sizeof(wchar_t);
 315                         iptr = (char *) &q;
 316                         ol = sizeof(tmp);
 317                         optr = tmp;
 318
 319                         iconv(f->ic_enc, &iptr, &il, &optr, &ol);
 320                 }
 321
 322                 for (n = 0; n < (int)(sizeof(tmp) - ol); n++, cnt++) {
 323                         if (put_char(tmp[n], f) == EOF)
 324                                 return -1;
 325                 }
 326         }
 327
 328         return cnt;
 329 }
 330
 331
 332 #endif                          /* CONFOPT_ICONV */
 333
 334 #define UTF8_BYTE() if((c = get_char(f)) == EOF) break
 335
 336 static wchar_t *read_utf8(const struct mpdm_file *f, int *s)
 337 /* crappy, ad-hoc utf8 reader */
 338 {
 339         wchar_t *ptr = NULL;
 340         wchar_t wc;
 341         int c;
 342
 343         *s = 0;
 344
 345         for (;;) {
 346                 wc = L'\0';
 347
 348                 UTF8_BYTE();
 349
 350                 if ((c & 0x80) == 0)
 351                         wc = c;
 352                 else
 353                 if ((c & 0xe0) == 0xe0) {
 354                         wc = (c & 0x1f) << 12;
 355                         UTF8_BYTE();
 356                         wc |= (c & 0x3f) << 6;
 357                         UTF8_BYTE();
 358                         wc |= (c & 0x3f);
 359                 }
 360                 else {
 361                         wc = (c & 0x3f) << 6;
 362                         UTF8_BYTE();
 363                         wc |= (c & 0x3f);
 364                 }
 365
 366                 /* store */
 367                 if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 368                         break;
 369
 370                 /* if it's an end of line, finish */
 371                 if (wc == L'\n')
 372                         break;
 373         }
 374
 375         if (ptr != NULL) {
 376                 ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 377                 (*s)--;
 378         }
 379
 380         return ptr;
 381 }
 382
 383
 384 static int write_utf8(const struct mpdm_file *f, const wchar_t * str)
 385 /* crappy, ad-hoc utf8 writer */
 386 {
 387         int cnt = 0;
 388         wchar_t wc;
 389
 390         /* convert char by char */
 391         for (; (wc = *str) != L'\0'; str++) {
 392                 if (wc < 0x80)
 393                         put_char((int) wc, f);
 394                 else
 395                 if (wc < 0x800) {
 396                         put_char((int) (0xc0 | (wc >> 6)), f);
 397                         put_char((int) (0x80 | (wc & 0x3f)), f);
 398                         cnt++;
 399                 }
 400                 else {
 401                         put_char((int) (0xe0 | (wc >> 12)), f);
 402                         put_char((int) (0x80 | ((wc >> 6) & 0x3f)), f);
 403                         put_char((int) (0x80 | (wc & 0x3f)), f);
 404                         cnt += 2;
 405                 }
 406
 407                 cnt++;
 408         }
 409
 410         return cnt;
 411 }
 412
 413
 414 static wchar_t *read_iso8859_1(const struct mpdm_file *f, int *s)
 415 /* crappy, ad-hoc iso8859-1 reader */
 416 {
 417         wchar_t *ptr = NULL;
 418         wchar_t wc;
 419         int c;
 420
 421         *s = 0;
 422
 423         while ((c = get_char(f)) != EOF) {
 424                 wc = c;
 425
 426                 /* store */
 427                 if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 428                         break;
 429
 430                 /* if it's an end of line, finish */
 431                 if (wc == L'\n')
 432                         break;
 433         }
 434
 435         if (ptr != NULL) {
 436                 ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 437                 (*s)--;
 438         }
 439
 440         return ptr;
 441 }
 442
 443
 444 static int write_iso8859_1(const struct mpdm_file *f, const wchar_t * str)
 445 /* crappy, ad-hoc iso8859-1 writer */
 446 {
 447         int cnt = 0;
 448         wchar_t wc;
 449
 450         /* convert char by char */
 451         for (; (wc = *str) != L'\0'; str++)
 452                 put_char(wc <= 0xff ? (int) wc : '?', f);
 453
 454         return cnt;
 455 }
 456
 457
 458 static wchar_t *read_utf16ae(const struct mpdm_file *f, int *s, int le)
 459 /* utf16 reader, ANY ending */
 460 {
 461         wchar_t *ptr = NULL;
 462         wchar_t wc;
 463         int c1, c2;
 464
 465         *s = 0;
 466
 467         for (;;) {
 468                 wc = L'\0';
 469
 470                 if ((c1 = get_char(f)) == EOF)
 471                         break;
 472
 473                 if ((c2 = get_char(f)) == EOF)
 474                         break;
 475
 476                 if (le)
 477                         wc = c1 | (c2 << 8);
 478                 else
 479                         wc = c2 | (c1 << 8);
 480
 481                 /* store */
 482                 if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 483                         break;
 484
 485                 /* if it's an end of line, finish */
 486                 if (wc == L'\n')
 487                         break;
 488         }
 489
 490         if (ptr != NULL) {
 491                 ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 492                 (*s)--;
 493         }
 494
 495         return ptr;
 496 }
 497
 498
 499 static int write_utf16ae(const struct mpdm_file *f, const wchar_t * str, int le)
 500 /* utf16 writer, ANY ending */
 501 {
 502         int cnt = 0;
 503         wchar_t wc;
 504
 505         /* convert char by char */
 506         for (; (wc = *str) != L'\0'; str++) {
 507
 508                 if (le) {
 509                         put_char(wc & 0xff, f);
 510                         put_char((wc & 0xff00) >> 8, f);
 511                 }
 512                 else {
 513                         put_char((wc & 0xff00) >> 8, f);
 514                         put_char(wc & 0xff, f);
 515                 }
 516         }
 517
 518         return cnt;
 519 }
 520
 521
 522 static wchar_t *read_utf16le(const struct mpdm_file *f, int *s)
 523 {
 524         return read_utf16ae(f, s, 1);
 525 }
 526
 527
 528 static int write_utf16le(const struct mpdm_file *f, const wchar_t * str)
 529 {
 530         return write_utf16ae(f, str, 1);
 531 }
 532
 533
 534 static wchar_t *read_utf16be(const struct mpdm_file *f, int *s)
 535 {
 536         return read_utf16ae(f, s, 0);
 537 }
 538
 539
 540 static int write_utf16be(const struct mpdm_file *f, const wchar_t * str)
 541 {
 542         return write_utf16ae(f, str, 0);
 543 }
 544
 545
 546 static wchar_t *read_utf16(struct mpdm_file *f, int *s)
 547 {
 548         int c1, c2;
 549
 550         f->f_read = NULL;
 551
 552         /* autodetection */
 553         c1 = get_char(f);
 554         c2 = get_char(f);
 555
 556         if (c1 == 0xff && c2 == 0xfe)
 557                 f->f_read = read_utf16le;
 558         else
 559         if (c1 == 0xfe && c2 == 0xff)
 560                 f->f_read = read_utf16be;
 561         else
 562                 return NULL;
 563
 564         return f->f_read(f, s);
 565 }
 566
 567
 568 static int write_utf16(struct mpdm_file *f, const wchar_t * str)
 569 {
 570         /* store the LE signature */
 571         put_char(0xff, f);
 572         put_char(0xfe, f);
 573
 574         /* we're 16le from now on */
 575         f->f_write = write_utf16le;
 576
 577         return f->f_write(f, str);
 578 }
 579
 580
 581 static wchar_t *read_utf32ae(const struct mpdm_file *f, int *s, int le)
 582 /* utf32 reader, ANY ending */
 583 {
 584         wchar_t *ptr = NULL;
 585         wchar_t wc;
 586         int c1, c2, c3, c4;
 587
 588         *s = 0;
 589
 590         for (;;) {
 591                 wc = L'\0';
 592
 593                 if ((c1 = get_char(f)) == EOF)
 594                         break;
 595
 596                 if ((c2 = get_char(f)) == EOF)
 597                         break;
 598
 599                 if ((c3 = get_char(f)) == EOF)
 600                         break;
 601
 602                 if ((c4 = get_char(f)) == EOF)
 603                         break;
 604
 605                 if (le)
 606                         wc = c1 | (c2 << 8) | (c3 << 16) | (c4 << 24);
 607                 else
 608                         wc = c4 | (c3 << 8) | (c2 << 16) | (c1 << 24);
 609
 610                 /* store */
 611                 if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 612                         break;
 613
 614                 /* if it's an end of line, finish */
 615                 if (wc == L'\n')
 616                         break;
 617         }
 618
 619         if (ptr != NULL) {
 620                 ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 621                 (*s)--;
 622         }
 623
 624         return ptr;
 625 }
 626
 627
 628 static int write_utf32ae(const struct mpdm_file *f, const wchar_t * str, int le)
 629 /* utf32 writer, ANY ending */
 630 {
 631         int cnt = 0;
 632         wchar_t wc;
 633
 634         /* convert char by char */
 635         for (; (wc = *str) != L'\0'; str++) {
 636
 637                 if (le) {
 638                         put_char((wc & 0x000000ff), f);
 639                         put_char((wc & 0x0000ff00) >> 8, f);
 640                         put_char((wc & 0x00ff0000) >> 16, f);
 641                         put_char((wc & 0xff000000) >> 24, f);
 642                 }
 643                 else {
 644                         put_char((wc & 0xff000000) >> 24, f);
 645                         put_char((wc & 0x00ff0000) >> 16, f);
 646                         put_char((wc & 0x0000ff00) >> 8, f);
 647                         put_char((wc & 0x000000ff), f);
 648                 }
 649         }
 650
 651         return cnt;
 652 }
 653
 654
 655 static wchar_t *read_utf32le(const struct mpdm_file *f, int *s)
 656 {
 657         return read_utf32ae(f, s, 1);
 658 }
 659
 660
 661 static int write_utf32le(const struct mpdm_file *f, const wchar_t * str)
 662 {
 663         return write_utf32ae(f, str, 1);
 664 }
 665
 666
 667 static wchar_t *read_utf32be(const struct mpdm_file *f, int *s)
 668 {
 669         return read_utf32ae(f, s, 0);
 670 }
 671
 672
 673 static int write_utf32be(const struct mpdm_file *f, const wchar_t * str)
 674 {
 675         return write_utf32ae(f, str, 0);
 676 }
 677
 678
 679 static wchar_t *read_utf32(struct mpdm_file *f, int *s)
 680 {
 681         int c1, c2, c3, c4;
 682
 683         f->f_read = NULL;
 684
 685         /* autodetection */
 686         c1 = get_char(f);
 687         c2 = get_char(f);
 688         c3 = get_char(f);
 689         c4 = get_char(f);
 690
 691         if (c1 == 0xff && c2 == 0xfe && c3 == 0 && c4 == 0)
 692                 f->f_read = read_utf32le;
 693         else
 694         if (c1 == 0 && c2 == 0 && c3 == 0xfe && c4 == 0xff)
 695                 f->f_read = read_utf32be;
 696         else
 697                 return NULL;
 698
 699         return f->f_read(f, s);
 700 }
 701
 702
 703 static int write_utf32(struct mpdm_file *f, const wchar_t * str)
 704 {
 705         /* store the LE signature */
 706         put_char(0xff, f);
 707         put_char(0xfe, f);
 708         put_char(0, f);
 709         put_char(0, f);
 710
 711         /* we're 32le from now on */
 712         f->f_write = write_utf32le;
 713
 714         return f->f_write(f, str);
 715 }
 716
 717
 718 static mpdm_t new_mpdm_file(void)
 719 /* creates a new file value */
 720 {
 721         mpdm_t v = NULL;
 722         struct mpdm_file *fs;
 723         mpdm_t e;
 724
 725         if ((fs = malloc(sizeof(struct mpdm_file))) == NULL)
 726                 return NULL;
 727
 728         memset(fs, '\0', sizeof(struct mpdm_file));
 729
 730         /* default I/O functions */
 731         fs->f_read = read_mbs;
 732         fs->f_write = write_wcs;
 733
 734 #ifdef CONFOPT_ICONV
 735         /* no iconv encodings by default */
 736         fs->ic_enc = fs->ic_dec = (iconv_t) -1;
 737 #endif
 738
 739         if ((v = mpdm_new(MPDM_FILE | MPDM_FREE, fs, sizeof(struct mpdm_file))) == NULL) {
 740                 free(fs);
 741                 return NULL;
 742         }
 743
 744         if ((e = mpdm_hget_s(mpdm_root(), L"ENCODING")) != NULL) {
 745
 746                 wchar_t *enc = mpdm_string(e);
 747
 748 #ifdef CONFOPT_ICONV
 749                 mpdm_t cs = MPDM_2MBS(e->data);
 750
 751                 if ((fs->ic_enc = iconv_open((char *) cs->data, "WCHAR_T")) != (iconv_t) -1 &&
 752                     (fs->ic_dec = iconv_open("WCHAR_T", (char *) cs->data)) != (iconv_t) -1) {
 753
 754                         fs->f_read = read_iconv;
 755                         fs->f_write = write_iconv;
 756
 757                         return v;
 758                 }
 759 #endif                          /* CONFOPT_ICONV */
 760
 761                 if (wcscmp(enc, L"utf-8") == 0) {
 762                         fs->f_read = read_utf8;
 763                         fs->f_write = write_utf8;
 764                 }
 765                 else
 766                 if (wcscmp(enc, L"iso8859-1") == 0) {
 767                         fs->f_read = read_iso8859_1;
 768                         fs->f_write = write_iso8859_1;
 769                 }
 770                 else
 771                 if (wcscmp(enc, L"utf-16le") == 0) {
 772                         fs->f_read = read_utf16le;
 773                         fs->f_write = write_utf16le;
 774                 }
 775                 else
 776                 if (wcscmp(enc, L"utf-16be") == 0) {
 777                         fs->f_read = read_utf16be;
 778                         fs->f_write = write_utf16be;
 779                 }
 780                 else
 781                 if (wcscmp(enc, L"utf-16") == 0) {
 782                         fs->f_read = read_utf16;
 783                         fs->f_write = write_utf16;
 784                 }
 785                 else
 786                 if (wcscmp(enc, L"utf-32le") == 0) {
 787                         fs->f_read = read_utf32le;
 788                         fs->f_write = write_utf32le;
 789                 }
 790                 else
 791                 if (wcscmp(enc, L"utf-32be") == 0) {
 792                         fs->f_read = read_utf32be;
 793                         fs->f_write = write_utf32be;
 794                 }
 795                 else
 796                 if (wcscmp(enc, L"utf-32") == 0) {
 797                         fs->f_read = read_utf32;
 798                         fs->f_write = write_utf32;
 799                 }
 800         }
 801
 802         return v;
 803 }
 804
 805
 806 static void destroy_mpdm_file(mpdm_t v)
 807 /* destroys and file value */
 808 {
 809         struct mpdm_file *fs = (struct mpdm_file *)v->data;
 810
 811         if (fs != NULL) {
 812 #ifdef CONFOPT_ICONV
 813                 if (fs->ic_enc != (iconv_t) - 1) {
 814                         iconv_close(fs->ic_enc);
 815                         fs->ic_enc = (iconv_t) - 1;
 816                 }
 817
 818                 if (fs->ic_dec != (iconv_t) - 1) {
 819                         iconv_close(fs->ic_dec);
 820                         fs->ic_dec = (iconv_t) - 1;
 821                 }
 822 #endif
 823
 824                 free(fs);
 825                 v->data = NULL;
 826         }
 827 }
 828
 829
 830 /** interface **/
 831
 832 wchar_t *mpdm_read_mbs(FILE * f, int *s)
 833 /* reads a multibyte string from a stream into a dynamic string */
 834 {
 835         struct mpdm_file fs;
 836
 837         /* reset the structure */
 838         memset(&fs, '\0', sizeof(fs));
 839         fs.in = f;
 840
 841         return read_mbs(&fs, s);
 842 }
 843
 844
 845 int mpdm_write_wcs(FILE * f, const wchar_t * str)
 846 /* writes a wide string to a stream */
 847 {
 848         struct mpdm_file fs;
 849
 850         /* reset the structure */
 851         memset(&fs, '\0', sizeof(fs));
 852         fs.out = f;
 853
 854         return write_wcs(&fs, str);
 855 }
 856
 857
 858 mpdm_t mpdm_new_f(FILE * f)
 859 /* creates a new file value from a FILE * */
 860 {
 861         mpdm_t v = NULL;
 862
 863         if (f == NULL)
 864                 return NULL;
 865
 866         if ((v = new_mpdm_file()) != NULL) {
 867                 struct mpdm_file *fs = (struct mpdm_file *)v->data;
 868                 fs->in = fs->out = f;
 869         }
 870
 871         return v;
 872 }
 873
 874
 875 /**
 876  * mpdm_open - Opens a file.
 877  * @filename: the file name
 878  * @mode: an fopen-like mode string
 879  *
 880  * Opens a file. If @filename can be open in the specified @mode, an
 881  * mpdm_t value will be returned containing the file descriptor, or NULL
 882  * otherwise.
 883  * [File Management]
 884  */
 885 mpdm_t mpdm_open(const mpdm_t filename, const mpdm_t mode)
 886 {
 887         FILE *f;
 888         mpdm_t fn;
 889         mpdm_t m;
 890
 891         if (filename == NULL || mode == NULL)
 892                 return NULL;
 893
 894         /* convert to mbs,s */
 895         fn = MPDM_2MBS(filename->data);
 896         m = MPDM_2MBS(mode->data);
 897
 898         if ((f = fopen((char *) fn->data, (char *) m->data)) == NULL)
 899                 store_syserr();
 900         else {
 901 #if defined(CONFOPT_SYS_STAT_H) && defined(S_ISDIR) && defined(EISDIR)
 902                 struct stat s;
 903
 904                 /* test if the open file is a directory */
 905                 if (fstat(fileno(f), &s) != -1 && S_ISDIR(s.st_mode)) {
 906                         /* it's a directory; fail */
 907                         errno = EISDIR;
 908                         store_syserr();
 909                         fclose(f);
 910                         f = NULL;
 911                 }
 912 #endif
 913         }
 914
 915         return MPDM_F(f);
 916 }
 917
 918
 919 /**
 920  * mpdm_close - Closes a file descriptor.
 921  * @fd: the value containing the file descriptor
 922  *
 923  * Closes the file descriptor.
 924  * [File Management]
 925  */
 926 mpdm_t mpdm_close(mpdm_t fd)
 927 {
 928         struct mpdm_file *fs = (struct mpdm_file *)fd->data;
 929
 930         if ((fd->flags & MPDM_FILE) && fs != NULL) {
 931                 if (fs->in != NULL)
 932                         fclose(fs->in);
 933
 934                 if (fs->out != fs->in && fs->out != NULL)
 935                         fclose(fs->out);
 936
 937                 destroy_mpdm_file(fd);
 938         }
 939
 940         return NULL;
 941 }
 942
 943
 944 /**
 945  * mpdm_read - Reads a line from a file descriptor.
 946  * @fd: the value containing the file descriptor
 947  *
 948  * Reads a line from @fd. Returns the line, or NULL on EOF.
 949  * [File Management]
 950  * [Character Set Conversion]
 951  */
 952 mpdm_t mpdm_read(const mpdm_t fd)
 953 {
 954         mpdm_t v = NULL;
 955         wchar_t *ptr;
 956         int s;
 957         const struct mpdm_file *fs = fd->data;
 958
 959         if (fs == NULL)
 960                 return NULL;
 961
 962         ptr = fs->f_read(fs, &s);
 963
 964         if (ptr != NULL)
 965                 v = MPDM_ENS(ptr, s);
 966
 967         return v;
 968 }
 969
 970
 971 mpdm_t mpdm_getchar(const mpdm_t fd)
 972 {
 973         int c;
 974         wchar_t tmp[2];
 975         const struct mpdm_file *fs = fd->data;
 976
 977         if (fs == NULL || (c = get_char(fs)) == EOF)
 978                 return NULL;
 979
 980         /* get the char as-is */
 981         tmp[0] = (wchar_t) c;
 982         tmp[1] = L'\0';
 983
 984         return MPDM_S(tmp);
 985 }
 986
 987
 988 mpdm_t mpdm_putchar(const mpdm_t fd, const mpdm_t c)
 989 {
 990         const struct mpdm_file *fs = fd->data;
 991         const wchar_t *ptr = mpdm_string(c);
 992
 993         if (fs == NULL || put_char(*ptr, fs) == -1)
 994                 return NULL;
 995
 996         return c;
 997 }
 998
 999
1000 /**
1001  * mpdm_write - Writes a value into a file.
1002  * @fd: the file descriptor.
1003  * @v: the value to be written.
1004  *
1005  * Writes the @v string value into @fd, using the current encoding.
1006  * [File Management]
1007  * [Character Set Conversion]
1008  */
1009 int mpdm_write(const mpdm_t fd, const mpdm_t v)
1010 {
1011         const struct mpdm_file *fs = fd->data;
1012         int ret = -1;
1013
1014         if (fs == NULL)
1015                 return -1;
1016
1017         ret = fs->f_write(fs, mpdm_string(v));
1018
1019         return ret;
1020 }
1021
1022
1023 int mpdm_fseek(const mpdm_t fd, long offset, int whence)
1024 {
1025         const struct mpdm_file *fs = fd->data;
1026
1027         return fseek(fs->in, offset, whence);
1028 }
1029
1030
1031 long mpdm_ftell(const mpdm_t fd)
1032 {
1033         const struct mpdm_file *fs = fd->data;
1034
1035         return ftell(fs->in);
1036 }
1037
1038
1039 FILE * mpdm_get_filehandle(const mpdm_t fd)
1040 {
1041         FILE * f = NULL;
1042
1043         if (fd->flags & MPDM_FILE) {
1044                 const struct mpdm_file *fs = fd->data;
1045                 f = fs->in;
1046         }
1047
1048         return f;
1049 }
1050
1051
1052 /*
1053 mpdm_t mpdm_bread(mpdm_t fd, int size)
1054 {
1055 }
1056
1057
1058 int mpdm_bwrite(mpdm_tfd, mpdm_t v, int size)
1059 {
1060 }
1061 */
1062
1063
1064 static mpdm_t embedded_encodings(void)
1065 {
1066         mpdm_t e;
1067         wchar_t *e2e[] = {
1068                 L"utf-8",       L"utf-8",
1069                 L"utf8",        NULL,
1070                 L"iso8859-1",   L"iso8859-1",
1071                 L"iso-8859-1",  NULL,
1072                 L"latin1",      NULL,
1073                 L"latin-1",     NULL,
1074                 L"utf-16le",    L"utf-16le",
1075                 L"utf16le",     NULL,
1076                 L"ucs-2le",     NULL,
1077                 L"utf-16be",    L"utf-16be",
1078                 L"utf16be",     NULL,
1079                 L"ucs-2be",     NULL,
1080                 L"utf-16",      L"utf-16",
1081                 L"utf16",       NULL,
1082                 L"ucs-2",       NULL,
1083                 L"ucs2",        NULL,
1084                 L"utf-32le",    L"utf-32le",
1085                 L"utf32le",     NULL,
1086                 L"ucs-4le",     NULL,
1087                 L"utf-32be",    L"utf-32be",
1088                 L"utf32be",     NULL,
1089                 L"ucs-4be",     NULL,
1090                 L"utf-32",      L"utf-32",
1091                 L"utf32",       NULL,
1092                 L"ucs-4",       NULL,
1093                 L"ucs4",        NULL,
1094                 NULL,           NULL
1095         };
1096
1097         if ((e = mpdm_hget_s(mpdm_root(), L"EMBEDDED_ENCODINGS")) == NULL) {
1098                 int n;
1099                 wchar_t *p = NULL;
1100
1101                 e = MPDM_H(0);
1102
1103                 for (n = 0; e2e[n] != NULL; n += 2) {
1104                         mpdm_t v = MPDM_S(e2e[n]);
1105
1106                         if (e2e[n + 1] != NULL)
1107                                 p = e2e[n + 1];
1108
1109                         mpdm_hset(e, v, MPDM_S(p));
1110                         mpdm_hset(e, mpdm_ulc(v, 1), MPDM_S(p));
1111                 }
1112
1113                 mpdm_hset_s(mpdm_root(), L"EMBEDDED_ENCODINGS", e);
1114         }
1115
1116         return e;
1117 }
1118
1119
1120 /**
1121  * mpdm_encoding - Sets the current charset encoding for files.
1122  * @charset: the charset name.
1123  *
1124  * Sets the current charset encoding for files. Future opened
1125  * files will be assumed to be encoded with @charset, which can
1126  * be any of the supported charset names (utf-8, iso-8859-1, etc.),
1127  * and converted on each read / write. If charset is NULL, it
1128  * is reverted to default charset conversion (i.e. the one defined
1129  * in the locale).
1130  * Returns a negative number if @charset is unsupported, or zero
1131  * if no errors were found.
1132  * [File Management]
1133  * [Character Set Conversion]
1134  */
1135 int mpdm_encoding(mpdm_t charset)
1136 {
1137         int ret = -1;
1138         mpdm_t e = embedded_encodings();
1139         mpdm_t v = NULL;
1140
1141         /* NULL encoding? done */
1142         if (charset == NULL) {
1143                 mpdm_hset_s(mpdm_root(), L"ENCODING", NULL);
1144                 return 0;
1145         }
1146
1147 #ifdef CONFOPT_ICONV
1148         {
1149                 iconv_t ic;
1150                 mpdm_t cs = MPDM_2MBS(charset->data);
1151
1152                 /* tries to create an iconv encoder and decoder for this charset */
1153
1154                 if ((ic = iconv_open("WCHAR_T", (char *) cs->data)) == (iconv_t) - 1)
1155                         ret = -1;
1156                 else {
1157                         iconv_close(ic);
1158
1159                         if ((ic = iconv_open((char *) cs->data, "WCHAR_T")) == (iconv_t) - 1)
1160                                 ret = -2;
1161                         else {
1162                                 iconv_close(ic);
1163
1164                                 /* got a valid encoding */
1165                                 v = charset;
1166                                 ret = 0;
1167                         }
1168                 }
1169         }
1170 #endif                          /* CONFOPT_ICONV */
1171
1172         if (ret != 0 && (v = mpdm_hget(e, charset)) != NULL)
1173                 ret = 0;
1174
1175         if (ret == 0)
1176                 mpdm_hset_s(mpdm_root(), L"ENCODING", v);
1177
1178         return ret;
1179 }
1180
1181
1182 /**
1183  * mpdm_unlink - Deletes a file.
1184  * @filename: file name to be deleted
1185  *
1186  * Deletes a file.
1187  * [File Management]
1188  */
1189 int mpdm_unlink(const mpdm_t filename)
1190 {
1191         int ret;
1192         mpdm_t fn;
1193
1194         /* convert to mbs */
1195         fn = MPDM_2MBS(filename->data);
1196
1197         if ((ret = unlink((char *) fn->data)) == -1)
1198                 store_syserr();
1199
1200         return ret;
1201 }
1202
1203
1204 /**
1205  * mpdm_stat - Gives status from a file.
1206  * @filename: file name to get the status from
1207  *
1208  * Returns a 14 element array of the status (permissions, onwer, etc.)
1209  * from the desired @filename, or NULL if the file cannot be accessed.
1210  * (man 2 stat).
1211  *
1212  * The values are: 0, device number of filesystem; 1, inode number;
1213  * 2, file mode; 3, number of hard links to the file; 4, uid; 5, gid;
1214  * 6, device identifier; 7, total size of file in bytes; 8, atime;
1215  * 9, mtime; 10, ctime; 11, preferred block size for system I/O;
1216  * 12, number of blocks allocated and 13, canonicalized file name.
1217  * Not all elements have necesarily meaningful values, as most are
1218  * system-dependent.
1219  * [File Management]
1220  */
1221 mpdm_t mpdm_stat(const mpdm_t filename)
1222 {
1223         mpdm_t r = NULL;
1224
1225 #ifdef CONFOPT_SYS_STAT_H
1226         struct stat s;
1227         mpdm_t fn;
1228
1229         fn = MPDM_2MBS(filename->data);
1230
1231         if (stat((char *) fn->data, &s) != -1) {
1232                 r = MPDM_A(14);
1233
1234                 mpdm_aset(r, MPDM_I(s.st_dev), 0);
1235                 mpdm_aset(r, MPDM_I(s.st_ino), 1);
1236                 mpdm_aset(r, MPDM_I(s.st_mode), 2);
1237                 mpdm_aset(r, MPDM_I(s.st_nlink), 3);
1238                 mpdm_aset(r, MPDM_I(s.st_uid), 4);
1239                 mpdm_aset(r, MPDM_I(s.st_gid), 5);
1240                 mpdm_aset(r, MPDM_I(s.st_rdev), 6);
1241                 mpdm_aset(r, MPDM_I(s.st_size), 7);
1242                 mpdm_aset(r, MPDM_I(s.st_atime), 8);
1243                 mpdm_aset(r, MPDM_I(s.st_mtime), 9);
1244                 mpdm_aset(r, MPDM_I(s.st_ctime), 10);
1245                 mpdm_aset(r, MPDM_I(0), 11);    /* s.st_blksize */
1246                 mpdm_aset(r, MPDM_I(0), 12);    /* s.st_blocks */
1247
1248 #ifdef CONFOPT_CANONICALIZE_FILE_NAME
1249
1250                 {
1251                         char * ptr;
1252
1253                         if ((ptr = canonicalize_file_name(
1254                                 (char *)fn->data)) != NULL) {
1255                                 mpdm_aset(r, MPDM_MBS(ptr), 13);
1256                                 free(ptr);
1257                         }
1258                 }
1259 #endif
1260
1261 #ifdef CONFOPT_REALPATH
1262                 {
1263                         char tmp[2048];
1264
1265                         if (realpath((char *)fn->data, tmp) != NULL)
1266                                 mpdm_aset(r, MPDM_MBS(tmp), 13);
1267                 }
1268 #endif
1269
1270         }
1271         else
1272                 store_syserr();
1273
1274 #endif                          /* CONFOPT_SYS_STAT_H */
1275
1276         return r;
1277 }
1278
1279
1280 /**
1281  * mpdm_chmod - Changes a file's permissions.
1282  * @filename: the file name
1283  * @perms: permissions (element 2 from mpdm_stat())
1284  *
1285  * Changes the permissions for a file.
1286  * [File Management]
1287  */
1288 int mpdm_chmod(const mpdm_t filename, mpdm_t perms)
1289 {
1290         int r = -1;
1291
1292         mpdm_t fn = MPDM_2MBS(filename->data);
1293
1294         if ((r = chmod((char *) fn->data, mpdm_ival(perms))) == -1)
1295                 store_syserr();
1296
1297         return r;
1298 }
1299
1300
1301 /**
1302  * mpdm_chown - Changes a file's owner.
1303  * @filename: the file name
1304  * @uid: user id (element 4 from mpdm_stat())
1305  * @gid: group id (element 5 from mpdm_stat())
1306  *
1307  * Changes the owner and group id's for a file.
1308  * [File Management]
1309  */
1310 int mpdm_chown(const mpdm_t filename, mpdm_t uid, mpdm_t gid)
1311 {
1312         int r = -1;
1313
1314 #ifdef CONFOPT_CHOWN
1315
1316         mpdm_t fn = MPDM_2MBS(filename->data);
1317
1318         if ((r = chown((char *) fn->data, mpdm_ival(uid), mpdm_ival(gid))) == -1)
1319                 store_syserr();
1320
1321 #endif                          /* CONFOPT_CHOWN */
1322
1323         return r;
1324 }
1325
1326
1327 /**
1328  * mpdm_glob - Executes a file globbing.
1329  * @spec: Globbing spec
1330  *
1331  * Executes a file globbing. @spec is system-dependent, but usually
1332  * the * and ? metacharacters work everywhere. @spec can contain a
1333  * directory; if that's the case, the output strings will include it.
1334  * In any case, each returned value will be suitable for a call to
1335  * mpdm_open().
1336  *
1337  * Returns an array of files that match the globbing (can be an empty
1338  * array if no file matches), or NULL if globbing is unsupported.
1339  * [File Management]
1340  */
1341 mpdm_t mpdm_glob(const mpdm_t spec)
1342 {
1343         mpdm_t d = NULL;
1344         mpdm_t f = NULL;
1345         mpdm_t v = NULL;
1346
1347 #ifdef CONFOPT_WIN32
1348
1349         WIN32_FIND_DATA fd;
1350         HANDLE h;
1351         char *ptr;
1352         mpdm_t w;
1353         mpdm_t s = NULL;
1354
1355         mpdm_t sp;
1356
1357         /* convert to mbs */
1358         if (spec != NULL)
1359                 sp = MPDM_2MBS(spec->data);
1360         else
1361                 sp = MPDM_2MBS(L"*.*");
1362
1363         ptr = (char *) sp->data;
1364
1365         /* convert MSDOS dir separators into Unix ones */
1366         for (; *ptr != '\0'; ptr++) {
1367                 if (*ptr == '\\')
1368                         *ptr = '/';
1369         }
1370
1371         v = MPDM_A(0);
1372         d = MPDM_A(0);
1373         f = MPDM_A(0);
1374
1375         if ((h = FindFirstFile((char *) sp->data, &fd)) != INVALID_HANDLE_VALUE) {
1376                 /* if spec includes a directory, store in s */
1377                 if ((ptr = strrchr((char *) sp->data, '/')) != NULL) {
1378                         *(ptr + 1) = '\0';
1379                         s = MPDM_MBS(sp->data);
1380                 }
1381
1382                 do {
1383                         /* ignore . and .. */
1384                         if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
1385                                 continue;
1386
1387                         /* concat base directory and file names */
1388                         w = mpdm_strcat(s, MPDM_MBS(fd.cFileName));
1389
1390                         /* if it's a directory, add a / */
1391                         if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1392                                 w = mpdm_strcat(w, MPDM_LS(L"/"));
1393                                 mpdm_push(d, w);
1394                         }
1395                         else
1396                                 mpdm_push(f, w);
1397                 }
1398                 while (FindNextFile(h, &fd));
1399
1400                 FindClose(h);
1401         }
1402
1403 #endif
1404
1405 #if CONFOPT_GLOB_H
1406
1407         /* glob.h support */
1408         glob_t globbuf;
1409         const char *ptr;
1410
1411         /* convert to mbs */
1412         if (spec != NULL) {
1413                 mpdm_t sp = MPDM_2MBS(spec->data);
1414
1415                 ptr = sp->data;
1416                 if (ptr == NULL || *ptr == '\0')
1417                         ptr = "*";
1418         }
1419         else
1420                 ptr = "*";
1421
1422         globbuf.gl_offs = 1;
1423
1424         v = MPDM_A(0);
1425         d = MPDM_A(0);
1426         f = MPDM_A(0);
1427
1428         if (glob(ptr, GLOB_MARK, NULL, &globbuf) == 0) {
1429                 int n;
1430
1431                 for (n = 0; globbuf.gl_pathv[n] != NULL; n++) {
1432                         char *ptr = globbuf.gl_pathv[n];
1433                         mpdm_t t = MPDM_MBS(ptr);
1434
1435                         /* if last char is /, add to directories */
1436                         if (ptr[strlen(ptr) - 1] == '/')
1437                                 mpdm_push(d, t);
1438                         else
1439                                 mpdm_push(f, t);
1440                 }
1441         }
1442
1443         globfree(&globbuf);
1444
1445 #else
1446
1447         /* no win32 nor glob.h; try workaround */
1448         /* ... */
1449
1450 #endif
1451
1452         if (v != NULL) {
1453                 int n;
1454
1455                 d = mpdm_sort(d, 1);
1456                 f = mpdm_sort(f, 1);
1457
1458                 /* transfer all data in d and f */
1459                 for (n = 0; n < mpdm_size(d); n++)
1460                         mpdm_push(v, mpdm_aget(d, n));
1461                 for (n = 0; n < mpdm_size(f); n++)
1462                         mpdm_push(v, mpdm_aget(f, n));
1463         }
1464
1465         return v;
1466 }
1467
1468
1469 #ifdef CONFOPT_WIN32
1470
1471 static void win32_pipe(HANDLE * h, int n)
1472 {
1473         SECURITY_ATTRIBUTES sa;
1474         HANDLE cp, t;
1475
1476         memset(&sa, '\0', sizeof(sa));
1477         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1478         sa.bInheritHandle = TRUE;
1479         sa.lpSecurityDescriptor = NULL;
1480
1481         cp = GetCurrentProcess();
1482
1483         CreatePipe(&h[0], &h[1], &sa, 0);
1484         DuplicateHandle(cp, h[n], cp, &t, 0, FALSE, DUPLICATE_SAME_ACCESS);
1485         CloseHandle(h[n]);
1486         h[n] = t;
1487 }
1488
1489
1490 static int sysdep_popen(mpdm_t v, char *prg, int rw)
1491 /* win32-style pipe */
1492 {
1493         HANDLE pr[2];
1494         HANDLE pw[2];
1495         PROCESS_INFORMATION pi;
1496         STARTUPINFO si;
1497         int ret;
1498         struct mpdm_file *fs = v->data;
1499
1500         /* init all */
1501         pr[0] = pr[1] = pw[0] = pw[1] = NULL;
1502
1503         if (rw & 0x01)
1504                 win32_pipe(pr, 0);
1505         if (rw & 0x02)
1506                 win32_pipe(pw, 1);
1507
1508         /* spawn new process */
1509         memset(&pi, '\0', sizeof(pi));
1510         memset(&si, '\0', sizeof(si));
1511
1512         si.cb = sizeof(STARTUPINFO);
1513         si.hStdError = pr[1];
1514         si.hStdOutput = pr[1];
1515         si.hStdInput = pw[0];
1516         si.dwFlags |= STARTF_USESTDHANDLES;
1517
1518         ret = CreateProcess(NULL, prg, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
1519
1520         if (rw & 0x01)
1521                 CloseHandle(pr[1]);
1522         if (rw & 0x02)
1523                 CloseHandle(pw[0]);
1524
1525         fs->hin = pr[0];
1526         fs->hout = pw[1];
1527
1528         return ret;
1529 }
1530
1531
1532 static int sysdep_pclose(const mpdm_t v)
1533 {
1534         const struct mpdm_file *fs = v->data;
1535
1536         if (fs->hin != NULL)
1537                 CloseHandle(fs->hin);
1538
1539         if (fs->hout != NULL)
1540                 CloseHandle(fs->hout);
1541
1542         /* how to know process exit code? */
1543         return 0;
1544 }
1545
1546
1547 #else                           /* CONFOPT_WIN32 */
1548
1549 static int sysdep_popen(mpdm_t v, char *prg, int rw)
1550 /* unix-style pipe open */
1551 {
1552         int pr[2], pw[2];
1553         struct mpdm_file *fs = (struct mpdm_file *)v->data;
1554
1555         /* init all */
1556         pr[0] = pr[1] = pw[0] = pw[1] = -1;
1557
1558         if (rw & 0x01)
1559                 pipe(pr);
1560         if (rw & 0x02)
1561                 pipe(pw);
1562
1563         if (fork() == 0) {
1564                 /* child process */
1565                 if (rw & 0x01) {
1566                         close(1);
1567                         dup(pr[1]);
1568                         close(pr[0]);
1569                 }
1570                 if (rw & 0x02) {
1571                         close(0);
1572                         dup(pw[0]);
1573                         close(pw[1]);
1574                 }
1575
1576                 /* redirect stderr to stdout */
1577                 close(2);
1578                 dup(1);
1579
1580                 /* run the program */
1581                 execlp("/bin/sh", "/bin/sh", "-c", prg, NULL);
1582                 execlp(prg, prg, NULL);
1583
1584                 /* still here? exec failed; close pipes and exit */
1585                 close(0);
1586                 close(1);
1587                 exit(0);
1588         }
1589
1590         /* create the pipes as non-buffered streams */
1591         if (rw & 0x01) {
1592                 fs->in = fdopen(pr[0], "r");
1593                 setvbuf(fs->in, NULL, _IONBF, 0);
1594                 close(pr[1]);
1595         }
1596
1597         if (rw & 0x02) {
1598                 fs->out = fdopen(pw[1], "w");
1599                 setvbuf(fs->out, NULL, _IONBF, 0);
1600                 close(pw[0]);
1601         }
1602
1603         return 1;
1604 }
1605
1606
1607 static int sysdep_pclose(const mpdm_t v)
1608 /* unix-style pipe close */
1609 {
1610         int s;
1611         const struct mpdm_file *fs = v->data;
1612
1613         if (fs->in != NULL)
1614                 fclose(fs->in);
1615
1616         if (fs->out != fs->in && fs->out != NULL)
1617                 fclose(fs->out);
1618
1619         wait(&s);
1620
1621         return s;
1622 }
1623
1624
1625 #endif                          /* CONFOPT_WIN32 */
1626
1627
1628 /**
1629  * mpdm_popen - Opens a pipe.
1630  * @prg: the program to pipe
1631  * @mode: an fopen-like mode string
1632  *
1633  * Opens a pipe to a program. If @prg can be open in the specified @mode, an
1634  * mpdm_t value will be returned containing the file descriptor, or NULL
1635  * otherwise.
1636  * [File Management]
1637  */
1638 mpdm_t mpdm_popen(const mpdm_t prg, const mpdm_t mode)
1639 {
1640         mpdm_t v, pr, md;
1641         char *m;
1642         int rw = 0;
1643
1644         if (prg == NULL || mode == NULL)
1645                 return NULL;
1646
1647         if ((v = new_mpdm_file()) == NULL)
1648                 return NULL;
1649
1650         /* convert to mbs,s */
1651         pr = MPDM_2MBS(prg->data);
1652         md = MPDM_2MBS(mode->data);
1653
1654         /* get the mode */
1655         m = (char *) md->data;
1656
1657         /* set the mode */
1658         if (m[0] == 'r')
1659                 rw = 0x01;
1660         if (m[0] == 'w')
1661                 rw = 0x02;
1662         if (m[1] == '+')
1663                 rw = 0x03;      /* r+ or w+ */
1664
1665         if (!sysdep_popen(v, (char *) pr->data, rw)) {
1666                 destroy_mpdm_file(v);
1667                 v = NULL;
1668         }
1669
1670         return v;
1671 }
1672
1673
1674 /**
1675  * mpdm_pclose - Closes a pipe.
1676  * @fd: the value containing the file descriptor
1677  *
1678  * Closes a pipe.
1679  * [File Management]
1680  */
1681 mpdm_t mpdm_pclose(mpdm_t fd)
1682 {
1683         mpdm_t r = NULL;
1684
1685         if ((fd->flags & MPDM_FILE) && fd->data != NULL) {
1686                 r = MPDM_I(sysdep_pclose(fd));
1687                 destroy_mpdm_file(fd);
1688         }
1689
1690         return r;
1691 }
1692
1693
1694 /**
1695  * mpdm_home_dir - Returns the home user directory.
1696  *
1697  * Returns a system-dependent directory where the user can write
1698  * documents and create subdirectories.
1699  * [File Management]
1700  */
1701 mpdm_t mpdm_home_dir(void)
1702 {
1703         mpdm_t r = NULL;
1704         char *ptr;
1705         char tmp[512] = "";
1706
1707 #ifdef CONFOPT_WIN32
1708
1709         LPITEMIDLIST pidl;
1710
1711         /* get the 'My Documents' folder */
1712         SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl);
1713         SHGetPathFromIDList(pidl, tmp);
1714         strcat(tmp, "\\");
1715
1716 #endif
1717
1718 #ifdef CONFOPT_PWD_H
1719
1720         struct passwd *p;
1721
1722         /* get home dir from /etc/passwd entry */
1723         if (tmp[0] == '\0' && (p = getpwuid(getpid())) != NULL) {
1724                 strcpy(tmp, p->pw_dir);
1725                 strcat(tmp, "/");
1726         }
1727
1728 #endif
1729
1730         /* still none? try the ENV variable $HOME */
1731         if (tmp[0] == '\0' && (ptr = getenv("HOME")) != NULL) {
1732                 strcpy(tmp, ptr);
1733                 strcat(tmp, "/");
1734         }
1735
1736         if (tmp[0] != '\0')
1737                 r = MPDM_MBS(tmp);
1738
1739         return r;
1740 }
1741
1742
1743 /**
1744  * mpdm_app_dir - Returns the applications directory.
1745  *
1746  * Returns a system-dependent directory where the applications store
1747  * their private data, as components or resources.
1748  * [File Management]
1749  */
1750 mpdm_t mpdm_app_dir(void)
1751 {
1752         mpdm_t r = NULL;
1753
1754 #ifdef CONFOPT_WIN32
1755
1756         HKEY hkey;
1757         char tmp[MAX_PATH];
1758         LPITEMIDLIST pidl;
1759
1760         /* get the 'Program Files' folder (can fail) */
1761         tmp[0] = '\0';
1762         if (SHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidl) == S_OK)
1763                 SHGetPathFromIDList(pidl, tmp);
1764
1765         /* if it's still empty, get from the registry */
1766         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
1767                          "SOFTWARE\\Microsoft\\Windows\\CurrentVersion",
1768                          0, KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) {
1769                 int n = sizeof(tmp);
1770
1771                 if (RegQueryValueEx(hkey, "ProgramFilesDir",
1772                                     NULL, NULL, tmp, (LPDWORD) & n) != ERROR_SUCCESS)
1773                         tmp[0] = '\0';
1774         }
1775
1776         if (tmp[0] != '\0') {
1777                 strcat(tmp, "\\");
1778                 r = MPDM_MBS(tmp);
1779         }
1780 #endif
1781
1782         /* still none? get the configured directory */
1783         if (r == NULL)
1784                 r = MPDM_MBS(CONFOPT_PREFIX "/share/");
1785
1786         return r;
1787 }