home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / mpack-1.3-amiga_src.lha / codes.c < prev    next >
C/C++ Source or Header  |  1994-05-10  |  11KB  |  371 lines
  1. /* (C) Copyright 1993 by John G. Myers
  2.  * All Rights Reserved.
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software
  5.  * and its documentation for any purpose is hereby granted without
  6.  * fee, provided that the above copyright notice appear in all copies
  7.  * and that both that copyright notice and this permission notice
  8.  * appear in supporting documentation, and that the name of John G.
  9.  * Myers not be used in advertising or publicity pertaining to
  10.  * distribution of the software without specific, written prior
  11.  * permission.  John G. Myers makes no representations about the
  12.  * suitability of this software for any purpose.  It is provided "as
  13.  * is" without express or implied warranty.
  14.  *
  15.  * JOHN G. MYERS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  16.  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17.  * FITNESS, IN NO EVENT SHALL JOHN G. MYERS BE LIABLE FOR ANY SPECIAL,
  18.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  19.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  21.  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  */
  23. /*
  24. Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
  25.  
  26. Permission to use, copy, modify, and distribute this material 
  27. for any purpose and without fee is hereby granted, provided 
  28. that the above copyright notice and this permission notice 
  29. appear in all copies, and that the name of Bellcore not be 
  30. used in advertising or publicity pertaining to this 
  31. material without the specific, prior written permission 
  32. of an authorized representative of Bellcore.  BELLCORE 
  33. MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY 
  34. OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS", 
  35. WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
  36. */
  37. #include <stdio.h>
  38. #include <string.h>
  39. #include <ctype.h>
  40. #include "xmalloc.h"
  41. #include "md5.h"
  42.  
  43. static char basis_64[] =
  44.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  45.  
  46. static char index_64[128] = {
  47.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  48.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  49.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
  50.     52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
  51.     -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  52.     15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
  53.     -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  54.     41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
  55. };
  56.  
  57. #define char64(c)  (((c) < 0 || (c) > 127) ? -1 : index_64[(c)])
  58.  
  59. static char index_hex[128] = {
  60.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  61.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  62.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  63.      0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
  64.     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  65.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  66.     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  67.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
  68. };
  69.  
  70. #define hexchar(c)  (((c) < 0 || (c) > 127) ? -1 : index_hex[(c)])
  71.  
  72. int to64(infile, outfile, limit) 
  73. FILE *infile, *outfile;
  74. long limit;
  75. {
  76.     int c1, c2, c3, ct=0, written=0;
  77.  
  78.     if (limit && limit < 73) return 1;
  79.  
  80.     while ((c1 = getc(infile)) != EOF) {
  81.         c2 = getc(infile);
  82.         if (c2 == EOF) {
  83.             output64chunk(c1, 0, 0, 2, outfile);
  84.         } else {
  85.             c3 = getc(infile);
  86.             if (c3 == EOF) {
  87.                 output64chunk(c1, c2, 0, 1, outfile);
  88.             } else {
  89.                 output64chunk(c1, c2, c3, 0, outfile);
  90.             }
  91.         }
  92.         ct += 4;
  93.         if (ct > 71) {
  94.             putc('\n', outfile);
  95.         if (limit) {
  96.         limit -= ct + 1;
  97.         if (limit < 73) return 1;
  98.         }
  99.         written += 73;
  100.             ct = 0;
  101.         }
  102.     }
  103.     if (ct) {
  104.     putc('\n', outfile);
  105.     ct++;
  106.     }
  107.     return written + ct;
  108. }
  109.  
  110. output64chunk(c1, c2, c3, pads, outfile)
  111. FILE *outfile;
  112. {
  113.     putc(basis_64[c1>>2], outfile);
  114.     putc(basis_64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)], outfile);
  115.     if (pads == 2) {
  116.         putc('=', outfile);
  117.         putc('=', outfile);
  118.     } else if (pads) {
  119.         putc(basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)], outfile);
  120.         putc('=', outfile);
  121.     } else {
  122.         putc(basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)], outfile);
  123.         putc(basis_64[c3 & 0x3F], outfile);
  124.     }
  125. }
  126.  
  127. PendingBoundary(s, Boundaries, BoundaryCt)
  128. char *s;
  129. char **Boundaries;
  130. int *BoundaryCt;
  131. {
  132.     int i, len;
  133.  
  134.     if (s[0] != '-' || s[1] != '-') return(0);
  135.     s+=2;
  136.  
  137.     for (i=0; i < *BoundaryCt; ++i) {
  138.     len = strlen(Boundaries[i]);
  139.         if (!strncmp(s, Boundaries[i], len)) {
  140.             if (s[len] == '-' && s[len+1] == '-') *BoundaryCt = i;
  141.             return(1);
  142.         }
  143.     }
  144.     return(0);
  145. }
  146.  
  147. static char *md5contextTo64(context)
  148. MD5_CTX *context;
  149. {
  150.     unsigned char digest[18];
  151.     char encodedDigest[25];
  152.     int i;
  153.     char *p;
  154.  
  155.     MD5Final(digest, context);
  156.     digest[sizeof(digest)-1] = digest[sizeof(digest)-2] = 0;
  157.  
  158.     p = encodedDigest;
  159.     for (i=0; i < sizeof(digest); i+=3) {
  160.     *p++ = basis_64[digest[i]>>2];
  161.     *p++ = basis_64[((digest[i] & 0x3)<<4) | ((digest[i+1] & 0xF0)>>4)];
  162.     *p++ = basis_64[((digest[i+1] & 0xF)<<2) | ((digest[i+2] & 0xC0)>>6)];
  163.     *p++ = basis_64[digest[i+2] & 0x3F];
  164.     }
  165.     *p-- = '\0';
  166.     *p-- = '=';
  167.     *p-- = '=';
  168.     return strsave(encodedDigest);
  169. }    
  170.  
  171.  
  172. from64(infile, outfile, digestp, suppressCR, boundaries, boundaryct) 
  173. FILE *infile, *outfile;
  174. char **digestp;
  175. int suppressCR;
  176. char **boundaries;
  177. int *boundaryct;
  178. {
  179.     int c1, c2, c3, c4;
  180.     int newline = 1, DataDone = 0;
  181.     char buf[3];
  182.     MD5_CTX context;
  183.  
  184.     if (digestp) MD5Init(&context);
  185.     while ((c1 = getc(infile)) != EOF) {
  186.         if (isspace(c1)) {
  187.             if (c1 == '\n') {
  188.                 newline = 1;
  189.             } else {
  190.                 newline = 0;
  191.             }
  192.             continue;
  193.         }
  194.         if (newline && boundaries && c1 == '-') {
  195.             char Buf[200];
  196.             /* a dash is NOT base 64, so all bets are off if NOT a boundary */
  197.             ungetc(c1, infile);
  198.             fgets(Buf, sizeof(Buf), infile);
  199.             if (boundaries
  200.                  && (Buf[0] == '-')
  201.                  && (Buf[1] == '-')
  202.                  && PendingBoundary(Buf, boundaries, boundaryct)) {
  203.                 break;
  204.             }
  205.             warn("Ignoring unrecognized boundary line");
  206.             continue;
  207.         }
  208.         if (DataDone) continue;
  209.         newline = 0;
  210.         do {
  211.             c2 = getc(infile);
  212.         } while (c2 != EOF && isspace(c2));
  213.         do {
  214.             c3 = getc(infile);
  215.         } while (c3 != EOF && isspace(c3));
  216.         do {
  217.             c4 = getc(infile);
  218.         } while (c4 != EOF && isspace(c4));
  219.         if (c2 == EOF || c3 == EOF || c4 == EOF) {
  220.             warn("Premature EOF");
  221.             break;
  222.         }
  223.         if (c1 == '=' || c2 == '=') {
  224.             DataDone=1;
  225.             continue;
  226.         }
  227.         c1 = char64(c1);
  228.         c2 = char64(c2);
  229.     buf[0] = ((c1<<2) | ((c2&0x30)>>4));
  230.         if (!suppressCR || buf[0] != '\r') putc(buf[0], outfile);
  231.         if (c3 == '=') {
  232.         if (digestp) MD5Update(&context, buf, 1);
  233.             DataDone = 1;
  234.         } else {
  235.             c3 = char64(c3);
  236.         buf[1] = (((c2&0XF) << 4) | ((c3&0x3C) >> 2));
  237.             if (!suppressCR || buf[1] != '\r') putc(buf[1], outfile);
  238.             if (c4 == '=') {
  239.         if (digestp) MD5Update(&context, buf, 2);
  240.                 DataDone = 1;
  241.             } else {
  242.                 c4 = char64(c4);
  243.         buf[2] = (((c3&0x03) <<6) | c4);
  244.                 if (!suppressCR || buf[2] != '\r') putc(buf[2], outfile);
  245.         if (digestp) MD5Update(&context, buf, 3);        
  246.             }
  247.         }
  248.     }
  249.     if (digestp) *digestp = md5contextTo64(&context);
  250. }
  251.  
  252. fromqp(infile, outfile, digestp, boundaries, boundaryct) 
  253. FILE *infile, *outfile;
  254. char **digestp;
  255. char **boundaries;
  256. int *boundaryct;
  257. {
  258.     int c1, c2, sawnewline = 1, neednewline = 0;
  259.     /* The neednewline hack is necessary because the newline leading into 
  260.       a multipart boundary is part of the boundary, not the data */
  261.     MD5_CTX context;
  262.     char Buf[200], *s;
  263.     char c;
  264.  
  265.     if (digestp) MD5Init(&context);
  266.  
  267.     while (fgets(Buf, sizeof(Buf), infile)) {
  268.     if (sawnewline && boundaries
  269.         && (Buf[0] == '-')
  270.         && (Buf[1] == '-')
  271.         && PendingBoundary(Buf, boundaries, boundaryct)) {
  272.         neednewline = 0;
  273.         break;
  274.         }
  275.     /* Not a boundary, now we must treat THIS line as q-p, sigh */
  276.     if (neednewline) {
  277.         putc('\n', outfile);
  278.         neednewline = 0;
  279.         if (digestp) MD5Update(&context, "\r\n", 2);
  280.     }
  281.     for (s=Buf; *s; ++s) {
  282.         if (*s == '=') {
  283.         if (!*++s) break;
  284.         if (*s == '\n') {
  285.             /* ignore it */
  286.             sawnewline = 1;
  287.         } else {
  288.             c1 = hexchar(*s);
  289.             if (!*++s) break;
  290.             c2 = hexchar(*s);
  291.             c = c1<<4 | c2;
  292.             putc(c, outfile);
  293.             if (digestp) MD5Update(&context, &c, 1);
  294.         }
  295.         } else {
  296.         if (*s == '\n') {
  297.             sawnewline = 1;
  298.             neednewline = 1;
  299.         }
  300.         else {
  301.             putc(*s, outfile);
  302.             if (digestp) MD5Update(&context, s, 1);
  303.         }
  304.         }
  305.     }
  306.     }
  307.     if (neednewline) {
  308.         putc('\n', outfile);
  309.         neednewline = 0;
  310.     if (digestp) MD5Update(&context, "\r\n", 2);
  311.     }    
  312.     if (digestp) *digestp=md5contextTo64(&context);
  313. }
  314.  
  315. fromnone(infile, outfile, digestp, boundaries, boundaryct) 
  316. FILE *infile, *outfile;
  317. char **digestp;
  318. char **boundaries;
  319. int *boundaryct;
  320. {
  321.     char buf[1024], *p;
  322.     int startofline = 1, neednewline = 0;
  323.     MD5_CTX context;
  324.  
  325.     if (digestp) MD5Init(&context);
  326.  
  327.     while (fgets(buf, sizeof(buf)-1, infile)) {
  328.     if (startofline && PendingBoundary(buf, boundaries, boundaryct)) {
  329.         neednewline = 0;
  330.         break;
  331.     }
  332.     if (neednewline) {
  333.         putc('\n', outfile);
  334.         if (digestp) MD5Update(&context, "\r\n", 2);
  335.     }
  336.     if (p = strchr(buf, '\n')) {
  337.         *p = '\0';
  338.         startofline = neednewline = 1;
  339.     }
  340.     else {
  341.         startofline = neednewline = 0;
  342.     }
  343.     fputs(buf, outfile);
  344.     if (digestp) MD5Update(&context, buf, strlen(buf));
  345.     }
  346.     if (neednewline) {
  347.     putc('\n', outfile);
  348.     if (digestp) MD5Update(&context, "\r\n", 2);
  349.     }
  350.     if (digestp) *digestp=md5contextTo64(&context);
  351. }
  352.  
  353. char *md5digest(infile, len)
  354. FILE *infile;
  355. long *len;
  356. {
  357.     MD5_CTX context;
  358.     char buf[1000];
  359.     long length = 0;
  360.     int nbytes;
  361.     
  362.     MD5Init(&context);
  363.     while (nbytes = fread(buf, 1, sizeof(buf), infile)) {
  364.     length += nbytes;
  365.     MD5Update(&context, buf, nbytes);
  366.     }
  367.     rewind(infile);
  368.     if (len) *len = length;
  369.     return md5contextTo64(&context);
  370. }
  371.