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