workbench/libs/codesets/src/base64.c

   1 /***************************************************************************
   2
   3  codesets.library - Amiga shared library for handling different codesets
   4  Copyright (C) 2001-2005 by Alfonso [alfie] Ranieri <alforan@tin.it>.
   5  Copyright (C) 2005-2014 codesets.library Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  codesets.library project: http://sourceforge.net/projects/codesetslib/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include "lib.h"
  24 #include "SDI_stdarg.h"
  25 #include "debug.h"
  26
  27 /****************************************************************************/
  28
  29 struct b64
  30 {
  31   APTR   in;
  32   APTR   out;
  33   ULONG  flags;
  34   int    inIndex;
  35   int    inAvailable;
  36   int    outIndex;
  37   int    maxLineLen;
  38   int    lineCounter;
  39   const char *eols;
  40   LONG   error;
  41 };
  42
  43 enum
  44 {
  45   B64FLG_SourceFile = 1<<0,
  46   B64FLG_DestFile   = 1<<1,
  47   B64FLG_Unix       = 1<<2,
  48 };
  49
  50 /****************************************************************************/
  51
  52 #define MAXLINELEN 72
  53
  54 #ifndef EOF
  55 #define EOF (-1)
  56 #endif
  57
  58 /****************************************************************************/
  59
  60 static const UBYTE etable[] =
  61 {
  62    65,   66,   67,   68,   69,   70,   71,   72,   73,   74,
  63    75,   76,   77,   78,   79,   80,   81,   82,   83,   84,
  64    85,   86,   87,   88,   89,   90,   97,   98,   99,  100,
  65   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
  66   111,  112,  113,  114,  115,  116,  117,  118,  119,  120,
  67   121,  122,   48,   49,   50,   51,   52,   53,   54,   55,
  68    56,   57,   43,   47,    0,    0,    0,    0,    0,    0,
  69     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  70     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  71     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  72     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  73     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  74     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  75     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  76     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  77     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  78     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  79     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  80     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  81     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  82     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  83     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  84     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  85     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  86     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  87     0,    0,    0,    0,    0,    0
  88 };
  89
  90 static const UBYTE dtable[] =
  91 {
  92   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  93   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  94   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  95   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  96   128,  128,  128,   62,  128,  128,  128,   63,   52,   53,
  97    54,   55,   56,   57,   58,   59,   60,   61,  128,  128,
  98   128,    0,  128,  128,  128,    0,    1,    2,    3,    4,
  99     5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
 100    15,   16,   17,   18,   19,   20,   21,   22,   23,   24,
 101    25,  128,  128,  128,  128,  128,  128,   26,   27,   28,
 102    29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
 103    39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
 104    49,   50,   51,  128,  128,  128,  128,  128,  128,  128,
 105   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 106   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 107   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 108   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 109   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 110   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 111   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 112   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 113   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 114   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 115   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 116   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 117   128,  128,  128,  128,  128,    0
 118 };
 119
 120 /****************************************************************************/
 121
 122 #if defined(__amigaos4__)
 123 static BPTR openIn(STRPTR name, int64 *size)
 124 {
 125   BPTR file = 0;
 126   struct ExamineData *exd;
 127
 128   ENTER();
 129
 130   if((exd = ExamineObjectTags(EX_StringNameInput, name, TAG_END)) != NULL)
 131   {
 132     if(EXD_IS_FILE(exd))
 133     {
 134       if((file = Open(name, MODE_OLDFILE)))
 135         *size = exd->FileSize;
 136     }
 137
 138     FreeDosObject(DOS_EXAMINEDATA, exd);
 139   }
 140
 141   RETURN(file);
 142   return file;
 143 }
 144
 145 #elif defined(__MORPHOS__)
 146 static BPTR openIn(STRPTR name, ULONG *size)
 147 {
 148   struct FileInfoBlock fib;
 149   BPTR file;
 150
 151   ENTER();
 152
 153   if((file = Open(name, MODE_OLDFILE)))
 154   {
 155     if(!ExamineFH(file, &fib))
 156     {
 157       Close(file);
 158       file = 0;
 159     }
 160     else
 161     {
 162       *size = fib.fib_Size;
 163     }
 164   }
 165
 166   RETURN(file);
 167   return file;
 168 }
 169 #else
 170 static BPTR openIn(STRPTR name, ULONG * size)
 171 {
 172   struct FileInfoBlock *fib;
 173   BPTR file;
 174
 175   ENTER();
 176
 177   if((fib = AllocDosObject(DOS_FIB,NULL)) != NULL)
 178   {
 179     if((file = Open(name, MODE_OLDFILE)))
 180     {
 181       if(!ExamineFH(file, fib))
 182       {
 183         Close(file);
 184         file = 0;
 185       }
 186       else
 187       {
 188         *size = fib->fib_Size;
 189       }
 190     }
 191
 192     FreeDosObject(DOS_FIB, fib);
 193   }
 194   else
 195     file = 0;
 196
 197   RETURN(file);
 198   return file;
 199 }
 200 #endif
 201
 202 /****************************************************************************/
 203
 204 static int inchar(struct b64 *b64)
 205 {
 206   int c;
 207
 208   ENTER();
 209
 210   if(b64->flags & B64FLG_SourceFile)
 211   {
 212     if((c = FGetC((BPTR)b64->in)) == EOF)
 213     {
 214       if(IoErr() != 0)
 215         b64->error = CSR_B64_ERROR_DOS;
 216     }
 217   }
 218   else
 219   {
 220     if(b64->inAvailable == 0)
 221     {
 222       RETURN(EOF);
 223       return EOF;
 224     }
 225
 226     c = ((STRPTR)b64->in)[b64->inIndex++];
 227     b64->inAvailable--;
 228   }
 229
 230   RETURN(c);
 231   return c;
 232 }
 233
 234 /****************************************************************************/
 235
 236 static int ochar(struct b64 *b64, int c)
 237 {
 238   ENTER();
 239
 240   if(b64->flags & B64FLG_DestFile)
 241   {
 242     int r = 0;
 243
 244     if(b64->maxLineLen && (b64->lineCounter>=b64->maxLineLen))
 245     {
 246       r = FPuts((BPTR)b64->out,b64->eols);
 247       b64->lineCounter = 0;
 248     }
 249
 250     if(!r)
 251     {
 252       r = FPutC((BPTR)b64->out,c);
 253     }
 254
 255     if(r==EOF)
 256     {
 257       b64->error = CSR_B64_ERROR_DOS;
 258
 259       RETURN(EOF);
 260       return EOF;
 261     }
 262
 263     b64->lineCounter++;
 264   }
 265   else
 266   {
 267     ((STRPTR)b64->out)[b64->outIndex++] = c;
 268   }
 269
 270   RETURN(0);
 271   return 0;
 272 }
 273
 274 /****************************************************************************/
 275
 276 static int ostring(struct b64 *b64, UBYTE * buf, int s)
 277 {
 278   int i;
 279
 280   ENTER();
 281
 282   if(b64->flags & B64FLG_DestFile)
 283   {
 284     int r;
 285
 286     for(r = i = 0; (r!=EOF) && (i<s); i++)
 287     {
 288       r = FPutC((BPTR)b64->out,buf[i]);
 289     }
 290
 291     if(r==EOF)
 292     {
 293       b64->error = CSR_B64_ERROR_DOS;
 294
 295       RETURN(EOF);
 296       return EOF;
 297     }
 298   }
 299   else
 300   {
 301     for(i = 0; i<s; i++)
 302       ((STRPTR)b64->out)[b64->outIndex++] = buf[i];
 303   }
 304
 305   RETURN(0);
 306   return 0;
 307 }
 308
 309 /****************************************************************************/
 310
 311 static int insig(struct b64 *b64)
 312 {
 313   int c;
 314
 315   for(;;)
 316   {
 317     c = inchar(b64);
 318
 319     if((c==EOF) || (c>' '))
 320     {
 321       RETURN(c);
 322       return c;
 323     }
 324   }
 325 }
 326
 327 /****************************************************************************/
 328
 329 LIBPROTO(CodesetsEncodeB64A, ULONG, REG(a6, UNUSED __BASE_OR_IFACE), REG(a0, struct TagItem *attrs))
 330 {
 331   struct b64     b64;
 332   struct TagItem *tag;
 333   STRPTR         source;
 334   APTR           dest, in, out;
 335   ULONG          totSize, stop, flags;
 336   #if defined(__amigaos4__)
 337   int64          size;
 338   #else
 339   ULONG          size;
 340   #endif
 341   int            sourceLen = 0, maxLineLen;
 342
 343   flags = 0;
 344
 345   if((tag = FindTagItem(CSA_B64SourceFile, attrs)) != NULL)
 346   {
 347     source = (STRPTR)tag->ti_Data;
 348     flags |= B64FLG_SourceFile;
 349   }
 350   else
 351   {
 352     if((source = (STRPTR)GetTagData(CSA_B64SourceString, 0, attrs)) == NULL)
 353     {
 354       RETURN(CSR_B64_ERROR_MEM);
 355       return CSR_B64_ERROR_MEM;
 356     }
 357
 358     if((tag = FindTagItem(CSA_B64SourceLen, attrs)) != NULL)
 359       sourceLen = tag->ti_Data;
 360     else
 361       sourceLen = strlen(source);
 362   }
 363
 364   if((tag = FindTagItem(CSA_B64DestFile, attrs)) != NULL)
 365   {
 366     dest = (APTR)tag->ti_Data;
 367     flags |= B64FLG_DestFile;
 368   }
 369   else
 370   {
 371     if((dest = (APTR)GetTagData(CSA_B64DestPtr, 0, attrs)) == NULL)
 372     {
 373       RETURN(CSR_B64_ERROR_MEM);
 374       return CSR_B64_ERROR_MEM;
 375     }
 376   }
 377
 378   maxLineLen = GetTagData(CSA_B64MaxLineLen,0,attrs);
 379   if(maxLineLen<=0 || maxLineLen>=256)
 380     maxLineLen = MAXLINELEN;
 381
 382   if(GetTagData(CSA_B64Unix,TRUE,attrs))
 383     flags |= B64FLG_Unix;
 384
 385   /* source */
 386   if(flags & B64FLG_SourceFile)
 387   {
 388     if(!(in = (APTR)openIn(source,&size)))
 389     {
 390       RETURN(CSR_B64_ERROR_DOS);
 391       return CSR_B64_ERROR_DOS;
 392     }
 393
 394     b64.inAvailable = 0;
 395   }
 396   else
 397   {
 398     in = source;
 399     size = sourceLen;
 400     b64.inAvailable = size;
 401   }
 402
 403   totSize = size<<1;
 404
 405   /* dest */
 406   if(flags & B64FLG_DestFile)
 407   {
 408     if(!(out = (APTR)Open(dest,MODE_NEWFILE)))
 409     {
 410       RETURN(CSR_B64_ERROR_DOS);
 411       return CSR_B64_ERROR_DOS;
 412     }
 413   }
 414   else
 415   {
 416     if(!totSize)
 417       totSize = 8;
 418
 419     if((out = allocArbitrateVecPooled(totSize)) == NULL)
 420     {
 421       if(flags & B64FLG_SourceFile)
 422         Close((BPTR)in);
 423
 424       RETURN(CSR_B64_ERROR_MEM);
 425       return CSR_B64_ERROR_MEM;
 426     }
 427
 428     *((STRPTR *)dest) = out;
 429   }
 430
 431   /* set globals */
 432   b64.in          = in;
 433   b64.out         = out;
 434   b64.flags       = flags;
 435   b64.inIndex     = 0;
 436   b64.outIndex    = 0;
 437   b64.maxLineLen  = maxLineLen;
 438   b64.lineCounter = 0;
 439   b64.eols        = (flags & B64FLG_Unix) ? "\n" : "\r\n";
 440   b64.error       = 0;
 441
 442   /* encode */
 443   stop = FALSE;
 444   while(stop == FALSE)
 445   {
 446     UBYTE    igroup[3], ogroup[4];
 447     int i, c, n;
 448
 449     igroup[0] = igroup[1] = igroup[2] = 0;
 450
 451     for(n = 0; n<3; n++)
 452     {
 453       c = inchar(&b64);
 454       if(c==EOF)
 455       {
 456         stop = TRUE;
 457         break;
 458       }
 459
 460       igroup[n] = (UBYTE) c;
 461     }
 462
 463     if(n>0)
 464     {
 465       ogroup[0] = etable[igroup[0]>>2];
 466       ogroup[1] = etable[((igroup[0] & 3)<<4) | (igroup[1]>>4)];
 467       ogroup[2] = etable[((igroup[1] & 0xF)<<2) | (igroup[2]>>6)];
 468       ogroup[3] = etable[igroup[2] & 0x3F];
 469
 470       if(n<3)
 471       {
 472         ogroup[3] = '=';
 473         if(n<2)
 474           ogroup[2] = '=';
 475       }
 476
 477       for(i=0; i<4; i++)
 478       {
 479         c = ochar(&b64,ogroup[i]);
 480         if(c==EOF)
 481         {
 482           stop = TRUE;
 483           break;
 484         }
 485       }
 486     }
 487   }
 488
 489   if(!(b64.flags & B64FLG_DestFile))
 490     ((STRPTR)out)[b64.outIndex] = 0;
 491
 492   /* close source */
 493   if(flags & B64FLG_SourceFile)
 494     Close((BPTR)in);
 495
 496   /* flush and close dest */
 497   if(flags & B64FLG_DestFile)
 498   {
 499     if(!b64.error)
 500     {
 501       if(FPuts((BPTR)out,b64.eols)==EOF)
 502         b64.error = CSR_B64_ERROR_DOS;
 503
 504       #if defined(__amigaos4__)
 505       FFlush((BPTR)out);
 506       #else
 507       Flush((BPTR)out);
 508       #endif
 509     }
 510
 511     Close((BPTR)out);
 512   }
 513   else
 514   {
 515     if(b64.error)
 516       freeArbitrateVecPooled(out);
 517   }
 518
 519   RETURN((ULONG)b64.error);
 520   return (ULONG)b64.error;
 521 }
 522
 523 #if defined(__amigaos4__)
 524 LIBPROTOVA(CodesetsEncodeB64, ULONG, REG(a6, UNUSED __BASE_OR_IFACE), ...)
 525 {
 526   ULONG res;
 527   VA_LIST args;
 528
 529   VA_START(args, ICodesets);
 530   res = CodesetsEncodeB64A(VA_ARG(args, struct TagItem *));
 531   VA_END(args);
 532
 533   return res;
 534 }
 535 #endif
 536
 537 /****************************************************************************/
 538
 539 LIBPROTO(CodesetsDecodeB64A, ULONG, REG(a6, UNUSED __BASE_OR_IFACE), REG(a0, struct TagItem *attrs))
 540 {
 541   struct b64              b64;
 542   struct TagItem *tag;
 543   STRPTR         source;
 544   APTR           dest, in, out;
 545   ULONG          totSize, flags, errcheck;
 546   #if defined(__amigaos4__)
 547   int64          size;
 548   #else
 549   ULONG          size;
 550   #endif
 551   int            sourceLen = 0;
 552
 553   ENTER();
 554
 555   flags = 0;
 556
 557   if((tag = FindTagItem(CSA_B64SourceFile, attrs)) != NULL)
 558   {
 559     source = (STRPTR)tag->ti_Data;
 560     flags |= B64FLG_SourceFile;
 561   }
 562   else
 563   {
 564     if ((source = (STRPTR)GetTagData(CSA_B64SourceString, 0, attrs)) == NULL)
 565     {
 566       RETURN(CSR_B64_ERROR_MEM);
 567       return CSR_B64_ERROR_MEM;
 568     }
 569
 570     if((tag = FindTagItem(CSA_B64SourceLen, attrs)) != NULL)
 571       sourceLen = tag->ti_Data;
 572     else
 573       sourceLen = strlen(source);
 574   }
 575
 576   if((tag = FindTagItem(CSA_B64DestFile, attrs)) != NULL)
 577   {
 578     dest = (APTR)tag->ti_Data;
 579     flags |= B64FLG_DestFile;
 580   }
 581   else
 582   {
 583     if((dest = (APTR)GetTagData(CSA_B64DestPtr, 0, attrs)) == NULL)
 584     {
 585       RETURN(CSR_B64_ERROR_MEM);
 586       return CSR_B64_ERROR_MEM;
 587     }
 588   }
 589
 590   /* source */
 591   if(flags & B64FLG_SourceFile)
 592   {
 593     if(!(in = (APTR)openIn(source, &size)))
 594     {
 595       RETURN(CSR_B64_ERROR_DOS);
 596       return CSR_B64_ERROR_DOS;
 597     }
 598
 599     b64.inAvailable = 0;
 600   }
 601   else
 602   {
 603     in = source;
 604     size = sourceLen;
 605     b64.inAvailable = size;
 606   }
 607
 608   totSize = size<<1;
 609
 610   /* dest */
 611   if(flags & B64FLG_DestFile)
 612   {
 613     if(!(out = (APTR)Open(dest, MODE_NEWFILE)))
 614     {
 615       RETURN(CSR_B64_ERROR_DOS);
 616       return CSR_B64_ERROR_DOS;
 617     }
 618   }
 619   else
 620   {
 621     if(!totSize)
 622       totSize = 8;
 623
 624     if(!(out = allocArbitrateVecPooled(totSize)))
 625     {
 626       if(flags & B64FLG_SourceFile)
 627         Close((BPTR)in);
 628
 629       RETURN(CSR_B64_ERROR_MEM);
 630       return CSR_B64_ERROR_MEM;
 631     }
 632
 633     *((STRPTR *)dest) = out;
 634   }
 635
 636   b64.in          = in;
 637   b64.out         = out;
 638   b64.flags       = flags;
 639   b64.inIndex     = 0;
 640   b64.outIndex    = 0;
 641   b64.maxLineLen  = 0;
 642   b64.lineCounter = 0;
 643   b64.eols        = NULL;
 644   b64.error       = 0;
 645
 646   /* parse error check */
 647   errcheck = !GetTagData(CSA_B64FLG_NtCheckErr, FALSE, attrs);
 648
 649   /* decode */
 650   for(;;)
 651   {
 652     UBYTE a[4], b[4], o[3];
 653     int i;
 654
 655     for(i = 0; i<4; i++)
 656     {
 657       int c = insig (&b64);
 658
 659       if(c==EOF)
 660       {
 661         if(!(b64.flags & B64FLG_DestFile))
 662           ((STRPTR)out)[b64.outIndex] = 0;
 663
 664         if(!b64.error && errcheck && (i>0))
 665           b64.error = CSR_B64_ERROR_INCOMPLETE;
 666
 667         goto end;
 668       }
 669
 670       if(dtable[c] & 0x80)
 671       {
 672         if(errcheck)
 673         {
 674           b64.error = CSR_B64_ERROR_ILLEGAL;
 675
 676           goto end;
 677         }
 678
 679         i--;
 680         continue;
 681       }
 682
 683       a[i] = (UBYTE) c;
 684       b[i] = (UBYTE) dtable[c];
 685     }
 686
 687     o[0] = (b[0]<<2) | (b[1]>>4);
 688     o[1] = (b[1]<<4) | (b[2]>>2);
 689     o[2] = (b[2]<<6) | b[3];
 690
 691     i = a[2]=='=' ? 1 : (a[3]=='=' ? 2 : 3);
 692
 693     if(ostring(&b64,o,i)==EOF || i < 3)
 694       goto end;
 695   }
 696
 697 end:
 698
 699   /* close source */
 700   if(flags & B64FLG_SourceFile)
 701     Close((BPTR)in);
 702
 703   /* flush and close dest */
 704   if(flags & B64FLG_DestFile)
 705   {
 706     if(!b64.error)
 707     {
 708       if(FPuts((BPTR)out,b64.eols)==EOF)
 709         b64.error = CSR_B64_ERROR_DOS;
 710
 711       #if defined(__amigaos4__)
 712       FFlush((BPTR)out);
 713       #else
 714       Flush((BPTR)out);
 715       #endif
 716     }
 717
 718     Close((BPTR)out);
 719   }
 720   else
 721   {
 722     if(b64.error)
 723       freeArbitrateVecPooled(out);
 724   }
 725
 726   RETURN((ULONG)b64.error);
 727   return (ULONG)b64.error;
 728 }
 729
 730 #if defined(__amigaos4__)
 731 LIBPROTOVA(CodesetsDecodeB64, ULONG, REG(a6, UNUSED __BASE_OR_IFACE), ...)
 732 {
 733   ULONG res;
 734   VA_LIST args;
 735
 736   VA_START(args, ICodesets);
 737   res = CodesetsDecodeB64A(VA_ARG(args, struct TagItem *));
 738   VA_END(args);
 739
 740   return res;
 741 }
 742 #endif
 743
 744 /****************************************************************************/