mpdm_f.c

   1 /*
   2
   3     MPDM - Minimum Profit Data Manager
   4     Copyright (C) 2003/2010 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) (struct mpdm_file *, int *);
  81     int (*f_write) (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 /** code **/
  99
 100
 101 static void store_syserr(void)
 102 /* stores the system error inside the global ERRNO */
 103 {
 104     mpdm_hset_s(mpdm_root(), L"ERRNO", MPDM_MBS(strerror(errno)));
 105 }
 106
 107
 108 static int get_char(struct mpdm_file *f)
 109 /* reads a character from a file structure */
 110 {
 111     int c = EOF;
 112
 113 #ifdef CONFOPT_WIN32
 114
 115     if (f->hin != NULL) {
 116         char tmp;
 117         DWORD n;
 118
 119         if (ReadFile(f->hin, &tmp, 1, &n, NULL) && n > 0)
 120             c = (int) tmp;
 121     }
 122
 123 #endif                          /* CONFOPT_WIN32 */
 124
 125     if (f->in != NULL) {
 126         /* read (converting to positive if needed) */
 127         if ((c = fgetc(f->in)) < 0 && !feof(f->in))
 128             c += 256;
 129     }
 130
 131     return c;
 132 }
 133
 134
 135 static int put_buf(const char *ptr, int s, struct mpdm_file *f)
 136 /* writes s bytes in the buffer in ptr to f */
 137 {
 138 #ifdef CONFOPT_WIN32
 139
 140     if (f->hout != NULL) {
 141         DWORD n;
 142
 143         if (WriteFile(f->hout, ptr, s, &n, NULL) && n > 0)
 144             s = n;
 145     }
 146     else
 147 #endif                          /* CONFOPT_WIN32 */
 148
 149     if (f->out != NULL)
 150         s = fwrite(ptr, s, 1, f->out);
 151
 152     return s;
 153 }
 154
 155
 156 static int put_char(int c, struct mpdm_file *f)
 157 /* writes a character in a file structure */
 158 {
 159     char tmp = c;
 160
 161     if (put_buf(&tmp, 1, f) != 1)
 162         c = EOF;
 163
 164     return c;
 165 }
 166
 167
 168 static wchar_t *read_mbs(struct mpdm_file *f, int *s)
 169 /* reads a multibyte string from a mpdm_file into a dynamic string */
 170 {
 171     wchar_t *ptr = NULL;
 172     char *auxptr = NULL;
 173     char tmp[100];
 174     int c, i = 0, n = 0;
 175
 176     while ((c = get_char(f)) != EOF) {
 177         tmp[i++] = c;
 178
 179         if (c == '\n')
 180             break;
 181
 182         if (i == sizeof(tmp) - 1) {
 183             /* out of space; start allocating */
 184             if ((auxptr =
 185                  mpdm_poke(auxptr, &n, tmp, i, sizeof(char))) == NULL)
 186                 return NULL;
 187
 188             i = 0;
 189         }
 190     }
 191
 192     /* is there something to return? */
 193     if (i || n) {
 194         /* NULL-terminate */
 195         tmp[i++] = '\0';
 196
 197         if (n) {
 198             /* auxiliary space used; concat all */
 199             if ((auxptr =
 200                  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(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(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(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(struct mpdm_file *f, int *s)
 337 /* 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(struct mpdm_file *f, const wchar_t * str)
 385 /* 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_utf8_bom(struct mpdm_file *f, int *s)
 415 /* utf-8 reader with BOM detection */
 416 {
 417     wchar_t *enc = L"";
 418
 419     f->f_read = NULL;
 420
 421     /* autodetection */
 422     if (get_char(f) == 0xef && get_char(f) == 0xbb && get_char(f) == 0xbf)
 423         enc = L"utf-8bom";
 424     else {
 425         enc = L"utf-8";
 426         fseek(f->in, 0, SEEK_SET);
 427     }
 428
 429     mpdm_hset_s(mpdm_root(), L"DETECTED_ENCODING", MPDM_LS(enc));
 430
 431     /* we're utf-8 from now on */
 432     f->f_read = read_utf8;
 433
 434     return f->f_read(f, s);
 435 }
 436
 437
 438 static int write_utf8_bom(struct mpdm_file *f, const wchar_t * str)
 439 /* utf-8 writer with BOM */
 440 {
 441     /* store the BOM */
 442     put_char(0xef, f);
 443     put_char(0xbb, f);
 444     put_char(0xbf, f);
 445
 446     /* we're utf-8 from now on */
 447     f->f_write = write_utf8;
 448
 449     return f->f_write(f, str);
 450 }
 451
 452
 453 static wchar_t *read_iso8859_1(struct mpdm_file *f, int *s)
 454 /* iso8859-1 reader */
 455 {
 456     wchar_t *ptr = NULL;
 457     wchar_t wc;
 458     int c;
 459
 460     *s = 0;
 461
 462     while ((c = get_char(f)) != EOF) {
 463         wc = c;
 464
 465         /* store */
 466         if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 467             break;
 468
 469         /* if it's an end of line, finish */
 470         if (wc == L'\n')
 471             break;
 472     }
 473
 474     if (ptr != NULL) {
 475         ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 476         (*s)--;
 477     }
 478
 479     return ptr;
 480 }
 481
 482
 483 static int write_iso8859_1(struct mpdm_file *f, const wchar_t * str)
 484 /* iso8859-1 writer */
 485 {
 486     int cnt = 0;
 487     wchar_t wc;
 488
 489     /* convert char by char */
 490     for (; (wc = *str) != L'\0'; str++)
 491         put_char(wc <= 0xff ? (int) wc : '?', f);
 492
 493     return cnt;
 494 }
 495
 496
 497 static wchar_t *read_utf16ae(struct mpdm_file *f, int *s, int le)
 498 /* utf16 reader, ANY ending */
 499 {
 500     wchar_t *ptr = NULL;
 501     wchar_t wc;
 502     int c1, c2;
 503
 504     *s = 0;
 505
 506     for (;;) {
 507         wc = L'\0';
 508
 509         if ((c1 = get_char(f)) == EOF)
 510             break;
 511
 512         if ((c2 = get_char(f)) == EOF)
 513             break;
 514
 515         if (le)
 516             wc = c1 | (c2 << 8);
 517         else
 518             wc = c2 | (c1 << 8);
 519
 520         /* store */
 521         if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 522             break;
 523
 524         /* if it's an end of line, finish */
 525         if (wc == L'\n')
 526             break;
 527     }
 528
 529     if (ptr != NULL) {
 530         ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 531         (*s)--;
 532     }
 533
 534     return ptr;
 535 }
 536
 537
 538 static int write_utf16ae(struct mpdm_file *f, const wchar_t * str, int le)
 539 /* utf16 writer, ANY ending */
 540 {
 541     int cnt = 0;
 542     wchar_t wc;
 543
 544     /* convert char by char */
 545     for (; (wc = *str) != L'\0'; str++) {
 546
 547         if (le) {
 548             put_char(wc & 0xff, f);
 549             put_char((wc & 0xff00) >> 8, f);
 550         }
 551         else {
 552             put_char((wc & 0xff00) >> 8, f);
 553             put_char(wc & 0xff, f);
 554         }
 555     }
 556
 557     return cnt;
 558 }
 559
 560
 561 static wchar_t *read_utf16le(struct mpdm_file *f, int *s)
 562 {
 563     return read_utf16ae(f, s, 1);
 564 }
 565
 566
 567 static int write_utf16le(struct mpdm_file *f, const wchar_t * str)
 568 {
 569     return write_utf16ae(f, str, 1);
 570 }
 571
 572
 573 static wchar_t *read_utf16be(struct mpdm_file *f, int *s)
 574 {
 575     return read_utf16ae(f, s, 0);
 576 }
 577
 578
 579 static int write_utf16be(struct mpdm_file *f, const wchar_t * str)
 580 {
 581     return write_utf16ae(f, str, 0);
 582 }
 583
 584
 585 static wchar_t *read_utf16(struct mpdm_file *f, int *s)
 586 {
 587     int c1, c2;
 588     wchar_t *enc = L"utf-16le";
 589
 590     /* assume little-endian */
 591     f->f_read = read_utf16le;
 592
 593     /* autodetection */
 594     c1 = get_char(f);
 595     c2 = get_char(f);
 596
 597     if (c1 == 0xfe && c2 == 0xff) {
 598         enc = L"utf-16be";
 599         f->f_read = read_utf16be;
 600     }
 601     else
 602     if (c1 != 0xff || c2 != 0xfe) {
 603         /* no BOM; rewind and hope */
 604         fseek(f->in, 0, SEEK_SET);
 605     }
 606
 607     mpdm_hset_s(mpdm_root(), L"DETECTED_ENCODING", MPDM_LS(enc));
 608
 609     return f->f_read(f, s);
 610 }
 611
 612
 613 static int write_utf16le_bom(struct mpdm_file *f, const wchar_t * str)
 614 {
 615     /* store the LE signature */
 616     put_char(0xff, f);
 617     put_char(0xfe, f);
 618
 619     /* we're 16le from now on */
 620     f->f_write = write_utf16le;
 621
 622     return f->f_write(f, str);
 623 }
 624
 625
 626 static int write_utf16be_bom(struct mpdm_file *f, const wchar_t * str)
 627 {
 628     /* store the BE signature */
 629     put_char(0xfe, f);
 630     put_char(0xff, f);
 631
 632     /* we're 16be from now on */
 633     f->f_write = write_utf16be;
 634
 635     return f->f_write(f, str);
 636 }
 637
 638
 639 static wchar_t *read_utf32ae(struct mpdm_file *f, int *s, int le)
 640 /* utf32 reader, ANY ending */
 641 {
 642     wchar_t *ptr = NULL;
 643     wchar_t wc;
 644     int c1, c2, c3, c4;
 645
 646     *s = 0;
 647
 648     for (;;) {
 649         wc = L'\0';
 650
 651         if ((c1 = get_char(f)) == EOF)
 652             break;
 653
 654         if ((c2 = get_char(f)) == EOF)
 655             break;
 656
 657         if ((c3 = get_char(f)) == EOF)
 658             break;
 659
 660         if ((c4 = get_char(f)) == EOF)
 661             break;
 662
 663         if (le)
 664             wc = c1 | (c2 << 8) | (c3 << 16) | (c4 << 24);
 665         else
 666             wc = c4 | (c3 << 8) | (c2 << 16) | (c1 << 24);
 667
 668         /* store */
 669         if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 670             break;
 671
 672         /* if it's an end of line, finish */
 673         if (wc == L'\n')
 674             break;
 675     }
 676
 677     if (ptr != NULL) {
 678         ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 679         (*s)--;
 680     }
 681
 682     return ptr;
 683 }
 684
 685
 686 static int write_utf32ae(struct mpdm_file *f, const wchar_t * str, int le)
 687 /* utf32 writer, ANY ending */
 688 {
 689     int cnt = 0;
 690     wchar_t wc;
 691
 692     /* convert char by char */
 693     for (; (wc = *str) != L'\0'; str++) {
 694
 695         if (le) {
 696             put_char((wc & 0x000000ff), f);
 697             put_char((wc & 0x0000ff00) >> 8, f);
 698             put_char((wc & 0x00ff0000) >> 16, f);
 699             put_char((wc & 0xff000000) >> 24, f);
 700         }
 701         else {
 702             put_char((wc & 0xff000000) >> 24, f);
 703             put_char((wc & 0x00ff0000) >> 16, f);
 704             put_char((wc & 0x0000ff00) >> 8, f);
 705             put_char((wc & 0x000000ff), f);
 706         }
 707     }
 708
 709     return cnt;
 710 }
 711
 712
 713 static wchar_t *read_utf32le(struct mpdm_file *f, int *s)
 714 {
 715     return read_utf32ae(f, s, 1);
 716 }
 717
 718
 719 static int write_utf32le(struct mpdm_file *f, const wchar_t * str)
 720 {
 721     return write_utf32ae(f, str, 1);
 722 }
 723
 724
 725 static wchar_t *read_utf32be(struct mpdm_file *f, int *s)
 726 {
 727     return read_utf32ae(f, s, 0);
 728 }
 729
 730
 731 static int write_utf32be(struct mpdm_file *f, const wchar_t * str)
 732 {
 733     return write_utf32ae(f, str, 0);
 734 }
 735
 736
 737 static wchar_t *read_utf32(struct mpdm_file *f, int *s)
 738 {
 739     int c1, c2, c3, c4;
 740     wchar_t *enc = L"utf-32le";
 741
 742     f->f_read = read_utf32le;
 743
 744     /* autodetection */
 745     c1 = get_char(f);
 746     c2 = get_char(f);
 747     c3 = get_char(f);
 748     c4 = get_char(f);
 749
 750     if (c1 == 0 && c2 == 0 && c3 == 0xfe && c4 == 0xff) {
 751         enc = L"utf-32be";
 752         f->f_read = read_utf32be;
 753     }
 754     if (c1 != 0xff || c2 != 0xfe || c3 != 0 || c4 != 0) {
 755         /* no BOM; assume le and hope */
 756         fseek(f->in, 0, SEEK_SET);
 757     }
 758
 759     mpdm_hset_s(mpdm_root(), L"DETECTED_ENCODING", MPDM_LS(enc));
 760
 761     return f->f_read(f, s);
 762 }
 763
 764
 765 static int write_utf32le_bom(struct mpdm_file *f, const wchar_t * str)
 766 {
 767     /* store the LE signature */
 768     put_char(0xff, f);
 769     put_char(0xfe, f);
 770     put_char(0, f);
 771     put_char(0, f);
 772
 773     /* we're 32le from now on */
 774     f->f_write = write_utf32le;
 775
 776     return f->f_write(f, str);
 777 }
 778
 779
 780 static int write_utf32be_bom(struct mpdm_file *f, const wchar_t * str)
 781 {
 782     /* store the BE signature */
 783     put_char(0, f);
 784     put_char(0, f);
 785     put_char(0xfe, f);
 786     put_char(0xff, f);
 787
 788     /* we're 32be from now on */
 789     f->f_write = write_utf32be;
 790
 791     return f->f_write(f, str);
 792 }
 793
 794
 795 static wchar_t *read_auto(struct mpdm_file *f, int *s)
 796 /* autodetects different encodings based on the BOM */
 797 {
 798     wchar_t *enc = L"";
 799
 800     /* by default, multibyte reading */
 801     f->f_read = read_mbs;
 802
 803     /* ensure seeking is possible */
 804     if (f->in != NULL && fseek(f->in, 0, SEEK_CUR) != -1) {
 805         int c;
 806
 807         c = get_char(f);
 808
 809         if (c == 0xff) {
 810             /* can be utf32le or utf16le */
 811             if (get_char(f) == 0xfe) {
 812                 /* if next 2 chars are 0x00, it's utf32; otherwise utf16 */
 813                 if (get_char(f) == 0x00 && get_char(f) == 0x00) {
 814                     enc = L"utf-32le";
 815                     f->f_read = read_utf32le;
 816                     goto got_encoding;
 817                 }
 818                 else {
 819                     /* rewind to 3rd character */
 820                     fseek(f->in, 2, SEEK_SET);
 821
 822                     enc = L"utf-16le";
 823                     f->f_read = read_utf16le;
 824                     goto got_encoding;
 825                 }
 826             }
 827         }
 828         else
 829         if (c == 0x00) {
 830             /* can be utf32be */
 831             if (get_char(f) == 0x00 && get_char(f) == 0xfe
 832                 && get_char(f) == 0xff) {
 833                 enc = L"utf-32be";
 834                 f->f_read = read_utf32be;
 835                 goto got_encoding;
 836             }
 837         }
 838         else
 839         if (c == 0xfe) {
 840             /* can be utf16be */
 841             if (get_char(f) == 0xff) {
 842                 enc = L"utf-16be";
 843                 f->f_read = read_utf16be;
 844                 goto got_encoding;
 845             }
 846         }
 847         else
 848         if (c == 0xef) {
 849             /* can be utf8 with BOM */
 850             if (get_char(f) == 0xbb && get_char(f) == 0xbf) {
 851                 enc = L"utf-8bom";
 852                 f->f_read = read_utf8;
 853                 goto got_encoding;
 854             }
 855         }
 856         else {
 857             /* try if a first bunch of chars are valid UTF-8 */
 858             int p = c;
 859             int n = 10000;
 860             int u = 0;
 861
 862             while (--n && (c = get_char(f)) != EOF) {
 863                 if ((c & 0xc0) == 0x80) {
 864                     if ((p & 0xc0) == 0xc0)
 865                         u++;
 866                     else
 867                     if ((p & 0x80) == 0x00) {
 868                         u = -1;
 869                         break;
 870                     }
 871                 }
 872                 else
 873                 if ((p & 0xc0) == 0xc0) {
 874                     u = -1;
 875                     break;
 876                 }
 877
 878                 p = c;
 879             }
 880
 881             if (u < 0) {
 882                 /* invalid utf-8; fall back to 8bit */
 883                 enc = L"8bit";
 884                 f->f_read = read_iso8859_1;
 885             }
 886             else
 887             if (u > 0) {
 888                 /* utf-8 sequences found */
 889                 enc = L"utf-8";
 890                 f->f_read = read_utf8;
 891             }
 892
 893             /* 7 bit ASCII: do nothing */
 894         }
 895
 896         /* none of the above; restart */
 897         fseek(f->in, 0, SEEK_SET);
 898     }
 899
 900   got_encoding:
 901     mpdm_hset_s(mpdm_root(), L"DETECTED_ENCODING", MPDM_LS(enc));
 902
 903     return f->f_read(f, s);
 904 }
 905
 906
 907 static mpdm_t new_mpdm_file(void)
 908 /* creates a new file value */
 909 {
 910     mpdm_t v = NULL;
 911     struct mpdm_file *fs;
 912     mpdm_t e;
 913
 914     if ((fs = malloc(sizeof(struct mpdm_file))) == NULL)
 915         return NULL;
 916
 917     memset(fs, '\0', sizeof(struct mpdm_file));
 918
 919     /* default I/O functions */
 920     fs->f_read = read_auto;
 921     fs->f_write = write_wcs;
 922
 923 #ifdef CONFOPT_ICONV
 924     /* no iconv encodings by default */
 925     fs->ic_enc = fs->ic_dec = (iconv_t) - 1;
 926 #endif
 927
 928     if ((v =
 929          mpdm_new(MPDM_FILE | MPDM_FREE, fs,
 930                   sizeof(struct mpdm_file))) == NULL) {
 931         free(fs);
 932         return NULL;
 933     }
 934
 935     e = mpdm_hget_s(mpdm_root(), L"ENCODING");
 936
 937     if (mpdm_size(e) == 0)
 938         e = mpdm_hget_s(mpdm_root(), L"TEMP_ENCODING");
 939
 940     if (mpdm_size(e)) {
 941
 942         wchar_t *enc = mpdm_string(e);
 943
 944         if (wcscmp(enc, L"utf-8") == 0) {
 945             fs->f_read = read_utf8_bom;
 946             fs->f_write = write_utf8;
 947         }
 948         else
 949         if (wcscmp(enc, L"utf-8bom") == 0) {
 950             fs->f_read = read_utf8_bom;
 951             fs->f_write = write_utf8_bom;
 952         }
 953         else
 954         if (wcscmp(enc, L"iso8859-1") == 0 ||
 955                  wcscmp(enc, L"8bit") == 0) {
 956             fs->f_read = read_iso8859_1;
 957             fs->f_write = write_iso8859_1;
 958         }
 959         else
 960         if (wcscmp(enc, L"utf-16le") == 0) {
 961             fs->f_read = read_utf16le;
 962             fs->f_write = write_utf16le_bom;
 963         }
 964         else
 965         if (wcscmp(enc, L"utf-16be") == 0) {
 966             fs->f_read = read_utf16be;
 967             fs->f_write = write_utf16be_bom;
 968         }
 969         else
 970         if (wcscmp(enc, L"utf-16") == 0) {
 971             fs->f_read = read_utf16;
 972             fs->f_write = write_utf16le_bom;
 973         }
 974         else
 975         if (wcscmp(enc, L"utf-32le") == 0) {
 976             fs->f_read = read_utf32le;
 977             fs->f_write = write_utf32le_bom;
 978         }
 979         else
 980         if (wcscmp(enc, L"utf-32be") == 0) {
 981             fs->f_read = read_utf32be;
 982             fs->f_write = write_utf32be_bom;
 983         }
 984         else
 985         if (wcscmp(enc, L"utf-32") == 0) {
 986             fs->f_read = read_utf32;
 987             fs->f_write = write_utf32le_bom;
 988         }
 989         else {
 990 #ifdef CONFOPT_ICONV
 991             mpdm_t cs = MPDM_2MBS(e->data);
 992
 993             if ((fs->ic_enc =
 994                  iconv_open((char *) cs->data, "WCHAR_T")) != (iconv_t) - 1
 995                 && (fs->ic_dec =
 996                     iconv_open("WCHAR_T",
 997                                (char *) cs->data)) != (iconv_t) - 1) {
 998
 999                 fs->f_read = read_iconv;
1000                 fs->f_write = write_iconv;
1001             }
1002 #endif                          /* CONFOPT_ICONV */
1003         }
1004
1005         mpdm_hset_s(mpdm_root(), L"TEMP_ENCODING", NULL);
1006     }
1007
1008     return v;
1009 }
1010
1011
1012 static void destroy_mpdm_file(mpdm_t v)
1013 /* destroys and file value */
1014 {
1015     struct mpdm_file *fs = (struct mpdm_file *) v->data;
1016
1017     if (fs != NULL) {
1018 #ifdef CONFOPT_ICONV
1019         if (fs->ic_enc != (iconv_t) - 1) {
1020             iconv_close(fs->ic_enc);
1021             fs->ic_enc = (iconv_t) - 1;
1022         }
1023
1024         if (fs->ic_dec != (iconv_t) - 1) {
1025             iconv_close(fs->ic_dec);
1026             fs->ic_dec = (iconv_t) - 1;
1027         }
1028 #endif
1029
1030         free(fs);
1031         v->data = NULL;
1032     }
1033 }
1034
1035
1036 /** interface **/
1037
1038 wchar_t *mpdm_read_mbs(FILE * f, int *s)
1039 /* reads a multibyte string from a stream into a dynamic string */
1040 {
1041     struct mpdm_file fs;
1042
1043     /* reset the structure */
1044     memset(&fs, '\0', sizeof(fs));
1045     fs.in = f;
1046
1047     return read_mbs(&fs, s);
1048 }
1049
1050
1051 int mpdm_write_wcs(FILE * f, const wchar_t * str)
1052 /* writes a wide string to a stream */
1053 {
1054     struct mpdm_file fs;
1055
1056     /* reset the structure */
1057     memset(&fs, '\0', sizeof(fs));
1058     fs.out = f;
1059
1060     return write_wcs(&fs, str);
1061 }
1062
1063
1064 mpdm_t mpdm_new_f(FILE * f)
1065 /* creates a new file value from a FILE * */
1066 {
1067     mpdm_t v = NULL;
1068
1069     if (f == NULL)
1070         return NULL;
1071
1072     if ((v = new_mpdm_file()) != NULL) {
1073         struct mpdm_file *fs = (struct mpdm_file *) v->data;
1074         fs->in = fs->out = f;
1075     }
1076
1077     return v;
1078 }
1079
1080
1081 /**
1082  * mpdm_open - Opens a file.
1083  * @filename: the file name
1084  * @mode: an fopen-like mode string
1085  *
1086  * Opens a file. If @filename can be open in the specified @mode, an
1087  * mpdm_t value will be returned containing the file descriptor, or NULL
1088  * otherwise.
1089  *
1090  * If the file is open for reading, some charset detection methods are
1091  * used. If any of them is successful, its name is stored in the
1092  * DETECTED_ENCODING element of the mpdm_root() hash. This value is
1093  * suitable to be copied over ENCODING or TEMP_ENCODING.
1094  *
1095  * If the file is open for writing, the encoding to be used is read from
1096  * the ENCODING element of mpdm_root() and, if not set, from the
1097  * TEMP_ENCODING one. The latter will always be deleted afterwards.
1098  * [File Management]
1099  */
1100 mpdm_t mpdm_open(const mpdm_t filename, const mpdm_t mode)
1101 {
1102     FILE *f = NULL;
1103     mpdm_t fn;
1104     mpdm_t m;
1105
1106     mpdm_ref(filename);
1107     mpdm_ref(mode);
1108
1109     if (filename != NULL && mode != NULL) {
1110
1111         /* convert to mbs,s */
1112         fn = mpdm_ref(MPDM_2MBS(filename->data));
1113         m = mpdm_ref(MPDM_2MBS(mode->data));
1114
1115         if ((f = fopen((char *) fn->data, (char *) m->data)) == NULL)
1116             store_syserr();
1117         else {
1118 #if defined(CONFOPT_SYS_STAT_H) && defined(S_ISDIR) && defined(EISDIR)
1119             struct stat s;
1120
1121             /* test if the open file is a directory */
1122             if (fstat(fileno(f), &s) != -1 && S_ISDIR(s.st_mode)) {
1123                 /* it's a directory; fail */
1124                 errno = EISDIR;
1125                 store_syserr();
1126                 fclose(f);
1127                 f = NULL;
1128             }
1129 #endif
1130         }
1131
1132         mpdm_unref(m);
1133         mpdm_unref(fn);
1134     }
1135
1136     mpdm_unref(mode);
1137     mpdm_unref(filename);
1138
1139     return MPDM_F(f);
1140 }
1141
1142
1143 /**
1144  * mpdm_close - Closes a file descriptor.
1145  * @fd: the value containing the file descriptor
1146  *
1147  * Closes the file descriptor.
1148  * [File Management]
1149  */
1150 mpdm_t mpdm_close(mpdm_t fd)
1151 {
1152     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1153
1154     mpdm_ref(fd);
1155
1156     if ((fd->flags & MPDM_FILE) && fs != NULL) {
1157         if (fs->in != NULL)
1158             fclose(fs->in);
1159
1160         if (fs->out != fs->in && fs->out != NULL)
1161             fclose(fs->out);
1162
1163         destroy_mpdm_file(fd);
1164     }
1165
1166     fd = mpdm_unref(fd);
1167
1168     return fd;
1169 }
1170
1171
1172 /**
1173  * mpdm_read - Reads a line from a file descriptor.
1174  * @fd: the value containing the file descriptor
1175  *
1176  * Reads a line from @fd. Returns the line, or NULL on EOF.
1177  * [File Management]
1178  * [Character Set Conversion]
1179  */
1180 mpdm_t mpdm_read(const mpdm_t fd)
1181 {
1182     mpdm_t v = NULL;
1183     wchar_t *ptr;
1184     int s;
1185     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1186
1187     if (fs == NULL)
1188         return NULL;
1189
1190     ptr = fs->f_read(fs, &s);
1191
1192     if (ptr != NULL)
1193         v = MPDM_ENS(ptr, s);
1194
1195     return v;
1196 }
1197
1198
1199 mpdm_t mpdm_getchar(const mpdm_t fd)
1200 {
1201     int c;
1202     wchar_t tmp[2];
1203     mpdm_t r = NULL;
1204     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1205
1206     if (fs != NULL && (c = get_char(fs)) != EOF) {
1207         /* get the char as-is */
1208         tmp[0] = (wchar_t) c;
1209         tmp[1] = L'\0';
1210
1211         r = MPDM_S(tmp);
1212     }
1213
1214     return r;
1215 }
1216
1217
1218 int mpdm_putchar(const mpdm_t fd, const mpdm_t c)
1219 {
1220     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1221     const wchar_t *ptr = mpdm_string(c);
1222     int r = 1;
1223
1224     mpdm_ref(c);
1225
1226     if (fs == NULL || put_char(*ptr, fs) == -1)
1227         r = 0;
1228
1229     mpdm_unref(c);
1230
1231     return r;
1232 }
1233
1234
1235 /**
1236  * mpdm_write - Writes a value into a file.
1237  * @fd: the file descriptor.
1238  * @v: the value to be written.
1239  *
1240  * Writes the @v string value into @fd, using the current encoding.
1241  * [File Management]
1242  * [Character Set Conversion]
1243  */
1244 int mpdm_write(const mpdm_t fd, const mpdm_t v)
1245 {
1246     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1247     int ret = -1;
1248
1249     mpdm_ref(v);
1250
1251     if (fs != NULL)
1252         ret = fs->f_write(fs, mpdm_string(v));
1253
1254     mpdm_unref(v);
1255
1256     return ret;
1257 }
1258
1259
1260 int mpdm_fseek(const mpdm_t fd, long offset, int whence)
1261 {
1262     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1263
1264     return fseek(fs->in, offset, whence);
1265 }
1266
1267
1268 long mpdm_ftell(const mpdm_t fd)
1269 {
1270     struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1271
1272     return ftell(fs->in);
1273 }
1274
1275
1276 FILE *mpdm_get_filehandle(const mpdm_t fd)
1277 {
1278     FILE *f = NULL;
1279
1280     if (fd->flags & MPDM_FILE && fd->data != NULL) {
1281         struct mpdm_file *fs = (struct mpdm_file *) fd->data;
1282         f = fs->in;
1283     }
1284
1285     return f;
1286 }
1287
1288
1289 /*
1290 mpdm_t mpdm_bread(mpdm_t fd, int size)
1291 {
1292 }
1293
1294
1295 int mpdm_bwrite(mpdm_tfd, mpdm_t v, int size)
1296 {
1297 }
1298 */
1299
1300
1301 static mpdm_t embedded_encodings(void)
1302 {
1303     mpdm_t e;
1304     wchar_t *e2e[] = {
1305         L"utf-8", L"utf-8",
1306         L"utf8", NULL,
1307         L"iso8859-1", L"iso8859-1",
1308         L"iso-8859-1", NULL,
1309         L"8bit", NULL,
1310         L"latin1", NULL,
1311         L"latin-1", NULL,
1312         L"utf-16le", L"utf-16le",
1313         L"utf16le", NULL,
1314         L"ucs-2le", NULL,
1315         L"utf-16be", L"utf-16be",
1316         L"utf16be", NULL,
1317         L"ucs-2be", NULL,
1318         L"utf-16", L"utf-16",
1319         L"utf16", NULL,
1320         L"ucs-2", NULL,
1321         L"ucs2", NULL,
1322         L"utf-32le", L"utf-32le",
1323         L"utf32le", NULL,
1324         L"ucs-4le", NULL,
1325         L"utf-32be", L"utf-32be",
1326         L"utf32be", NULL,
1327         L"ucs-4be", NULL,
1328         L"utf-32", L"utf-32",
1329         L"utf32", NULL,
1330         L"ucs-4", NULL,
1331         L"ucs4", NULL,
1332         L"utf-8bom", L"utf-8bom",
1333         L"utf8bom", NULL,
1334         NULL, NULL
1335     };
1336
1337     if ((e = mpdm_hget_s(mpdm_root(), L"EMBEDDED_ENCODINGS")) == NULL) {
1338         int n;
1339         mpdm_t p = NULL;
1340
1341         e = mpdm_ref(MPDM_H(0));
1342
1343         for (n = 0; e2e[n] != NULL; n += 2) {
1344             mpdm_t v = MPDM_S(e2e[n]);
1345
1346             if (e2e[n + 1] != NULL)
1347                 p = MPDM_S(e2e[n + 1]);
1348
1349             mpdm_hset(e, v, p);
1350             mpdm_hset(e, mpdm_ulc(v, 1), p);
1351         }
1352
1353         mpdm_hset_s(mpdm_root(), L"EMBEDDED_ENCODINGS", e);
1354
1355         mpdm_unref(e);
1356     }
1357
1358     return e;
1359 }
1360
1361
1362 /**
1363  * mpdm_encoding - Sets the current charset encoding for files.
1364  * @charset: the charset name.
1365  *
1366  * Sets the current charset encoding for files. Future opened
1367  * files will be assumed to be encoded with @charset, which can
1368  * be any of the supported charset names (utf-8, iso-8859-1, etc.),
1369  * and converted on each read / write. If charset is NULL, it
1370  * is reverted to default charset conversion (i.e. the one defined
1371  * in the locale).
1372  *
1373  * This function stores the @charset value into the ENCODING item
1374  * of the mpdm_root() hash.
1375  *
1376  * Returns a negative number if @charset is unsupported, or zero
1377  * if no errors were found.
1378  * [File Management]
1379  * [Character Set Conversion]
1380  */
1381 int mpdm_encoding(mpdm_t charset)
1382 {
1383     int ret = -1;
1384     mpdm_t e = embedded_encodings();
1385     mpdm_t v = NULL;
1386
1387     mpdm_ref(charset);
1388
1389     /* NULL encoding? done */
1390     if (mpdm_size(charset) == 0) {
1391         mpdm_hset_s(mpdm_root(), L"ENCODING", NULL);
1392         ret = 0;
1393     }
1394
1395 #ifdef CONFOPT_ICONV
1396     else {
1397         iconv_t ic;
1398         mpdm_t cs = mpdm_ref(MPDM_2MBS(charset->data));
1399
1400         /* tries to create an iconv encoder and decoder for this charset */
1401
1402         if ((ic =
1403              iconv_open("WCHAR_T", (char *) cs->data)) == (iconv_t) - 1)
1404             ret = -1;
1405         else {
1406             iconv_close(ic);
1407
1408             if ((ic =
1409                  iconv_open((char *) cs->data,
1410                             "WCHAR_T")) == (iconv_t) - 1)
1411                 ret = -2;
1412             else {
1413                 iconv_close(ic);
1414
1415                 /* got a valid encoding */
1416                 v = charset;
1417                 ret = 0;
1418             }
1419         }
1420
1421         mpdm_unref(cs);
1422     }
1423 #endif                          /* CONFOPT_ICONV */
1424
1425     if (ret != 0 && (v = mpdm_hget(e, charset)) != NULL)
1426         ret = 0;
1427
1428     if (ret == 0)
1429         mpdm_hset_s(mpdm_root(), L"ENCODING", v);
1430
1431     mpdm_unref(charset);
1432
1433     return ret;
1434 }
1435
1436
1437 /**
1438  * mpdm_unlink - Deletes a file.
1439  * @filename: file name to be deleted
1440  *
1441  * Deletes a file.
1442  * [File Management]
1443  */
1444 int mpdm_unlink(const mpdm_t filename)
1445 {
1446     int ret;
1447     mpdm_t fn;
1448
1449     mpdm_ref(filename);
1450
1451     /* convert to mbs */
1452     fn = mpdm_ref(MPDM_2MBS(filename->data));
1453
1454     if ((ret = unlink((char *) fn->data)) == -1)
1455         store_syserr();
1456
1457     mpdm_unref(fn);
1458     mpdm_unref(filename);
1459
1460     return ret;
1461 }
1462
1463
1464 /**
1465  * mpdm_stat - Gives status from a file.
1466  * @filename: file name to get the status from
1467  *
1468  * Returns a 14 element array of the status (permissions, onwer, etc.)
1469  * from the desired @filename, or NULL if the file cannot be accessed.
1470  * (man 2 stat).
1471  *
1472  * The values are: 0, device number of filesystem; 1, inode number;
1473  * 2, file mode; 3, number of hard links to the file; 4, uid; 5, gid;
1474  * 6, device identifier; 7, total size of file in bytes; 8, atime;
1475  * 9, mtime; 10, ctime; 11, preferred block size for system I/O;
1476  * 12, number of blocks allocated and 13, canonicalized file name.
1477  * Not all elements have necesarily meaningful values, as most are
1478  * system-dependent.
1479  * [File Management]
1480  */
1481 mpdm_t mpdm_stat(const mpdm_t filename)
1482 {
1483     mpdm_t r = NULL;
1484
1485     mpdm_ref(filename);
1486
1487 #ifdef CONFOPT_SYS_STAT_H
1488     struct stat s;
1489     mpdm_t fn;
1490
1491     fn = mpdm_ref(MPDM_2MBS(filename->data));
1492
1493     if (stat((char *) fn->data, &s) != -1) {
1494         r = MPDM_A(14);
1495
1496         mpdm_ref(r);
1497
1498         mpdm_aset(r, MPDM_I(s.st_dev), 0);
1499         mpdm_aset(r, MPDM_I(s.st_ino), 1);
1500         mpdm_aset(r, MPDM_I(s.st_mode), 2);
1501         mpdm_aset(r, MPDM_I(s.st_nlink), 3);
1502         mpdm_aset(r, MPDM_I(s.st_uid), 4);
1503         mpdm_aset(r, MPDM_I(s.st_gid), 5);
1504         mpdm_aset(r, MPDM_I(s.st_rdev), 6);
1505         mpdm_aset(r, MPDM_I(s.st_size), 7);
1506         mpdm_aset(r, MPDM_I(s.st_atime), 8);
1507         mpdm_aset(r, MPDM_I(s.st_mtime), 9);
1508         mpdm_aset(r, MPDM_I(s.st_ctime), 10);
1509         mpdm_aset(r, MPDM_I(0), 11);    /* s.st_blksize */
1510         mpdm_aset(r, MPDM_I(0), 12);    /* s.st_blocks */
1511
1512 #ifdef CONFOPT_CANONICALIZE_FILE_NAME
1513
1514         {
1515             char *ptr;
1516
1517             if ((ptr = canonicalize_file_name((char *) fn->data)) != NULL) {
1518                 mpdm_aset(r, MPDM_MBS(ptr), 13);
1519                 free(ptr);
1520             }
1521         }
1522 #endif
1523
1524 #ifdef CONFOPT_REALPATH
1525         {
1526             char tmp[2048];
1527
1528             if (realpath((char *) fn->data, tmp) != NULL)
1529                 mpdm_aset(r, MPDM_MBS(tmp), 13);
1530         }
1531 #endif
1532
1533 #ifdef CONFOPT_FULLPATH
1534         {
1535             char tmp[_MAX_PATH + 1];
1536
1537             if (_fullpath(tmp, (char *) fn->data, _MAX_PATH) != NULL)
1538                 mpdm_aset(r, MPDM_MBS(tmp), 13);
1539         }
1540 #endif
1541
1542         mpdm_unrefnd(r);
1543     }
1544     else
1545         store_syserr();
1546
1547     mpdm_unref(fn);
1548
1549 #endif                          /* CONFOPT_SYS_STAT_H */
1550
1551     mpdm_unref(filename);
1552
1553     return r;
1554 }
1555
1556
1557 /**
1558  * mpdm_chmod - Changes a file's permissions.
1559  * @filename: the file name
1560  * @perms: permissions (element 2 from mpdm_stat())
1561  *
1562  * Changes the permissions for a file.
1563  * [File Management]
1564  */
1565 int mpdm_chmod(const mpdm_t filename, mpdm_t perms)
1566 {
1567     int r = -1;
1568
1569     mpdm_ref(filename);
1570     mpdm_ref(perms);
1571
1572     mpdm_t fn = mpdm_ref(MPDM_2MBS(filename->data));
1573
1574     if ((r = chmod((char *) fn->data, mpdm_ival(perms))) == -1)
1575         store_syserr();
1576
1577     mpdm_unref(fn);
1578     mpdm_unref(perms);
1579     mpdm_unref(filename);
1580
1581     return r;
1582 }
1583
1584
1585 /**
1586  * mpdm_chdir - Changes the working directory
1587  * @dir: the new path
1588  *
1589  * Changes the working directory
1590  * [File Management]
1591  */
1592 int mpdm_chdir(const mpdm_t dir)
1593 {
1594     int r = -1;
1595
1596     mpdm_ref(dir);
1597     mpdm_t fn = mpdm_ref(MPDM_2MBS(dir->data));
1598
1599     if ((r = chdir((char *) fn->data)) == -1)
1600         store_syserr();
1601
1602     mpdm_unref(fn);
1603     mpdm_unref(dir);
1604
1605     return r;
1606 }
1607
1608
1609 /**
1610  * mpdm_chown - Changes a file's owner.
1611  * @filename: the file name
1612  * @uid: user id (element 4 from mpdm_stat())
1613  * @gid: group id (element 5 from mpdm_stat())
1614  *
1615  * Changes the owner and group id's for a file.
1616  * [File Management]
1617  */
1618 int mpdm_chown(const mpdm_t filename, mpdm_t uid, mpdm_t gid)
1619 {
1620     int r = -1;
1621
1622     mpdm_ref(filename);
1623     mpdm_ref(uid);
1624     mpdm_ref(gid);
1625
1626 #ifdef CONFOPT_CHOWN
1627
1628     mpdm_t fn = mpdm_ref(MPDM_2MBS(filename->data));
1629
1630     if ((r =
1631          chown((char *) fn->data, mpdm_ival(uid), mpdm_ival(gid))) == -1)
1632         store_syserr();
1633
1634     mpdm_unref(fn);
1635
1636 #endif                          /* CONFOPT_CHOWN */
1637
1638     mpdm_unref(gid);
1639     mpdm_unref(uid);
1640     mpdm_unref(filename);
1641
1642     return r;
1643 }
1644
1645
1646 /**
1647  * mpdm_glob - Executes a file globbing.
1648  * @spec: Globbing spec
1649  * @base: Optional base directory
1650  *
1651  * Executes a file globbing. @spec is system-dependent, but usually
1652  * the * and ? metacharacters work everywhere. @base can contain a
1653  * directory; if that's the case, the output strings will include it.
1654  * In any case, each returned value will be suitable for a call to
1655  * mpdm_open().
1656  *
1657  * Returns an array of files that match the globbing (can be an empty
1658  * array if no file matches), or NULL if globbing is unsupported.
1659  * [File Management]
1660  */
1661 mpdm_t mpdm_glob(const mpdm_t spec, const mpdm_t base)
1662 {
1663     mpdm_t d = NULL;
1664     mpdm_t f = NULL;
1665     mpdm_t v = NULL;
1666
1667     mpdm_ref(spec);
1668     mpdm_ref(base);
1669
1670 #ifdef CONFOPT_WIN32
1671
1672     WIN32_FIND_DATA fd;
1673     HANDLE h;
1674     char *ptr;
1675     mpdm_t w;
1676     mpdm_t s = NULL;
1677     mpdm_t sp = NULL;
1678
1679     /* add base */
1680     if (mpdm_size(base))
1681         sp = mpdm_strcat_s(base, L"/");
1682
1683     /* add spec */
1684     w = mpdm_ref(sp);
1685
1686     if (mpdm_size(spec) == 0)
1687         sp = mpdm_strcat_s(w, L"*.*");
1688     else
1689         sp = mpdm_strcat(w, spec);
1690
1691     mpdm_unref(w);
1692
1693     /* delete repeated directory delimiters */
1694     w = mpdm_ref(sp);
1695     sp = mpdm_sregex(w, MPDM_LS(L"@[\\/]+@g"), MPDM_LS(L"/"), 0);
1696     mpdm_unref(w);
1697
1698     w = mpdm_ref(sp);
1699     sp = MPDM_2MBS(w->data);
1700     mpdm_unref(w);
1701
1702     v = MPDM_A(0);
1703     d = mpdm_ref(MPDM_A(0));
1704     f = mpdm_ref(MPDM_A(0));
1705     mpdm_ref(sp);
1706
1707     if ((h =
1708          FindFirstFile((char *) sp->data, &fd)) != INVALID_HANDLE_VALUE) {
1709         /* if spec includes a directory, store in s */
1710         if ((ptr = strrchr((char *) sp->data, '/')) != NULL) {
1711             *(ptr + 1) = '\0';
1712             s = MPDM_MBS(sp->data);
1713         }
1714
1715         do {
1716             /* ignore . and .. */
1717             if (strcmp(fd.cFileName, ".") == 0
1718                 || strcmp(fd.cFileName, "..") == 0)
1719                 continue;
1720
1721             /* concat base directory and file names */
1722             w = mpdm_strcat(s, MPDM_MBS(fd.cFileName));
1723
1724             /* if it's a directory, add a / */
1725             if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1726                 mpdm_t t = mpdm_ref(w);
1727                 w = mpdm_strcat_s(t, L"/");
1728                 mpdm_unref(t);
1729
1730                 mpdm_push(d, w);
1731             }
1732             else
1733                 mpdm_push(f, w);
1734         }
1735         while (FindNextFile(h, &fd));
1736
1737         FindClose(h);
1738     }
1739
1740     mpdm_unref(sp);
1741
1742 #endif
1743
1744 #if CONFOPT_GLOB_H
1745
1746     /* glob.h support */
1747     glob_t globbuf;
1748     const char *ptr;
1749     mpdm_t w;
1750
1751     /* build full path */
1752     if (mpdm_size(base))
1753         v = mpdm_strcat_s(base, L"/");
1754
1755     w = mpdm_ref(v);
1756
1757     if (mpdm_size(spec) == 0)
1758         v = mpdm_strcat_s(w, L"*");
1759     else
1760         v = mpdm_strcat(w, spec);
1761
1762     mpdm_unref(w);
1763
1764     /* delete repeated directory delimiters */
1765     w = mpdm_ref(v);
1766     v = mpdm_sregex(w, MPDM_LS(L"@/{2,}@g"), MPDM_LS(L"/"), 0);
1767     mpdm_unref(w);
1768
1769     w = mpdm_ref(v);
1770     v = MPDM_2MBS(w->data);
1771     mpdm_unref(w);
1772
1773     ptr = v->data;
1774
1775     globbuf.gl_offs = 1;
1776
1777     v = MPDM_A(0);
1778     d = mpdm_ref(MPDM_A(0));
1779     f = mpdm_ref(MPDM_A(0));
1780
1781     if (glob(ptr, GLOB_MARK, NULL, &globbuf) == 0) {
1782         int n;
1783
1784         for (n = 0; globbuf.gl_pathv[n] != NULL; n++) {
1785             char *ptr = globbuf.gl_pathv[n];
1786             mpdm_t t = MPDM_MBS(ptr);
1787
1788             /* if last char is /, add to directories */
1789             if (ptr[strlen(ptr) - 1] == '/')
1790                 mpdm_push(d, t);
1791             else
1792                 mpdm_push(f, t);
1793         }
1794     }
1795
1796     globfree(&globbuf);
1797
1798 #else
1799
1800     /* no win32 nor glob.h; try workaround */
1801     /* ... */
1802
1803 #endif
1804
1805     if (v != NULL) {
1806         int n;
1807
1808         mpdm_sort(d, 1);
1809         mpdm_sort(f, 1);
1810
1811         mpdm_ref(v);
1812
1813         /* transfer all data in d and f */
1814         for (n = 0; n < mpdm_size(d); n++)
1815             mpdm_push(v, mpdm_aget(d, n));
1816         for (n = 0; n < mpdm_size(f); n++)
1817             mpdm_push(v, mpdm_aget(f, n));
1818
1819         mpdm_unref(f);
1820         mpdm_unref(d);
1821
1822         mpdm_unrefnd(v);
1823     }
1824
1825     mpdm_unref(base);
1826     mpdm_unref(spec);
1827
1828     return v;
1829 }
1830
1831
1832 #ifdef CONFOPT_WIN32
1833
1834 static void win32_pipe(HANDLE * h, int n)
1835 {
1836     SECURITY_ATTRIBUTES sa;
1837     HANDLE cp, t;
1838
1839     memset(&sa, '\0', sizeof(sa));
1840     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1841     sa.bInheritHandle = TRUE;
1842     sa.lpSecurityDescriptor = NULL;
1843
1844     cp = GetCurrentProcess();
1845
1846     CreatePipe(&h[0], &h[1], &sa, 0);
1847     DuplicateHandle(cp, h[n], cp, &t, 0, FALSE, DUPLICATE_SAME_ACCESS);
1848     CloseHandle(h[n]);
1849     h[n] = t;
1850 }
1851
1852
1853 static int sysdep_popen(mpdm_t v, char *prg, int rw)
1854 /* win32-style pipe */
1855 {
1856     HANDLE pr[2];
1857     HANDLE pw[2];
1858     PROCESS_INFORMATION pi;
1859     STARTUPINFO si;
1860     int ret;
1861     struct mpdm_file *fs = (struct mpdm_file *) v->data;
1862
1863     /* init all */
1864     pr[0] = pr[1] = pw[0] = pw[1] = NULL;
1865
1866     if (rw & 0x01)
1867         win32_pipe(pr, 0);
1868     if (rw & 0x02)
1869         win32_pipe(pw, 1);
1870
1871     /* spawn new process */
1872     memset(&pi, '\0', sizeof(pi));
1873     memset(&si, '\0', sizeof(si));
1874
1875     si.cb = sizeof(STARTUPINFO);
1876     si.hStdError = pr[1];
1877     si.hStdOutput = pr[1];
1878     si.hStdInput = pw[0];
1879     si.dwFlags |= STARTF_USESTDHANDLES;
1880
1881     ret =
1882         CreateProcess(NULL, prg, NULL, NULL, TRUE, 0, NULL, NULL, &si,
1883                       &pi);
1884
1885     if (rw & 0x01)
1886         CloseHandle(pr[1]);
1887     if (rw & 0x02)
1888         CloseHandle(pw[0]);
1889
1890     fs->hin = pr[0];
1891     fs->hout = pw[1];
1892
1893     return ret;
1894 }
1895
1896
1897 static int sysdep_pclose(const mpdm_t v)
1898 {
1899     struct mpdm_file *fs = (struct mpdm_file *) v->data;
1900
1901     if (fs->hin != NULL)
1902         CloseHandle(fs->hin);
1903
1904     if (fs->hout != NULL)
1905         CloseHandle(fs->hout);
1906
1907     /* how to know process exit code? */
1908     return 0;
1909 }
1910
1911
1912 #else                           /* CONFOPT_WIN32 */
1913
1914 static int sysdep_popen(mpdm_t v, char *prg, int rw)
1915 /* unix-style pipe open */
1916 {
1917     int pr[2], pw[2];
1918     struct mpdm_file *fs = (struct mpdm_file *) v->data;
1919
1920     /* init all */
1921     pr[0] = pr[1] = pw[0] = pw[1] = -1;
1922
1923     if (rw & 0x01)
1924         pipe(pr);
1925     if (rw & 0x02)
1926         pipe(pw);
1927
1928     if (fork() == 0) {
1929         /* child process */
1930         if (rw & 0x01) {
1931             close(1);
1932             dup(pr[1]);
1933             close(pr[0]);
1934         }
1935         if (rw & 0x02) {
1936             close(0);
1937             dup(pw[0]);
1938             close(pw[1]);
1939         }
1940
1941         /* redirect stderr to stdout */
1942         close(2);
1943         dup(1);
1944
1945         /* run the program */
1946         execlp("/bin/sh", "/bin/sh", "-c", prg, NULL);
1947         execlp(prg, prg, NULL);
1948
1949         /* still here? exec failed; close pipes and exit */
1950         close(0);
1951         close(1);
1952         exit(0);
1953     }
1954
1955     /* create the pipes as non-buffered streams */
1956     if (rw & 0x01) {
1957         fs->in = fdopen(pr[0], "r");
1958         setvbuf(fs->in, NULL, _IONBF, 0);
1959         close(pr[1]);
1960     }
1961
1962     if (rw & 0x02) {
1963         fs->out = fdopen(pw[1], "w");
1964         setvbuf(fs->out, NULL, _IONBF, 0);
1965         close(pw[0]);
1966     }
1967
1968     return 1;
1969 }
1970
1971
1972 static int sysdep_pclose(const mpdm_t v)
1973 /* unix-style pipe close */
1974 {
1975     int s;
1976     struct mpdm_file *fs = (struct mpdm_file *) v->data;
1977
1978     if (fs->in != NULL)
1979         fclose(fs->in);
1980
1981     if (fs->out != fs->in && fs->out != NULL)
1982         fclose(fs->out);
1983
1984     wait(&s);
1985
1986     return s;
1987 }
1988
1989
1990 #endif                          /* CONFOPT_WIN32 */
1991
1992
1993 /**
1994  * mpdm_popen - Opens a pipe.
1995  * @prg: the program to pipe
1996  * @mode: an fopen-like mode string
1997  *
1998  * Opens a pipe to a program. If @prg can be open in the specified @mode, an
1999  * mpdm_t value will be returned containing the file descriptor, or NULL
2000  * otherwise.
2001  * [File Management]
2002  */
2003 mpdm_t mpdm_popen(const mpdm_t prg, const mpdm_t mode)
2004 {
2005     mpdm_t v, pr, md;
2006     char *m;
2007     int rw = 0;
2008
2009     mpdm_ref(prg);
2010     mpdm_ref(mode);
2011
2012     if (prg != NULL && mode != NULL) {
2013
2014         v = new_mpdm_file();
2015
2016         /* convert to mbs,s */
2017         pr = mpdm_ref(MPDM_2MBS(prg->data));
2018         md = mpdm_ref(MPDM_2MBS(mode->data));
2019
2020         /* get the mode */
2021         m = (char *) md->data;
2022
2023         /* set the mode */
2024         if (m[0] == 'r')
2025             rw = 0x01;
2026         if (m[0] == 'w')
2027             rw = 0x02;
2028         if (m[1] == '+')
2029             rw = 0x03;          /* r+ or w+ */
2030
2031         if (!sysdep_popen(v, (char *) pr->data, rw)) {
2032             destroy_mpdm_file(v);
2033             mpdm_unref(mpdm_ref(v));
2034             v = NULL;
2035         }
2036
2037         mpdm_unref(md);
2038         mpdm_unref(pr);
2039     }
2040     else
2041         v = NULL;
2042
2043     mpdm_unref(mode);
2044     mpdm_unref(prg);
2045
2046     return v;
2047 }
2048
2049
2050 /**
2051  * mpdm_popen2 - Opens a pipe and returns 2 descriptors.
2052  * @prg: the program to pipe
2053  *
2054  * Opens a read-write pipe and returns an array of two descriptors,
2055  * one for reading and one for writing. If @prg could not be piped to,
2056  * returns NULL.
2057  * [File Management]
2058  */
2059 mpdm_t mpdm_popen2(const mpdm_t prg)
2060 {
2061     mpdm_t i, o;
2062     mpdm_t p = NULL;
2063
2064     if ((i = mpdm_popen(prg, MPDM_AS(L"r+"))) != NULL) {
2065         struct mpdm_file *ifs;
2066         struct mpdm_file *ofs;
2067
2068         o = MPDM_C(i->flags, (void *)i->data, i->size);
2069
2070         ifs = (struct mpdm_file *)i->data;
2071         ofs = (struct mpdm_file *)o->data;
2072
2073         ofs->in = ifs->out;
2074         ifs->out = NULL;
2075
2076 #ifdef CONFOPT_WIN32
2077         ofs->hin = ifs->hout;
2078         ifs->hout = NULL;
2079 #endif
2080
2081         p = mpdm_ref(MPDM_A(2));
2082         mpdm_aset(p, i, 0);
2083         mpdm_aset(p, o, 1);
2084         mpdm_unrefnd(p);
2085     }
2086
2087     return p;
2088 }
2089
2090
2091 /**
2092  * mpdm_pclose - Closes a pipe.
2093  * @fd: the value containing the file descriptor
2094  *
2095  * Closes a pipe.
2096  * [File Management]
2097  */
2098 mpdm_t mpdm_pclose(mpdm_t fd)
2099 {
2100     mpdm_t r = NULL;
2101
2102     mpdm_ref(fd);
2103
2104     if ((fd->flags & MPDM_FILE) && fd->data != NULL) {
2105         r = MPDM_I(sysdep_pclose(fd));
2106         destroy_mpdm_file(fd);
2107     }
2108
2109     fd = mpdm_unref(fd);
2110
2111     return r;
2112 }
2113
2114
2115 /**
2116  * mpdm_home_dir - Returns the home user directory.
2117  *
2118  * Returns a system-dependent directory where the user can write
2119  * documents and create subdirectories.
2120  * [File Management]
2121  */
2122 mpdm_t mpdm_home_dir(void)
2123 {
2124     mpdm_t r = NULL;
2125     char *ptr;
2126     char tmp[512] = "";
2127
2128 #ifdef CONFOPT_WIN32
2129
2130     LPITEMIDLIST pidl;
2131
2132     /* get the 'My Documents' folder */
2133     SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl);
2134     SHGetPathFromIDList(pidl, tmp);
2135     strcat(tmp, "\\");
2136
2137 #endif
2138
2139 #ifdef CONFOPT_PWD_H
2140
2141     struct passwd *p;
2142
2143     /* get home dir from /etc/passwd entry */
2144     if (tmp[0] == '\0' && (p = getpwuid(getpid())) != NULL) {
2145         strcpy(tmp, p->pw_dir);
2146         strcat(tmp, "/");
2147     }
2148
2149 #endif
2150
2151     /* still none? try the ENV variable $HOME */
2152     if (tmp[0] == '\0' && (ptr = getenv("HOME")) != NULL) {
2153         strcpy(tmp, ptr);
2154         strcat(tmp, "/");
2155     }
2156
2157     if (tmp[0] != '\0')
2158         r = MPDM_MBS(tmp);
2159
2160     return r;
2161 }
2162
2163
2164 /**
2165  * mpdm_app_dir - Returns the applications directory.
2166  *
2167  * Returns a system-dependent directory where the applications store
2168  * their private data, as components or resources.
2169  * [File Management]
2170  */
2171 mpdm_t mpdm_app_dir(void)
2172 {
2173     mpdm_t r = NULL;
2174
2175 #ifdef CONFOPT_WIN32
2176
2177     HKEY hkey;
2178     char tmp[MAX_PATH];
2179     LPITEMIDLIST pidl;
2180
2181     /* get the 'Program Files' folder (can fail) */
2182     tmp[0] = '\0';
2183     if (SHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidl) ==
2184         S_OK)
2185         SHGetPathFromIDList(pidl, tmp);
2186
2187     /* if it's still empty, get from the registry */
2188     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
2189                      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion",
2190                      0, KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) {
2191         int n = sizeof(tmp);
2192
2193         if (RegQueryValueEx(hkey, "ProgramFilesDir",
2194                             NULL, NULL, tmp,
2195                             (LPDWORD) & n) != ERROR_SUCCESS)
2196             tmp[0] = '\0';
2197     }
2198
2199     if (tmp[0] != '\0') {
2200         strcat(tmp, "\\");
2201         r = MPDM_MBS(tmp);
2202     }
2203 #endif
2204
2205     /* still none? get the configured directory */
2206     if (r == NULL)
2207         r = MPDM_MBS(CONFOPT_PREFIX "/share/");
2208
2209     return r;
2210 }