home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / winsock / wvnsc926 / wvcoding.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  63.6 KB  |  2,102 lines
  1. /********************************************************************
  2.  *                                                                  *
  3.  *  MODULE    :  WVCODING.C                                         *
  4.  *                                                                  *
  5.  *  PURPOSE   : This file contains functions for en/decoding files  *
  6.  *                                                                  *
  7.  *  ENTRY POINTS:                                                   *
  8.  *            DecodeInit  - initializes decoding resources        *
  9.  *        DecodeDone  - frees decoding resources              *
  10.  *        InitCoded   - initializes a coded block             * 
  11.  *                  called for each new art to decode     *
  12.  *        DecodeLine  - Main decoding engine.  Called once    *
  13.  *                  for each input line                   *
  14.  *        DecodeFile  - Uses file instead of comm input as a  *
  15.  *                     line provider to the decoding engine  *
  16.  *        DecodeDoc   - Uses a Doc instead of comm input as a *
  17.  *                     line provider to the decoding engine  *
  18.  *    CompleteThisDecode  - Called at end of each article - adds  *
  19.  *                  block to appropriate decode thread,   *
  20.  *                  writes to disk if possible, etc       *
  21.  *                  Encode  - Encodes a file into a text block      *
  22.  *            EncodeToFile  - Calls Encode, then writes block to    * 
  23.  *                            an output file                        *
  24.  *                                                                  *
  25.  *  NOTES:                                                          *
  26.  *    Both the max # of batched decode files and the max #        * 
  27.  *    threads per file are fixed.  This should be made dynamic    *
  28.  *    at some point I guess.                                      *
  29.  *                                                                  *
  30.  * Author: John S. Cooper (jcooper@netcom.com)                      *
  31.  *   Date: Sept 13, 1993                                            *
  32.  *                                                                  *
  33.  * Let me know if you like this code, or if you re-use any piece of *
  34.  * it. I'm just curious to know what people think.                  *
  35.  ********************************************************************/
  36. /* 
  37.  * $Id: wvcoding.c 1.12 1994/09/18 22:44:20 jcooper Exp $
  38.  * $Log: wvcoding.c $
  39.  * Revision 1.12  1994/09/18  22:44:20  jcooper
  40.  * Better handling of status windows, using IsBusy flag, etc
  41.  *
  42.  * Revision 1.11  1994/09/16  00:58:48  jcooper
  43.  * new coding-status window style.  optimized info-header parser.
  44.  * general cleanup for 92.6
  45.  * 
  46.  * Revision 1.10  1994/08/24  18:00:29  jcooper
  47.  * misc encoding/decoding changes
  48.  *
  49.  * Revision 1.9  1994/08/11  21:03:19  rushing
  50.  * FindExecutable fix for NT
  51.  *
  52.  * Revision 1.8  1994/08/11  20:16:25  rushing
  53.  * bug fix
  54.  *
  55.  * Revision 1.6  1994/07/25  20:05:13  jcooper
  56.  * execution of decoded files
  57.  *
  58.  * Revision 1.5  1994/05/23  18:36:00  jcooper
  59.  * new attach code, session [dis]connect
  60.  *
  61.  * Revision 1.4  1994/03/01  19:14:22  rushing
  62.  * ifdef'd the DEBUG info
  63.  *
  64.  * Revision 1.3  1994/02/24  21:28:04  jcoop
  65.  * jcoop changes.
  66.  *
  67.  * Revision 1.2  1994/02/09  18:01:08  cnolan
  68.  * cnolan 90.2 changes
  69.  *
  70.  * Revision 1.1  1994/01/18  09:54:20  jcoop
  71.  * Initial revision
  72.  *
  73.  */ 
  74. #include <windows.h>
  75. #include <windowsx.h>
  76. #include "wvglob.h"
  77. #include "winvn.h"
  78. #pragma hdrstop
  79. #include <string.h>
  80. #include <stdio.h>
  81. #include <stdlib.h>
  82. #include <ctype.h>        /* for isspace, isalnum, etc */
  83.  
  84. #ifdef _DEBUG
  85. #define DEBUG_MAP
  86. #define DEBUG_MEM
  87. #define DEBUG_DECODE
  88. #endif
  89.  
  90. #define LOW        1    // sequence confidence levels
  91. #define HIGH            2
  92. #define UNUSED        127    // unused mapping slots
  93.  
  94. #define END_BLOCK    2
  95. #define CODE_LINE_LEN    45    
  96. /*
  97.  * Globals for this func
  98.  */
  99. char
  100.     xxTable[CODINGTABLESIZE] = "+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  101. char
  102.     uuTable[CODINGTABLESIZE] = "`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
  103. char
  104.     base64Table[CODINGTABLESIZE] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  105. char    *codingTable;
  106. char     customTable[CODINGTABLESIZE];
  107.  
  108. TypDecodeThread *threadList[MAX_DECODE_THREADS];
  109. int    numDecodeThreads;        // number of active decode threads
  110. int    currentDecodeThread;
  111. int    numDumbDecoded;
  112. BOOL    bossanovaMIME;                  // = TRUE if found MIME Version header
  113. int      thisNumBlocks;             // MIME vars for current block
  114. char     thisContentType[80];
  115. char    thisContentDesc[MAXINTERNALLINE];
  116. char    thisBoundary[MAXINTERNALLINE];
  117. int    thisContentEncoding, prevContentEncoding;
  118. char     prevBlockIdent[MAXFILENAME];
  119. /*
  120.  * Private functions
  121.  */
  122. int     EncodeLine (unsigned char *outLine, unsigned char *line, int start, int num);
  123. void    EncodeUnit (unsigned char *out, unsigned char *in, int num);
  124. int    GetThreadByName (char *name);
  125. int    AddToThreadList ();
  126. void     DestroyThread (int num);
  127. void    DestroyCodedBlock (TypCoded **thisCoded);
  128. void    InsertBlockInThread (int num, TypCoded *thisBlock, int index);
  129. void    DeleteBlockFromThread (int num, int index);
  130. BOOL    WriteDecodeThread(int num);
  131. BOOL    WriteBlockToFile(int num, TypCoded *thisDecode);
  132. BOOL    WriteTopBlockToFile (int num, int *endFlag);
  133. BOOL    AddDataToBlock (TypCoded *thisDecode, char *newData, unsigned int dataLen);
  134. void    ParseInfoLine (TypCoded *thisDecode, char *line, BOOL guessIdent);
  135. BOOL    ParseAppSpecificLine (TypCoded *thisDecode, char *line);
  136. char     *ReadSubjectToken (char *dest, char **ptr);
  137. BOOL    isnumber (char *str);
  138. BOOL    SearchThreadNames (char *name);
  139. int    ParseMimeHeaderLine (TypCoded *thisDecode, char *line);
  140. int    ParseMimeContentType (TypCoded *thisDecode, char *line);
  141.  
  142. void CreateCodingStatusWnd();
  143. int    DecodeDataLine (TypCoded *decode, char *line);
  144. void     CreateUUTable();
  145. BOOL    TestIgnoreLine (char *line);
  146. int    IsDataLine (char *line);
  147. BOOL     TestDataLine (char *line);
  148. int     ThreadTable (char *dest, char *name);
  149. void    UpdateThreadStatus (int num, char *str);
  150.  
  151. void    ExecuteDecodedFile (int num, char *fileName);
  152.  
  153. #if defined(DEBUG_DECODE) || defined(DEBUG_MEM)
  154. #define DEBUG_FILE "coding.log"
  155. void     DebugLog();
  156. void     InitDebugLog();
  157. char     debug[MAXCOMMLINE];
  158. OFSTRUCT debugFileStruct;
  159. #endif
  160.  
  161. #if defined(DEBUG_DECODE) || defined(DEBUG_MEM)
  162. /* ------------------------------------------------------------------------
  163.  * Debug log handler
  164.  * Open/close the file for every addition to log, so all info is safely
  165.  * captured in case of GPF
  166.  */
  167. void
  168. DebugLog ()
  169. {
  170.     HFILE hDebugFile;
  171.  
  172.         if ((hDebugFile = OpenFile ((char far *)NULL, &debugFileStruct, OF_REOPEN|OF_WRITE)) >= 0)
  173.     {       
  174.         _llseek(hDebugFile, 0L, 2);    /* go to end */
  175.             _lwrite(hDebugFile, debug, strlen(debug));
  176.             _lclose(hDebugFile);
  177.         }
  178. }
  179. void
  180. InitDebugLog ()
  181. {
  182.     HFILE hDebugFile;
  183.  
  184.         if ((hDebugFile = OpenFile ((char far *)DEBUG_FILE, &debugFileStruct, OF_CREATE)) >= 0)
  185.     {
  186.             sprintf(debug, "New log");
  187.             _lwrite(hDebugFile, debug, strlen(debug));
  188.             _lclose(hDebugFile);
  189.         }
  190. }
  191. #endif
  192. /* ------------------------------------------------------------------------
  193.  * Decode a file
  194.  * Uses a file instead of the comm article as a line-provider to the 
  195.  * decode routines
  196.  */
  197. void
  198. DecodeFile (HWND hParentWnd)
  199. {
  200.     FILE *DecodeFile;
  201.         char mybuf[MAXINTERNALLINE], fileName[MAXFILENAME], *ptr;
  202.         int result;
  203.  
  204.         if (AskForExistingFileName (hParentWnd, fileName, "Open encoded file") == FAIL)
  205.             return;
  206.  
  207.     DecodeInit();
  208.     if ((DecodeFile = fopen (fileName, "r")) == NULL)
  209.     {
  210.         MessageBox (hParentWnd, "Failure to read file", "File error", MB_OK);
  211.         return;
  212.     } 
  213.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  214.     {
  215.         MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  216.         return;
  217.     }
  218.            while (1)
  219.            {
  220.                if ((ptr = fgets(mybuf, MAXINTERNALLINE, DecodeFile)) == NULL)
  221.                    strcpy (mybuf, "EOF");    // make sure wrap up occurs
  222.  
  223.         result = DecodeLine (currentCoded, mybuf);
  224.         if (result == FAIL)
  225.         {
  226.                  MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  227.             goto abortDecodeFile;
  228.         }           
  229.         if (result == END_BLOCK)
  230.         {
  231.             if (CompleteThisDecode () == FAIL)
  232.             {
  233.                      MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  234.                 goto abortDecodeFile;
  235.             }           
  236.                if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  237.             {
  238.                 MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  239.                 goto abortDecodeFile;
  240.             }
  241.         }
  242.         if (ptr == NULL)    // EOF
  243.             break;
  244.     }
  245.  
  246.     if (currentCoded != NULL)    // finish final block
  247.         CompleteThisDecode ();
  248.    
  249.    abortDecodeFile:;
  250.           fclose(DecodeFile);
  251.     DecodeDone ();
  252. }
  253. /* ------------------------------------------------------------------------
  254.  * Decode a doc
  255.  * Uses a doc instead of the comm article as a line-provider to the 
  256.  * decode routines
  257.  */
  258. void
  259. DecodeDoc (HWND hParentWnd, TypDoc *Document)
  260. {
  261.         int result;
  262.     TypBlock far *BlockPtr;
  263.     TypLine far *LinePtr;
  264.             
  265.     DecodeInit();
  266.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  267.     {
  268.         MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  269.         return;
  270.     }
  271.     
  272.     LockLine (Document->hFirstBlock, sizeof (TypBlock), (TypLineID) 0L, &BlockPtr, &LinePtr);
  273.     while (LinePtr->length != END_OF_BLOCK)
  274.     {
  275.         result = DecodeLine (currentCoded, 
  276.                 ((char far *) LinePtr) + sizeof (TypText) + sizeof (TypLine));
  277.  
  278.         if (result == FAIL)
  279.         {
  280.                  MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  281.             goto abortDecodeDoc;
  282.         }           
  283.  
  284.         if (result == END_BLOCK)
  285.         {
  286.             if (CompleteThisDecode () == FAIL)
  287.             {
  288.                      MessageBox (hParentWnd, "Aborted decode", "Problems during decode", MB_OK | MB_ICONEXCLAMATION);
  289.                 goto abortDecodeDoc;
  290.             }           
  291.                if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  292.             {
  293.                 MessageBox (hParentWnd, "Unable to continue due to memory constraints.  Aborted", "Init Coded Object Error", MB_OK);
  294.                 return;
  295.             }
  296.         }
  297.         NextLine (&BlockPtr, &LinePtr);
  298.     }
  299.     if (currentCoded != NULL)    // finish final block
  300.         CompleteThisDecode ();
  301.    
  302.    abortDecodeDoc:;
  303.     GlobalUnlock (BlockPtr->hCurBlock);
  304.     DecodeDone ();
  305. }
  306. /* ------------------------------------------------------------------------
  307.  *    Encode a file and ask the user for a file to name to store it in
  308.  */
  309. void
  310. EncodeToFile (HWND hParentWnd, char *inFile)
  311. {
  312.    register unsigned long i;
  313.    char fileName[MAXFILENAME];
  314.    OFSTRUCT outFileStruct;
  315.    HFILE hAttachFile;
  316.    TypTextBlock *encodeData;
  317.  
  318.    if ((encodeData = InitTextBlock (hParentWnd)) != NULL)
  319.    {
  320.       CreateStatusArea(hParentWnd);
  321.       strcpy (currentCoded->ident, inFile);    // status window info
  322.  
  323.       if (Encode (encodeData, inFile, ADD_TO_FILE) != FAIL)
  324.       {
  325.     fileName[0]='\0';        
  326.     if (AskForNewFileName (hParentWnd, fileName, "", FALSE) != FAIL)
  327.     {
  328.        if ((hAttachFile = OpenFile ((char far *) fileName, &outFileStruct, OF_CREATE)) < 0)
  329.         MessageBox(hParentWnd, "Unable to open output file", "File Error", MB_OK|MB_ICONSTOP);
  330.        else
  331.        {
  332.           for (i = 0; i < encodeData->numLines; i++)
  333.           _lwrite (hAttachFile, TextBlockLine (encodeData, i), lstrlen(TextBlockLine (encodeData, i)));
  334.           _lclose (hAttachFile);
  335.        }
  336.     }    
  337.       }     
  338.       FreeTextBlock (encodeData);
  339.       DestroyStatusArea ();
  340.    }   
  341. }
  342.  
  343. /* ------------------------------------------------------------------------
  344.  *    Create a status window a coding block used for status info
  345.  *    the currentCoded block is purely for status in this case
  346.  *    This is used by attach and EncodeFile and ReadFileToTextBlock
  347.  *    to show status in progress
  348.  *    Use UpdateBlockStatus to update/display status
  349.  *    Use DestroyStatusArea to clean up when done
  350.  */
  351. void
  352. CreateStatusArea (HWND hParentWnd)
  353. {
  354.     if ((currentCoded = InitCoded(hParentWnd)) == NULL)
  355.         return;
  356.     CreateCodingStatusWnd();
  357.     currentCoded->sequence = 1;        // status window info
  358.  
  359. }
  360.  
  361. void
  362. DestroyStatusArea ()
  363. {
  364.     DestroyCodedBlock (¤tCoded);
  365.     DestroyWindow (hCodedBlockWnd);
  366.     hCodedBlockWnd = (HWND)NULL;
  367. }
  368.  
  369. void
  370. CreateCodingStatusWnd()
  371. {
  372.     /* Create coding status window, top center */
  373.     hCodedBlockWnd = CreateWindowEx (WS_EX_DLGMODALFRAME, "WinVnBlockCoding", "Block Encoding Status",
  374.             WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_THICKFRAME,
  375.             (xScreen-STATUSWIDTH)>>1, 1, STATUSWIDTH, STATUSHEIGHT,
  376.             (HWND)NULL, (HMENU)NULL, hInst, (void far *)NULL);
  377.     
  378.     SetHandleBkBrush( hCodedBlockWnd, hStatusBackgroundBrush);
  379.     ShowWindow (hCodedBlockWnd, SW_SHOWNORMAL);
  380. }
  381.  
  382.  
  383. /* ------------------------------------------------------------------------
  384.  *    Adds text to a thread coding status block, and refreshes
  385.  *    the thread status window
  386.  */    
  387. void
  388. UpdateThreadStatus (int num, char *str)
  389. {
  390.     AddLineToTextBlock (threadList[num]->statusText, str);
  391.     InvalidateRect (threadList[num]->statusText->hTextWnd, NULL, FALSE);
  392.     UpdateWindow (threadList[num]->statusText->hTextWnd);
  393. }
  394.  
  395. /* ------------------------------------------------------------------------
  396.  *    Refreshes the block status window
  397.  */    
  398. void
  399. UpdateBlockStatus ()
  400. {
  401.     InvalidateRect (hCodedBlockWnd, NULL, FALSE);
  402.     UpdateWindow (hCodedBlockWnd);
  403. }
  404.  
  405. /* ------------------------------------------------------------------------
  406.  *    Encode a file 
  407.  *    Called _after_ the attach dialog, so all globals for this encode
  408.  *    are set  (sorry about the globals...)
  409.  *    Result is encoded file in TextBlock 
  410.  *    Assumes currentCoded is initialized
  411.  */
  412. int 
  413. Encode (TypTextBlock *textBlock, char *fileName, int mode)
  414. {
  415.     HFILE hFile;
  416.         int numRead, lineLen, start;
  417.     register int i;
  418.     unsigned char inBuf[CODE_LINE_LEN];
  419.     unsigned char outLine[MAXINTERNALLINE];
  420.     extern char *NameWithoutPath ();
  421.  
  422.     CodingState = ATTACH_PROCESSING;
  423.  
  424.     // Set up encoding map
  425.     switch (EncodingTypeNum)
  426.     {
  427.     case CODE_BASE64:    
  428.         codingTable = base64Table;
  429.         break;
  430.     case CODE_UU:
  431.         codingTable = uuTable;
  432.         break;
  433.     case CODE_XX:
  434. //    Note, XX table is hard coded in declarations for simplicity
  435.         codingTable = xxTable;
  436.         break;
  437.     case CODE_CUSTOM:
  438.         codingTable = UserCodingTable;
  439.         // add 2 table lines
  440.         if (AddEndedLineToTextBlock (textBlock, "table", mode))
  441.             return (FAIL);
  442.         memmove (str, UserCodingTable, 32);
  443.         str[32] = '\0';
  444.         if (AddEndedLineToTextBlock (textBlock, str, mode))
  445.             return (FAIL);
  446.         memmove (str, &UserCodingTable[32], 32);
  447.         if (AddEndedLineToTextBlock (textBlock, str, mode))
  448.             return (FAIL);
  449.         break;
  450.     }
  451.  
  452.     // Prepare for encoding
  453.     switch (EncodingTypeNum)
  454.     {
  455.     case CODE_UU:
  456.     case CODE_XX:
  457.     case CODE_CUSTOM:
  458.         // these are 3-to-4 encodings with 1st char indicating line len
  459.         // and block starts with 'begin' line and ends with 'end' line
  460.         // add 'begin' line
  461.         NameWithoutPath (str, fileName);
  462.         sprintf (outLine, "begin 755 %s", str);
  463.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  464.             return (FAIL);
  465.         currentCoded->numLines++;
  466.             // set 1st char to appropriate line length value
  467.             outLine[0] = codingTable[CODE_LINE_LEN];
  468.             start = 1;    // count includes the count char itself
  469.         break;
  470.     case CODE_BASE64:
  471.         // base64 is a 3-to-4 encoding, with no line len indicator and 
  472.         // no 'begin' or 'end' lines
  473.         start = 0;
  474.     }
  475.     lineLen = CODE_LINE_LEN;
  476.  
  477.     // open the file and have at it    
  478.         hFile = _lopen (fileName, OF_READ);
  479.         while (1)
  480.         {
  481.             if ((numRead = _lread(hFile, inBuf, lineLen)) == 0)
  482.                 break;
  483.         if (numRead < lineLen)    // last line length value
  484.         {
  485.             if (EncodingTypeNum != CODE_BASE64)
  486.                 outLine[0] = codingTable[numRead];
  487.             
  488.             for (i = numRead; i < lineLen; i++)
  489.                 inBuf[i] = 0;
  490.         }
  491.             EncodeLine (outLine, inBuf, start, numRead);
  492.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  493.             return (FAIL);
  494.         currentCoded->numLines++;
  495.         currentCoded->numBytes += numRead;
  496.             if (currentCoded->numLines % STATUS_UPDATE_FREQ == 0)
  497.                 UpdateBlockStatus ();
  498.     }        
  499.     _lclose(hFile);
  500.     switch (EncodingTypeNum)
  501.     {
  502.     case CODE_UU:
  503.     case CODE_XX:
  504.     case CODE_CUSTOM:
  505.             // add zero length line
  506.             outLine[0] = codingTable[0];
  507.             outLine[1] = '\0';
  508.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  509.             return (FAIL);
  510.         // add 'end' line
  511.         strcpy (outLine, "end");
  512.         if (AddEndedLineToTextBlock (textBlock, outLine, mode))
  513.             return (FAIL);
  514.         currentCoded->numLines+=2;
  515.         }
  516.     UpdateBlockStatus ();
  517.     
  518.     CodingState = INACTIVE;
  519.     return (SUCCESS);
  520. }
  521.     
  522. /* ------------------------------------------------------------------------
  523.  *    Encode num chars from line
  524.  *    Put data in outLine starting at start
  525.  */
  526. int 
  527. EncodeLine (unsigned char *outLine, unsigned char *line, int start, int num)
  528. {
  529.     register int i, j;
  530.     
  531.     for (j = start, i = 0; i < num; j+=4, i+=3)
  532.         EncodeUnit (&outLine[j], &line[i], (i+3 > num) ? num - i : 3);
  533.  
  534.     outLine[j] = '\0';
  535.     return (j);
  536. }
  537.     
  538. void
  539. EncodeUnit (unsigned char *out, unsigned char *in, int num)
  540. {
  541.            out[0] = codingTable[((in[0]>>2) & 63)];
  542.     out[1] = codingTable[(((in[0]<<4)|(in[1]>>4)) & 63)];
  543.     if (num == 1)
  544.     {
  545.         if (EncodingTypeNum == CODE_BASE64)
  546.             strcpy (&out[2], "==");
  547.         return;
  548.     }
  549.  
  550.     out[2] = codingTable[(((in[1]<<2)|(in[2]>>6)) & 63)];
  551.     if (num == 2)
  552.     {
  553.         if (EncodingTypeNum == CODE_BASE64)
  554.             strcpy (&out[3], "=");
  555.         return;
  556.     }
  557.  
  558.     out[3] = codingTable[(in[2] & 63)];
  559. }
  560. /* ------------------------------------------------------------------------
  561.  *    Init for decoding
  562.  *     Initialize the coding tables
  563.  *    Init threadList:  list of pointers to Thread lists 
  564.  *    (one thread for each file being decoded)
  565.  *        
  566.  */
  567. void
  568. DecodeInit ()
  569. {
  570.     register int i;
  571.     
  572. #ifdef DEBUG_MEM
  573.     InitDebugLog();
  574. #endif
  575.     
  576.         for (i = 0; i < MAX_DECODE_THREADS; i++)
  577.             threadList[i] = NULL;
  578.  
  579.     currentCoded = (TypCoded *) NULL;
  580.     CodingState = DECODE_SKIPPING;
  581.     numDecodeThreads = 0;
  582.     numDumbDecoded = 0;
  583.     currentDecodeThread = -1;    
  584.     thisNumBlocks = -1;
  585.     prevBlockIdent[0] = '\0';
  586.     thisContentEncoding = CODE_UNKNOWN;
  587.     prevContentEncoding = CODE_UNKNOWN;
  588.         customTable[0] = '\0';
  589.  
  590. #ifdef DEBUG_MEM
  591.     sprintf(debug, "\nInitialized decoding, %d threads", MAX_DECODE_THREADS);
  592.     DebugLog();
  593. #endif
  594.     // Create coding status window (open for duration of coding only)
  595.     CreateCodingStatusWnd();
  596.     UpdateBlockStatus ();
  597. }
  598.  
  599. /* ------------------------------------------------------------------------
  600.  * At this point, all threads in sequence should have been written and freed,
  601.  * If any threads left, we either had an incomplete decode of some file,
  602.  * or the file was encoded w/out sequence info, and we were waiting to 
  603.  * hopefully receive it all.  If we had an endflag, then write it in order
  604.  * received
  605.  * Accepts handle of parent window so it can display any 'incomplete' messages
  606.  */
  607. void
  608. DecodeDone ()
  609. {
  610.     char mybuf[MAXINTERNALLINE], name[MAXINTERNALLINE];
  611.  
  612. #ifdef DEBUG_MEM
  613.     sprintf(debug, "\nDone coding,  Wrapping up stray threads");
  614.     DebugLog();
  615. #endif
  616.     name[0]='\0';            // only show name if not verbose mode
  617.     while (numDecodeThreads > 0)    // always work on top of list [0]
  618.     {
  619.         if (!CodingStatusVerbose)
  620.             if (threadList[0]->name[0] != '\0')
  621.                 sprintf (name, "%s   ", threadList[0]->name);
  622.             else
  623.                 sprintf (name, "%s   ", threadList[0]->ident);
  624.  
  625.         if (threadList[0]->numBlocks == 0)
  626.         {    // premature end of file
  627.                     WriteDecodeThread (0);
  628.             sprintf (mybuf, "%sDecode is missing parts, written total size %ld", name, threadList[0]->totalBytes);
  629.             UpdateThreadStatus (0, mybuf);
  630.         }
  631.         else if (threadList[0]->contentEncoding != CODE_BASE64 &&
  632.                 !threadList[0]->codedBlockList[threadList[0]->numBlocks-1]->endFlag)
  633.         {
  634.             sprintf (mybuf, "%sEnd never found.  Cancelling", name);
  635.             UpdateThreadStatus (0, mybuf);
  636.         }
  637.         else if (threadList[0]->expectedNumBlocks > 0)
  638.         {    // there IS sequencing info, so we should not be here
  639.                     WriteDecodeThread (0);
  640.             sprintf (mybuf, "%sDecode is missing parts, written total size %ld", name, threadList[0]->totalBytes);
  641.             UpdateThreadStatus (0, mybuf);
  642.         }
  643.         else
  644.                 {
  645.             sprintf (mybuf, "%sCompleteness confidence is medium, written total size %ld", name, threadList[0]->totalBytes);
  646.             UpdateThreadStatus (0, mybuf);
  647.                     WriteDecodeThread (0);
  648.         }            
  649.         DestroyThread (0);    // decrements numDecodeThreads
  650.     }
  651.     currentCoded = NULL;
  652.     CodingState = INACTIVE;
  653.         CommDecoding = FALSE;
  654.     DestroyWindow (hCodedBlockWnd);
  655.     hCodedBlockWnd = (HWND)NULL;
  656. }    
  657.  
  658. /* ------------------------------------------------------------------------
  659.  *     Initialize a coded object, and initial data space
  660.  *    Returns ptr to object or NULL if failed
  661.  */
  662. TypCoded *
  663. InitCoded (HWND hParentWnd)
  664. {      
  665.     TypCoded *thisCoded = NULL;
  666.     
  667. #ifdef DEBUG_MEM
  668.     sprintf(debug, "\nInitializing a coded object");
  669.     DebugLog();
  670. #endif
  671.     if ((thisCoded = (TypCoded *) GlobalAllocPtr ( GMEM_MOVEABLE, sizeof (TypCoded))) == NULL)
  672.         return ((TypCoded *) NULL);
  673.     
  674. #ifdef DEBUG_MEM
  675.     sprintf(debug, "\nAllocing data size %d", BASE_BLOCK_SIZE);
  676.     DebugLog();
  677. #endif
  678.     if ((thisCoded->data = (char huge *) GlobalAllocPtr (GMEM_MOVEABLE, BASE_BLOCK_SIZE * sizeof (char))) == NULL)
  679.         return ((TypCoded *) NULL);
  680.  
  681.     thisCoded->maxBytes = BASE_BLOCK_SIZE;
  682.     thisCoded->numBytes = 0;
  683.     thisCoded->numLines = 0;
  684.     thisCoded->sequence = -1;
  685.     thisCoded->seqConfidence = 0;
  686.     thisCoded->name[0] = '\0';
  687.     thisCoded->ident[0] = '\0';
  688.     thisCoded->endFlag = thisCoded->beginFlag = FALSE;
  689.     thisCoded->hParentWnd = hParentWnd;
  690.         bossanovaMIME = FALSE;
  691.     
  692.     return (thisCoded);
  693. }    
  694.  
  695. /* ------------------------------------------------------------------------
  696.  *     Destroy a thread
  697.  *    Destroy all blocks in the thread
  698.  *    Remove the thread from the threadList
  699.  */
  700. void
  701. DestroyThread (int num)
  702. { 
  703.     register int i;
  704.     
  705. #ifdef DEBUG_MEM
  706.     sprintf(debug, "\nDestroying thread %d", num);
  707.     DebugLog();
  708. #endif
  709.     if (CodingStatusVerbose)
  710.         threadList[num]->statusText->IsBusy = FALSE;
  711.     
  712.     for (i = 0; i < threadList[num]->numBlocks; i++)
  713.         DestroyCodedBlock (&(threadList[num]->codedBlockList[i]));
  714.         
  715.     GlobalFreePtr (threadList[num]);
  716.  
  717.     for (i = num; i < numDecodeThreads; i++)
  718.         threadList[i] = threadList[i + 1];
  719.     
  720.     numDecodeThreads--;
  721.     if (currentDecodeThread == num)
  722.         currentDecodeThread = max (0, currentDecodeThread - 1);
  723. }
  724. /* ------------------------------------------------------------------------
  725.  *     Destroy a coded block structure
  726.  *    Free the huge data.  Takes a ptr to a ptr so it can NULL it when done
  727.  */
  728. void
  729. DestroyCodedBlock (TypCoded **thisCoded)
  730. {        
  731. #ifdef DEBUG_MEM
  732.     sprintf(debug, "\nDestroying block sequence %d", (*thisCoded)->sequence);
  733.     DebugLog();
  734. #endif
  735.     GlobalFreePtr ((*thisCoded)->data);
  736.     GlobalFreePtr (*thisCoded);
  737.         *thisCoded = NULL;
  738. }
  739.  
  740. /* ------------------------------------------------------------------------
  741.  *     Given a file name, find the associated thread number  
  742.  *    Returns -1 if no thread by that name exists
  743.  */
  744. int
  745. GetThreadByName (char *name)
  746. {
  747.     int i, result;
  748.     
  749.     for (result = -1, i = 0; i < numDecodeThreads && result == -1; i++)
  750.         if (!_stricmp (name, threadList[i]->name))
  751.             result = i;
  752.  
  753.     return (result);
  754. }
  755. /* ------------------------------------------------------------------------
  756.  *     Determine if a thread has already been started for this ident
  757.  *    if yes, add decode object to that thread
  758.  *    otherwise, alloc a new thread list structure, add this block to it
  759.  *    At end, currentDecodeThread is set to handle of thread
  760.  */
  761. BOOL                                                           
  762. AddToThreadList ()
  763. {
  764.     register int i;
  765.     int num;
  766.     char mybuf[MAXINTERNALLINE];
  767.     int x, y, width, height, maxX, maxY;
  768.     
  769.      if (DumbDecode)
  770.      {    
  771.         if (numDecodeThreads == 0)
  772.              num = -1;
  773.         else 
  774.              num = 0;
  775.     } else
  776.      /* Search existing threads for an ident match.  If
  777.       * no match found, or no threads exist yet, add new thread.
  778.       */
  779.         for (num = -1, i = 0; i < numDecodeThreads; i++)
  780.             if (!_stricmp (currentCoded->ident, threadList[i]->ident))
  781.                 num = i;
  782.  
  783.     if (num == -1)        /* add a new thread */
  784.     {
  785.         if ((numDecodeThreads + 1) > MAX_DECODE_THREADS)    
  786.         {
  787.             return (FAIL);
  788. /*            GlobalUnlock(decodeObjectHandles);
  789.               decodeObjectHandles = GlobalRealloc (decodeFileHandles,
  790.                   (numDecodeThreads + LIST_SIZE_INC) * sizeof (HGLOBAL), 
  791.                   GMEM_MOVEABLE);
  792.             threadList = (HGLOBAL *) GlobalLock (decodeFileHandles);
  793. */
  794.         }
  795.  
  796. // create a new DecodeThreadStruct object, store its handle in threadList,
  797. #ifdef DEBUG_MEM
  798.         sprintf(debug, "\nCreating new thread ident %s", currentCoded->ident);
  799.         DebugLog();
  800. #endif
  801.          num = numDecodeThreads;
  802.         numDecodeThreads++;
  803.  
  804.         threadList[num] = (TypDecodeThread *) GlobalAllocPtr (GMEM_MOVEABLE, sizeof (TypDecodeThread));
  805.         threadList[num]->expectedNumBlocks = 0;
  806.         threadList[num]->numBlocksWritten = 0;
  807.         threadList[num]->numBlocks = 0;
  808.         threadList[num]->totalBytes = 0;
  809.         threadList[num]->dosFileName[0] = '\0';
  810.         if (thisContentEncoding == CODE_CUSTOM)
  811.             strncpy (threadList[num]->customTable, customTable, CODINGTABLESIZE);
  812.         threadList[num]->contentEncoding = thisContentEncoding;
  813.         strcpy (threadList[num]->ident, currentCoded->ident);
  814.                 if (currentCoded->name[0] != '\0')
  815.             strcpy (threadList[num]->name, currentCoded->name);
  816.         else
  817.             threadList[num]->name[0] = '\0';
  818.  
  819.             if (CodingStatusVerbose || NumStatusTexts == 0)
  820.         {
  821.            if ((threadList[num]->statusText = InitTextBlock(hCodedBlockWnd)) == NULL)
  822.             MessageBox (hCodedBlockWnd, "Memory allocation error in text block", "Memory Error", MB_OK);
  823.                 
  824.                    if (NumStatusTexts + 1 > MAX_DECODE_THREADS);
  825.                        // ?????
  826.                 
  827.                    CodingStatusText[NumStatusTexts++] = threadList[num]->statusText;
  828.  
  829.            if (CodingStatusVerbose)
  830.                sprintf(mybuf, "Decoding Status for file %s", (threadList[num]->name[0]!='\0')?threadList[num]->name:threadList[num]->ident);
  831.            else
  832.                strcpy(mybuf, "Decoding Status");
  833.            
  834.            width = xScreen>>1;
  835.            height = (yScreen>>1) - CaptionHeight;
  836.            maxX = 3 * (width>>1);    /* 3/4 screen width  */
  837.            maxY = 3 * (height>>1);    /* 3/4 screen height */
  838.  
  839.            x = (NumStatusTexts * 10) % maxX;
  840.            y = (yScreen>>2) + (NumStatusTexts * CaptionHeight) % maxY;
  841.  
  842.            threadList[num]->statusText->hTextWnd =
  843.             CreateWindow ("WinVnCoding", mybuf,
  844.                 WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
  845.                 x, y, width, height,
  846.                 (HWND)NULL, (HMENU)NULL, hInst, (void far *)NULL);
  847.  
  848.            if (threadList[num]->statusText->hTextWnd == (HWND)NULL)
  849.            {
  850.             FreeTextBlock(threadList[num]->statusText);    
  851.             MessageBox (hCodedBlockWnd, "Couldn't create status text window","Window Creation Error", MB_OK);
  852.             return (FAIL);            
  853.            }
  854.            SetHandleBkBrush (threadList[num]->statusText->hTextWnd,
  855.                       hStatusBackgroundBrush);
  856.            ShowWindow (threadList[num]->statusText->hTextWnd, SW_SHOWNORMAL);
  857.                UpdateWindow (threadList[num]->statusText->hTextWnd);
  858.         }
  859.         else
  860.            threadList[num]->statusText = CodingStatusText[0];
  861.  
  862.     }
  863.     
  864. /* If this new block enlightens us with any useful thread info, update
  865.  * the thread
  866.  */
  867.     if (currentCoded->name[0] != '\0')
  868.         strcpy (threadList[num]->name, currentCoded->name);
  869. //    if (threadList[num]->contentType[0] == '\0')
  870. //        strcpy (threadList[num]->contentType, thisContentType);
  871.     if (threadList[num]->expectedNumBlocks == 0 && thisNumBlocks > 0)
  872.         threadList[num]->expectedNumBlocks = thisNumBlocks;
  873.     
  874.     threadList[num]->totalBytes += currentCoded->numBytes;
  875. /*
  876.  * Now, add this decode object to the thread codedBlockList
  877.  * Insert in correct sequence. 
  878.  * If no sequence info available, add to end of list, but before any end block
  879.  */
  880.     if (DumbDecode)
  881.         InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks);
  882.     else
  883.     {    
  884.       if (threadList[num]->numBlocks != 0 && currentCoded->sequence == -1)
  885.       {    /* sequence unknown, add at end or before end block */
  886.         if (currentCoded->beginFlag)
  887.             InsertBlockInThread(num, currentCoded, 0);
  888.         else 
  889.         {
  890.             if (threadList[num]->codedBlockList[threadList[num]->numBlocks - 1]->endFlag)
  891.                 InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks - 1);
  892.             else            
  893.                 InsertBlockInThread(num, currentCoded, threadList[num]->numBlocks);
  894.         }
  895.       }
  896.       else
  897.       {
  898.         for (i = 0; i < threadList[num]->numBlocks; i++)
  899.         {
  900.             if (threadList[num]->codedBlockList[i]->sequence == -1 || 
  901.                 threadList[num]->codedBlockList[i]->sequence >= currentCoded->sequence)
  902.                 break;
  903.         }
  904.         InsertBlockInThread (num, currentCoded, i);
  905.       }                                                  
  906.     }
  907.     currentDecodeThread = num;         
  908.     if (!CodingStatusVerbose)
  909.         return (SUCCESS);
  910.     
  911.     sprintf (mybuf, "Decoded block");
  912.     if (currentCoded->sequence == -1)
  913.     {
  914.         if (currentCoded->beginFlag || currentCoded->endFlag)
  915.         {
  916.             if (currentCoded->beginFlag)
  917.                 strcat (mybuf, ", begin block");
  918.             if (currentCoded->endFlag)
  919.                 strcat (mybuf, ", end block");
  920.         } else
  921.             strcat (mybuf, " sequence unknown");
  922.     }        
  923.     else
  924.     {
  925.         sprintf (str, " %d", currentCoded->sequence);
  926.         strcat (mybuf, str);
  927.         if (threadList[num]->expectedNumBlocks > 0)
  928.         {
  929.             sprintf (str, " of %d.", threadList[num]->expectedNumBlocks);
  930.             strcat (mybuf, str);
  931.         }
  932.         if (currentCoded->sequence == threadList[num]->numBlocksWritten + 1)
  933.             strcat (mybuf, " In sequence");
  934.         else
  935.             strcat (mybuf, " Out of sequence");
  936.     }
  937.     UpdateThreadStatus (num, mybuf);
  938.     thisNumBlocks = -1;
  939.  
  940.     return (SUCCESS);
  941. }
  942.  
  943. /* ------------------------------------------------------------------------
  944.  *     Insert/delete a block in a thread list
  945.  *    Inserts and deletes will be O(n).  Since n will never be big,
  946.  *    it's not worth the trouble (and space usage) of using a linked list
  947.  *
  948.  *    index should never be -1 (case of unkown sequence handled by caller)
  949.  *    to insert at front of list, index = 0
  950.  *    to insert at end of list, index = threadList[num]->numBlocks
  951.  */
  952. void
  953. InsertBlockInThread (int num, TypCoded *block, int index)
  954. {
  955.     register int i;
  956.     
  957.     for (i = threadList[num]->numBlocks; i > index && i > 0 ; i--)
  958.         threadList[num]->codedBlockList[i] = threadList[num]->codedBlockList[i-1];
  959.      
  960. #ifdef DEBUG_DECODE
  961.     sprintf(debug, "\nInserting into thread %s at posn %d", threadList[num]->ident, i);
  962.     DebugLog(); 
  963. #endif
  964.      threadList[num]->codedBlockList[i] = block;
  965.             
  966.     threadList[num]->numBlocks++;        
  967.  
  968.     return;
  969. }
  970.  
  971. void
  972. DeleteBlockFromThread (int num, int index)
  973. {
  974.     register int i;
  975.     
  976.     for (i = index; i < threadList[num]->numBlocks; i++)
  977.         threadList[num]->codedBlockList[i] = threadList[num]->codedBlockList[i+1];
  978.      
  979. #ifdef DEBUG_DECODE
  980.     sprintf(debug, "\nRemoved from thread %s at posn %d", threadList[num]->name, index);
  981.     DebugLog();
  982. #endif
  983.     threadList[num]->numBlocks--;        
  984.  
  985.     return;
  986. }
  987.  
  988. /* ------------------------------------------------------------------------
  989.  *     Complete a decode block
  990.  *    Adds to thread list
  991.  *    Writes block to disk if possible (and any others now in sequence)
  992.  *    If it ends a thread, make sure everything is written, and
  993.  *    free up the thread
  994.  */
  995. BOOL
  996. CompleteThisDecode ()
  997. {
  998.     char mybuf[MAXINTERNALLINE];
  999.     int num, singleBlockDone, foundEnd;
  1000.  
  1001.     UpdateBlockStatus ();    // final size displayed
  1002. #ifdef DEBUG_DECODE
  1003.     sprintf(debug, "\nCompleteThisDecode for file %s, block %d",
  1004.             currentCoded->ident, currentCoded->sequence);
  1005.     DebugLog();
  1006. #endif
  1007.     if (currentCoded->numBytes == 0)
  1008.     {
  1009. #ifdef DEBUG_DECODE
  1010.         sprintf(debug, "\nNon-data block.  Discarding it.");
  1011.         DebugLog();
  1012. #endif
  1013.         DestroyCodedBlock (¤tCoded);
  1014.         return (SUCCESS);
  1015.     }
  1016.     
  1017.     if (DumbDecode)
  1018.     {        
  1019.         if (numDumbDecoded == 0 && !currentCoded->beginFlag)
  1020.             return (SUCCESS); // Dumb skipping a data block
  1021.         if (numDumbDecoded > 0 && currentCoded->beginFlag)
  1022.         {        // found next begin without an end
  1023.             if (CodingStatusVerbose)
  1024.                 sprintf (mybuf, "Decode missing end, total size %ld, wrote to file %s", threadList[num]->totalBytes, threadList[num]->dosFileName);
  1025.             else
  1026.                 sprintf (mybuf, "%s   Decode missing end, total size %ld, wrote to file %s", 
  1027.             threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  1028.             UpdateThreadStatus (num, mybuf);
  1029.             DestroyThread(num);
  1030.             numDumbDecoded = 0;
  1031.         }
  1032.     }                    
  1033.         else
  1034.     // if for some reason (?) we didn't get a begin, but this is block 1
  1035.     if (currentCoded->sequence == 1 && 
  1036.         currentCoded->seqConfidence == HIGH && 
  1037.         !currentCoded->beginFlag)
  1038.     {
  1039.         currentCoded->beginFlag;
  1040.         strcpy (currentCoded->name, currentCoded->ident);
  1041.     }    
  1042.     
  1043.     if (AddToThreadList () == FAIL)
  1044.         return (FAIL);
  1045.     
  1046.     prevContentEncoding = thisContentEncoding;
  1047.     thisContentEncoding = CODE_UNKNOWN;
  1048.     
  1049.     num = currentDecodeThread;    
  1050.     singleBlockDone = currentCoded->beginFlag && currentCoded->endFlag;
  1051.  
  1052.     if (!CodingStatusVerbose && 
  1053.        (threadList[num]->numBlocksWritten == 0 && threadList[num]->numBlocks == 1))
  1054.     {
  1055.         sprintf (mybuf, "%s   Decode in progress", (threadList[num]->name[0]!='\0')?threadList[num]->name:threadList[num]->ident);
  1056.         UpdateThreadStatus (num, mybuf);
  1057.     }
  1058.     
  1059.     if (DumbDecode)
  1060.     {
  1061.         if (WriteTopBlockToFile (num, &foundEnd) == FAIL)
  1062.             return (FAIL);
  1063.         numDumbDecoded++;
  1064.     }
  1065.         else
  1066.         {
  1067. /* If this block is both begin and end, then go straight to WriteDecodeThread
  1068.  * If currentCoded is in sequence, then it was added as block 0 in the 
  1069.  * thread's block list, and may have caused other blocks to now be in 
  1070.  * sequence as well.  Write all blocks which are in sequence now.
  1071.  */
  1072.       if (!singleBlockDone && currentCoded->sequence != -1 && 
  1073.           currentCoded->seqConfidence != 0)
  1074.         while (threadList[num]->numBlocks != 0)
  1075.         {
  1076.             if (threadList[num]->codedBlockList[0]->sequence == threadList[num]->numBlocksWritten)
  1077.             {    // skip duplicate block sequence
  1078.                 DestroyCodedBlock (¤tCoded);    // threadList[num]->codedBlockList[0]
  1079.                             DeleteBlockFromThread (num, 0);
  1080.                             break;
  1081.                     }
  1082.             if (threadList[num]->codedBlockList[0]->sequence != threadList[num]->numBlocksWritten + 1)
  1083.                 break;
  1084. #ifdef DEBUG_DECODE
  1085.             sprintf(debug, "\nBlock in sequence, writing it, file %s, block %d",
  1086.                 threadList[num]->name, threadList[num]->codedBlockList[0]->sequence);
  1087.             DebugLog();
  1088. #endif
  1089.             if (WriteTopBlockToFile (num, &foundEnd) == FAIL)
  1090.                 return (FAIL);
  1091.          }
  1092.      }    
  1093.     if (singleBlockDone || (foundEnd && DumbDecode) ||
  1094.         (foundEnd && threadList[num]->expectedNumBlocks > 0 && 
  1095.         threadList[num]->numBlocksWritten >= threadList[num]->expectedNumBlocks))
  1096.     {
  1097. #ifdef DEBUG_DECODE
  1098.         sprintf(debug, "\nThread complete: file %s", threadList[num]->name);
  1099.         DebugLog();
  1100. #endif
  1101.            if (WriteDecodeThread(num) == FAIL)
  1102.         {
  1103.             DestroyThread(num);
  1104.             currentCoded = NULL;
  1105.                return (FAIL);
  1106.            }
  1107.  
  1108.         if (CodingStatusVerbose)
  1109.             sprintf (mybuf, "Decode complete, total size %ld, wrote to file %s", threadList[num]->totalBytes, threadList[num]->dosFileName);
  1110.         else
  1111.             sprintf (mybuf, "%s   Decode complete, total size %ld, wrote to file %s", 
  1112.         threadList[num]->name, threadList[num]->totalBytes, threadList[num]->dosFileName);
  1113.         UpdateThreadStatus (num, mybuf);
  1114.  
  1115.         DestroyThread(num);
  1116.         numDumbDecoded = 0;
  1117.     }
  1118.     currentCoded = NULL;
  1119.     return (SUCCESS);
  1120. }            
  1121.             
  1122. /* ------------------------------------------------------------------------
  1123.  *     Write data for the top block of a thread to a file, and remove
  1124.  *    the top block from the thread
  1125.  */
  1126. BOOL
  1127. WriteTopBlockToFile (int num, int *endFlag)
  1128. {
  1129.     char mybuf[MAXINTERNALLINE];
  1130.  
  1131.     if (WriteBlockToFile (num, threadList[num]->codedBlockList[0]) == FAIL)
  1132.     {
  1133.         sprintf (mybuf, "Could not write to file %s", threadList[num]->dosFileName);
  1134.         UpdateThreadStatus (num, mybuf);
  1135.         DestroyThread(num);
  1136.         return (FAIL);
  1137.     }
  1138.     
  1139.     *endFlag = threadList[num]->codedBlockList[0]->endFlag;
  1140.     DestroyCodedBlock (&(threadList[num]->codedBlockList[0]));
  1141.     DeleteBlockFromThread (num, 0);
  1142.     threadList[num]->numBlocksWritten++; 
  1143.     return (SUCCESS);
  1144. }
  1145.     
  1146. /* ------------------------------------------------------------------------
  1147.  *     Write data for a thread to a file
  1148.  */
  1149. BOOL
  1150. WriteDecodeThread (int num)
  1151. {
  1152.     register int i;
  1153.     char mybuf[MAXINTERNALLINE];
  1154.         
  1155.     for (i = 0; i < threadList[num]->numBlocks; i++)
  1156.     {
  1157. #ifdef DEBUG_DECODE
  1158.         sprintf(debug, "\nSaving sequence %d", threadList[num]->codedBlockList[i]->sequence);
  1159.         DebugLog();
  1160. #endif
  1161.         if (WriteBlockToFile (num, threadList[num]->codedBlockList[i]) == FAIL)
  1162.         {
  1163.             sprintf (mybuf, "Could not write to file %s", threadList[num]->dosFileName);
  1164.             UpdateThreadStatus (num, mybuf);
  1165.             return (FAIL);
  1166.         }
  1167.     }
  1168.     if (ExecuteDecodedFiles)
  1169.         ExecuteDecodedFile(num, threadList[num]->dosFileName);
  1170.  
  1171.     return (SUCCESS);
  1172. }
  1173.  
  1174. /* ------------------------------------------------------------------------
  1175.  *     Write block data to a file
  1176.  *    Verify thread file name will work in DOS, and request a new file
  1177.  *    name if necessary
  1178.  *     Accepts handle of parent window to allow any necessary dialogs
  1179.  */
  1180. BOOL
  1181. WriteBlockToFile(int num, TypCoded *thisDecode)
  1182. { 
  1183.     register unsigned long i;
  1184.     unsigned int chunkSize;
  1185.     char    actualFileName[MAXFILENAME], mybuf[MAXINTERNALLINE];
  1186.         OFSTRUCT outFileStruct;
  1187.     HFILE     hWriteFile;
  1188.     UINT    fileMode;
  1189.  
  1190. #define    CHUNK_SIZE 65500    /* must not exceed UINT (65534) */        
  1191.     
  1192.     if (threadList[num]->dosFileName[0] != '\0') {
  1193.         fileMode = OF_WRITE;
  1194.         if (strchr (threadList[num]->dosFileName, '\\') == NULL)
  1195.         {
  1196.             strcpy (actualFileName, DecodePathName);
  1197.             if (actualFileName[strlen(actualFileName)-1] != '\\')
  1198.                 strcat(actualFileName, "\\");
  1199.             strcat(actualFileName, threadList[num]->dosFileName);
  1200.             }
  1201.         else
  1202.            strcpy (actualFileName, threadList[num]->dosFileName);
  1203.     }
  1204.     else 
  1205.     {
  1206.     /* First time write to file
  1207.      */
  1208.         fileMode = OF_CREATE;
  1209.                 
  1210.                 actualFileName[0] = '\0';
  1211.         if (threadList[num]->name[0] != '\0')
  1212.             strcpy (threadList[num]->dosFileName, threadList[num]->name);
  1213.         else if (threadList[num]->ident[0] != '\0')
  1214.             strcpy (threadList[num]->dosFileName, threadList[num]->ident);
  1215.         if (threadList[num]->dosFileName[0] != '\0')
  1216.         {
  1217.             strcpy (actualFileName, DecodePathName);
  1218.             if (actualFileName[strlen(actualFileName-1)] != '\\')
  1219.                 strcat(actualFileName, "\\");
  1220.             strcat(actualFileName, threadList[num]->dosFileName);
  1221.         }
  1222.  
  1223.         /* smart filer work */
  1224.         if (SmartFile(hCodedBlockWnd, actualFileName) == FAIL)
  1225.             return (FAIL);
  1226.  
  1227.         strcpy (threadList[num]->dosFileName, actualFileName);
  1228.     }
  1229.         
  1230.         if ((hWriteFile = OpenFile ((char far *) actualFileName, &outFileStruct, fileMode)) < 0)
  1231.     {
  1232.         MessageBox(hCodedBlockWnd, "Unable to open output file", "File Error", MB_OK|MB_ICONSTOP);
  1233.         return (FAIL);
  1234.         }
  1235.         if (fileMode == OF_WRITE)
  1236.             _llseek (hWriteFile, 0L, 2);    /* append */
  1237.             
  1238.     for (i = 0L; i < thisDecode->numBytes; i += chunkSize)
  1239.     {
  1240.                if (i + CHUNK_SIZE > thisDecode->numBytes)
  1241.                    chunkSize = (unsigned int) (thisDecode->numBytes - i);
  1242.                else
  1243.                    chunkSize = CHUNK_SIZE;
  1244.  
  1245.                if (_lwrite(hWriteFile, &(thisDecode->data[i]), chunkSize) != chunkSize)
  1246.         {
  1247.             MessageBox(hCodedBlockWnd, "Error writing to file", "File Error", MB_OK|MB_ICONSTOP);
  1248.                    _lclose(hWriteFile);
  1249.             return (FAIL);
  1250.             }
  1251.         }
  1252.  
  1253.     if (CodingStatusVerbose)
  1254.     {
  1255.         strcpy (mybuf, "     Wrote block ");
  1256.         if (thisDecode->sequence > 0)
  1257.         {
  1258.             sprintf (str, "%d ", thisDecode->sequence);
  1259.             strcat (mybuf, str);
  1260.         }
  1261. //        sprintf (str, "to file %s", threadList[num]->dosFileName);
  1262. //        strcat (mybuf, str);
  1263.         UpdateThreadStatus (num, mybuf);
  1264.     }
  1265.            _lclose(hWriteFile);
  1266.     return (SUCCESS);
  1267. }
  1268.  
  1269. /* ------------------------------------------------------------------------
  1270.  *     Decode a line in article.  Store in thisDecode
  1271.  */
  1272. int  
  1273. DecodeLine(TypCoded *thisDecode, char *line)
  1274. {
  1275.     register int i;
  1276.     static int table_count;
  1277.     char thisBlockName[MAXINTERNALLINE];
  1278.          int mode;
  1279.  
  1280.     if (strlen(line) == 0)    
  1281.         return (SUCCESS);
  1282.  
  1283.     thisDecode->numLines++;
  1284.     if (thisDecode->numLines % STATUS_UPDATE_FREQ == 0)
  1285.         UpdateBlockStatus ();
  1286.     
  1287.     switch (CodingState)
  1288.     {
  1289.     case DECODE_SKIPPING: 
  1290.         if (strlen(line) < 3)    // if we're skipping, ignore any really short line
  1291.             return (SUCCESS);
  1292.  
  1293.         // encoded UU/XX/Custom data always starts with line 
  1294.         // like 'begin <mode> <file-name>'
  1295.         if (!strncmp (line, "begin", 5) &&
  1296.             sscanf (line, "%*s %d %s", &mode, thisBlockName) == 2)
  1297.                 {
  1298. #ifdef DEBUG_DECODE
  1299.             sprintf(debug, "\nStart of new encoded file %s, mode %d", thisBlockName, mode);
  1300.             DebugLog();
  1301. #endif
  1302.             if (thisBlockName[0] != '\0')
  1303.                 strcpy (thisDecode->name, strlwr(thisBlockName));
  1304.                         else
  1305.                 strcpy (thisDecode->name, thisDecode->ident);
  1306.                                     
  1307.             thisDecode->sequence = 1;
  1308.             thisDecode->beginFlag = TRUE;
  1309. //            thisDecode->mode = mode;
  1310.  
  1311.             CodingState = DECODE_PROCESSING;
  1312.             return (SUCCESS);
  1313.         }     
  1314. /* Check for keywords in the non-data lines which may aid in describing
  1315.  * the name for this data, the sequence, a custom table, etc
  1316.  */
  1317.          else if (!DumbDecode && !_strnicmp(line, "subject:", 8))
  1318.              ParseInfoLine (thisDecode, &line[8], TRUE);
  1319.          else if (!DumbDecode && !_strnicmp(line, "summary:", 8))
  1320.             ParseInfoLine (thisDecode, &line[8], FALSE);
  1321.          else if (!DumbDecode && ParseAppSpecificLine (thisDecode, line))
  1322.             return (SUCCESS);
  1323.          else if (!strncmp(line, "table", 5))
  1324.          {    // next two lines are table
  1325.              CodingState=DECODE_GET_TABLE;
  1326.             table_count = 0;
  1327.              return (SUCCESS);
  1328.          }
  1329.                      
  1330. /*        else if (ParseMimeHeaderLine(thisDecode, line) == SUCCESS)
  1331.             return (SUCCESS);
  1332. */
  1333. /* Skipping to find new block of data.
  1334.  * Skip until a data line (a line with the correct length) is found
  1335.  */        
  1336.          else if (IsDataLine(line))
  1337.         {   
  1338. #ifdef DEBUG_DECODE
  1339.             sprintf(debug, "\nFound start of next data section", line);
  1340.             DebugLog();
  1341. #endif
  1342.                          CodingState = DECODE_PROCESSING;
  1343.                            // found good line, process it and continue processing
  1344.                            return (DecodeDataLine(thisDecode, line));
  1345.         }
  1346. #ifdef DEBUG_DECODE
  1347.         sprintf(debug, "\nskipped: %s", line);
  1348.         DebugLog();
  1349. #endif
  1350.         return (SUCCESS);        // continue skipping 
  1351.  
  1352.     case DECODE_GET_TABLE:
  1353.     // This is one of two lines containing table info
  1354.         memmove ((customTable + table_count * 32), line, 32);
  1355.  
  1356.         if (++table_count == 2)
  1357.         {
  1358. #ifdef DEBUG_MAP
  1359.             strncpy (str, customTable, 64);
  1360.             str[64]='\0';
  1361.             sprintf(debug, "\nfound table: %s", str);
  1362.             DebugLog();
  1363. #endif
  1364.             CodingState = DECODE_SKIPPING;
  1365.             if (i = CreateCodingMap (CodingMap[CODE_CUSTOM], customTable) != -1)
  1366.             {
  1367. #ifdef DEBUG_MAP
  1368.                 sprintf (debug, "Invalid decoding table in block.  Duplicate character %c.",  i);
  1369.                 DebugLog();
  1370. #endif
  1371.                 customTable[0]='\0';    // ditch the table
  1372.             } 
  1373.             else
  1374.                 thisContentEncoding = CODE_CUSTOM;
  1375.         }
  1376.         return (SUCCESS);
  1377.             
  1378.     case DECODE_PROCESSING:
  1379. /* Some encoders place an END line at end of a section, and length it like 
  1380.  * a proper encoded line
  1381.  * Make sure we catch it, don't decode it as data, and switch back to skipping
  1382.  * Note the only End statement which means End of entire file is lower case
  1383.  * "end".  The other tags are ignored, i.e. "END", "End_of_section", etc
  1384.  */
  1385.         if (!_strnicmp (line, "end", 3) || !IsDataLine(line) ||
  1386.            (bossanovaMIME && !strcmp (&line[2], thisBoundary))) // skip '--'
  1387.         {
  1388. #ifdef DEBUG_DECODE    
  1389.             sprintf(debug, "\nSwitching back to skipping\nskipped: %s", line);
  1390.             DebugLog();
  1391. #endif
  1392.             CodingState = DECODE_SKIPPING;
  1393.  
  1394. /* If we are switching back to skipping and haven't really received any
  1395.  * data yet (< about a line's worth), then the line which gave us the coding type
  1396.  * was bogus (regular text line where first char happened to = encoded line 
  1397.  * length, Here's one: 'From: marnold@cwis.unomaha.edu (Matthew Eldon Arnold)'
  1398.  * Ditch all data so far and the current table  and reprocess
  1399.  * this line.  Note if we have a custom table, then we trust it.
  1400.  */
  1401.             if (thisContentEncoding != CODE_CUSTOM && thisDecode->numBytes < 80)
  1402.             {
  1403.                 thisDecode->numBytes = 0;
  1404.                 thisContentEncoding = CODE_UNKNOWN;
  1405. #ifdef DEBUG_DECODE    
  1406.                 sprintf(debug, "\nBogus table!  Scrapping so far, reprocessing line: %s", line);
  1407.                 DebugLog();
  1408. #endif
  1409.                 thisDecode->numLines--;
  1410.                 return (DecodeLine (thisDecode, line));
  1411.             }
  1412.             strcpy (prevBlockIdent, thisDecode->ident);
  1413.         
  1414.                    if (!strncmp (line, "end", 3))
  1415.             {
  1416.                 thisDecode->endFlag = TRUE;
  1417.                 if (thisNumBlocks == -1 && thisDecode->sequence != -1)
  1418.                     thisNumBlocks = thisDecode->sequence;
  1419. #ifdef DEBUG_DECODE
  1420.                 sprintf(debug, "\nFound end of file %s", thisDecode->ident);
  1421.                 DebugLog();
  1422. #endif
  1423.             }                    
  1424.                 return (END_BLOCK);
  1425.         }
  1426.                   return (DecodeDataLine(thisDecode, line));
  1427.     }
  1428. }
  1429.  
  1430. /* ------------------------------------------------------------------------
  1431.  *  4 to 3 line decoder
  1432.  */
  1433. BOOL    DecodeDataLine (TypCoded *thisDecode, char *line)
  1434. {
  1435.     register unsigned int i, j;
  1436.     unsigned int decodedCount, numEncoded, numDecoded, checkSum, startNum, stop;
  1437.     unsigned char buf[4], outLine[120];
  1438.     char *thisMap = CodingMap[thisContentEncoding];
  1439.     
  1440.     switch (thisContentEncoding)
  1441.     {
  1442.     case CODE_QP:
  1443.        // not implemented yet
  1444.     return (FAIL);
  1445.     
  1446.     case CODE_UU:
  1447.     case CODE_XX:
  1448.     case CODE_CUSTOM:
  1449.     // these are 4-to-3 decodings which have the line length encoded
  1450.     // as the first char (count is # of chars after decoding)
  1451.     checkSum = decodedCount = thisMap[line[0]];
  1452.     numEncoded = 4 * ((thisMap[line[0]] + 2) / 3);    // don't include count char
  1453.     startNum = 1;
  1454.     break;
  1455.     case CODE_BASE64:
  1456.     // base64 is 4-to-3 decoding with nonexplicit line lengths 
  1457.     numEncoded = strlen(line);
  1458.     decodedCount = 3 * (numEncoded / 4);
  1459.     startNum = 0;
  1460.     break;
  1461.     }    
  1462.     for (i = startNum, numDecoded=0; numDecoded < decodedCount;)
  1463.     {
  1464.     // Get the next group of four characters 
  1465.     // Handle last group of characters in a base64 encoding specially -
  1466.     // padding '=' at end means we have fewer than 24 bits after decoding
  1467.     // Base64 end scenarios:
  1468.     //    'xx==' decodes to 8 bits
  1469.     //    'xxx=' decodes to 16 bits
  1470.     //    'xxxx' decodes to 24 bits
  1471.     //    'x===' can't happen
  1472.     stop = min(4, numEncoded - i + 1);
  1473.     for (j = 0; j < stop; j++, i++)
  1474.     {       
  1475.         if (thisContentEncoding == CODE_BASE64 && line[i] == '=')
  1476.         {
  1477.             buf[j] = 0;
  1478.             j--;
  1479.             break;
  1480.         }
  1481.         else
  1482.             buf[j] = thisMap[line[i]];
  1483.         checkSum += buf[j]; 
  1484.     }
  1485.     outLine[numDecoded++] = buf[0]<<2|buf[1]>>4;
  1486.     if (j == 1) break;
  1487.     outLine[numDecoded++] = buf[1]<<4|buf[2]>>2;
  1488.     if (j == 2) break;
  1489.     outLine[numDecoded++] = buf[2]<<6|buf[3];
  1490.     }
  1491.     if (numDecoded && AddDataToBlock (currentCoded, outLine, numDecoded) == FAIL)
  1492.     return (FAIL);
  1493.  
  1494. /*    if (checkSum%64 != line[i])
  1495.     {
  1496.         printf("\nChecksum error: %d vs. %d", checkSum%64, line[i]);
  1497.         break;
  1498.     } else
  1499.         printf("\nChecksum ok: %c vs. %c", checkSum%64, line[i]);
  1500. */
  1501.     return (SUCCESS);
  1502. }
  1503.  
  1504. /* ------------------------------------------------------------------------
  1505.  * AddDataToBlock is called on a line-by-line basis.
  1506.  * dataLen should rarely be > 100 bytes
  1507.  * The data is type huge, but it's just pointing to a string of chars, so
  1508.  * the size does not have to be a power of 2
  1509.  */
  1510. BOOL
  1511. AddDataToBlock (TypCoded *thisDecode, char *newData, unsigned int dataLen)
  1512. {
  1513.     if (thisDecode->numBytes + (unsigned long) dataLen > thisDecode->maxBytes)
  1514.     { 
  1515.             thisDecode->maxBytes += BASE_BLOCK_SIZE;
  1516. #ifdef DEBUG_MEM
  1517.         sprintf(debug, "\nReallocing data to %ld", thisDecode->maxBytes);
  1518.         DebugLog();
  1519. #endif
  1520.         if ((thisDecode->data = (char huge *) GlobalReAllocPtr (thisDecode->data, thisDecode->maxBytes, GMEM_MOVEABLE)) == NULL)    
  1521.             return (FALSE);
  1522.     }
  1523.     memmove (thisDecode->data + thisDecode->numBytes, newData, dataLen);
  1524.     thisDecode->numBytes += dataLen;
  1525.         return (SUCCESS);
  1526. }     
  1527.         
  1528. /* ------------------------------------------------------------------------
  1529.  *     Determine if the line is a data line
  1530.  */
  1531. BOOL
  1532. IsDataLine (char *line)
  1533. {
  1534.     if (thisContentEncoding == CODE_UNKNOWN)
  1535.     {
  1536. /* If this block has same ident as prev block, use same decode table
  1537.  * If this block has same ident as any existing threads, use same decode table
  1538.  * as matching thread
  1539.  * Otherwise, test line for UU, XX, or Base64, returning if find a fit
  1540.  */            
  1541.         if (currentCoded->ident[0] != '\0' && 
  1542.             !strcmp (currentCoded->ident, prevBlockIdent))
  1543.         {
  1544.             thisContentEncoding = prevContentEncoding;
  1545. #ifdef DEBUG_MAP
  1546.             strcpy (debug, "\nUsing same table as prev decode block");
  1547.             DebugLog();
  1548. #endif
  1549.         }
  1550.         else
  1551.             if ((thisContentEncoding = ThreadTable (customTable, currentCoded->ident)) != CODE_UNKNOWN)
  1552.             {
  1553.                if (thisContentEncoding == CODE_CUSTOM)
  1554.                 CreateCodingMap (CodingMap[CODE_CUSTOM], customTable);
  1555. #ifdef DEBUG_MAP
  1556.                 strcpy (debug, "\nUsing stored thread table");
  1557.                 DebugLog();
  1558. #endif
  1559.             }
  1560.             else
  1561.             {                
  1562.                 thisContentEncoding = CODE_UU;
  1563.                 if (TestDataLine (line))
  1564.                 {
  1565. #ifdef DEBUG_MAP
  1566.                     sprintf (debug, "\nUsing UU table: %s", line);
  1567.                     DebugLog();
  1568. #endif
  1569.                     return (TRUE);
  1570.                 }
  1571.                 thisContentEncoding = CODE_XX;
  1572.                 if (TestDataLine (line))
  1573.                 {
  1574. #ifdef DEBUG_MAP
  1575.                     sprintf (debug, "\nUsing XX table: %s", line);
  1576.                     DebugLog();
  1577. #endif
  1578.                     return (TRUE);
  1579.                 }
  1580.                 thisContentEncoding = CODE_BASE64;
  1581.                 if (TestDataLine (line))
  1582.                 {
  1583. #ifdef DEBUG_MAP
  1584.                     sprintf (debug, "\nUsing Base64 table: %s", line);
  1585.                     DebugLog();
  1586. #endif
  1587.                     return (TRUE);
  1588.                 }
  1589.                 thisContentEncoding = CODE_UNKNOWN;
  1590.                 return (FALSE);
  1591.             }
  1592.     }
  1593.     return (TestDataLine(line));
  1594. }
  1595.         
  1596. BOOL
  1597. TestDataLine (char *line)
  1598. {        
  1599.    unsigned int expectedLineLen, dataLen, lineLen;
  1600.    register unsigned int i;
  1601.    char *thisMap;
  1602.    
  1603.    thisMap = CodingMap[thisContentEncoding];
  1604.    lineLen = strlen(line);
  1605.    switch (thisContentEncoding)
  1606.    {
  1607.    case CODE_UU:
  1608.    case CODE_XX:
  1609.    case CODE_CUSTOM:
  1610. /*
  1611.  * The first char of a good data UU/XX/Custom line is the encoded character
  1612.  * count for the line.  
  1613.  * example M = ascii 77, decodes to 45.  This line will decode to 45 characters,
  1614.  * so the # encoded chars should be (int)(4 * ((n+2) / 3)) - (round up and re-encode)
  1615.  * So if line[0] is 'M', there should be 60 characters on the line
  1616.  * The count does not include the first count char, so the expected line 
  1617.  * length is count+1 (i.e. 61). 
  1618.  * If the line length is actually 2 + count, then we have a checksum (?)
  1619.  */ 
  1620.     expectedLineLen = 4 * ((thisMap[line[0]] + 2) / 3) + 1;
  1621.  
  1622.     if (lineLen < expectedLineLen)
  1623.          return (FALSE);
  1624. /*
  1625.  * Count the number of encoded data characters on the line (up to any whitespace)
  1626.  * (Some encoders pad with spaces at the end).  Don't forget, a space may be
  1627.  * a valid encoded char, so a proper line may very well end with a space.
  1628.  * Don't blindly remove all trailing white space!
  1629.  */        
  1630.      for (dataLen = lineLen; 
  1631.           isspace (line[dataLen-1]) && dataLen > 0 && dataLen != expectedLineLen; 
  1632.           --dataLen);
  1633.      
  1634.      // May have a checksum character, so allow for one extra char
  1635.      if (expectedLineLen != dataLen && expectedLineLen+1 != dataLen)
  1636.          return (FALSE);
  1637.      
  1638.      line[dataLen] = '\0';    // permanently chop off the white space
  1639.      // It's the right length, now check content for match w/ table
  1640.     for (i = 0; i < expectedLineLen; i++)
  1641.         if (thisMap[line[i]] == UNUSED)
  1642.             return (FALSE);
  1643.     return (TRUE);
  1644.  
  1645.     case CODE_BASE64:
  1646.     // permanently remove all trailing space
  1647.     while (lineLen > 0 && isspace (line[lineLen-1]))
  1648.         line[--lineLen] = '\0';
  1649.      
  1650.      // for base 64, just check if all chars in coding map (allow pad '=')
  1651.     for (i = 0; i < lineLen; i++)
  1652.         if (thisMap[line[i]] == UNUSED && line[i] != '=')
  1653.             return (FALSE);
  1654.     return (TRUE);
  1655.  
  1656.     case CODE_QP:
  1657.     // not implemented yet
  1658.     default:
  1659.         return (FALSE);
  1660.     }        
  1661. }                               
  1662.  
  1663. /* ------------------------------------------------------------------------
  1664.  *     Mappings for encoding/decoding
  1665.  */
  1666. int
  1667. CreateCodingMap(char *map, char *table)
  1668. {
  1669.     register unsigned int i;
  1670.     
  1671.     for (i=0; i < 128; i++)
  1672.         map[i] = UNUSED;
  1673.     
  1674.     // if you see a table[i] character, decode it to i
  1675.     // i.e. UU, table[1] is a '!'.  So a '!' should decode to 1
  1676.     
  1677.     for (i = 0; i < CODINGTABLESIZE; i++)
  1678.             if (map[table[i]] != UNUSED)
  1679.                 return (table[i]);    // table[i] is duplicate 
  1680.         else                
  1681.             map[table[i]]=i;
  1682.     
  1683. #ifdef DEBUG_MAP2
  1684.     sprintf(debug, "\nCoding Map:\n"); DebugLog();
  1685.     for (i=0; i < 128; i++)
  1686.     {
  1687.         sprintf(debug, "%d ",map[i]);
  1688.         DebugLog();
  1689.     } 
  1690. #endif
  1691.     return (-1);            
  1692. }
  1693.  
  1694. int   
  1695. ThreadTable (char *dest, char *ident)
  1696. {
  1697.     int num;
  1698.     register int i;
  1699.     
  1700.     for (num = -1, i = 0; i < numDecodeThreads; i++)
  1701.         if (!_stricmp (ident, threadList[i]->ident))
  1702.             num = i;
  1703.  
  1704.     if (num == -1)        // no thread by that name 
  1705.         return (CODE_UNKNOWN);
  1706.     else
  1707.     {
  1708.         if (threadList[num]->contentEncoding == CODE_CUSTOM)
  1709.             strncpy (dest, threadList[num]->customTable, CODINGTABLESIZE);
  1710.         return (threadList[num]->contentEncoding);
  1711.     }
  1712. }
  1713. #if 0
  1714. void
  1715. CreateUUTable()
  1716. {
  1717.     register unsigned int i;
  1718.  
  1719.     for (i=0; i < CODINGTABLESIZE; i++)
  1720.         uuTable[i] = i + 32;
  1721.     
  1722.     uuTable[0] = 96;        /* set space to map to back-quote */    
  1723. }
  1724. #endif
  1725.  
  1726. /* ------------------------------------------------------------------------
  1727.  *    Search through a subject: or BEGIN line 
  1728.  *    (for a Subject: line,  "Subject:" has already been removed).
  1729.  *
  1730.  *    Attempt to obtain a block number, and a total # of blocks
  1731.  *    Generate an identifier based on the subject, preferably based on the
  1732.  *    actual file name.  If guessIdent is TRUE, choose an ident even if
  1733.  *    it doesn't look like a fileName.  If guessIdent is FALSE, only fill
  1734.  *    ident if we see a fileName (word containing a dot).
  1735.  *
  1736.  *    Note: at this point, we haven't seen any MIME header, and we're not
  1737.  *    really expecting one.  So now is the time to get what we can
  1738.  *
  1739.  *    Common Subject styles which this function deals with:
  1740.  *    filename.ext 1/2 comment
  1741.  *    filename.ext(1/2)comment
  1742.  *    filename.ext (1/2) comment
  1743.  *    filename.ext [1/2] comment
  1744.  *    filename.ext 1 of 2 comment
  1745.  *    filename.ext part 1 of 2 comment
  1746.  *    filename.ext 1 of 2 comment
  1747.  *    This is part 1/2 of filename.ext
  1748.  *
  1749.  *    Also handles the following common BEGIN lines:
  1750.  *    BEGIN --- CUT HERE --- Cut Here --- cut here --- abcd.efg n/N
  1751.  *     BEGIN --- CUT HERE --- Cut Here --- cut here --- abcd.efg
  1752.  *    BEGIN-------cut here-------CUT HERE-------PART n               // This is TIN
  1753.  *    BEGIN -- CUT HERE -- cut here -- abcd.efg part n of N
  1754.  *    BEGIN---CUT HERE---BEGIN---CUT HERE---BEGIN PART n/N
  1755.  *
  1756.  *    For subject lines beginning with the comment, or free text, the
  1757.  *    name is harder to guess.  In these cases, prefer a word containing
  1758.  *    a dot (filename.ext), or if none, just take the first word.  Scan
  1759.  *    any existing threads to see if any of their identifiers matches.
  1760.  *    For example,
  1761.  *    another encoded file: filename.ext (1/2)
  1762.  *    testing encoded files (1/2)    i.e. ident would be testing
  1763.  *
  1764.  *     Known to be incorrectly handled by this function:
  1765.  *    filename.ext 3.4 (1/2)        i.e. name w/ version number
  1766.  *    filename.ext 001        i.e. sequence w/ no # parts
  1767.  *    filename.ext1            i.e. part number appended to file name
  1768.  */ 
  1769. #define SEEK_PARTNUM    1
  1770. #define SEEK_NUMPARTS    2
  1771. #define IGNORE_NUMBERS    3
  1772. void
  1773. ParseInfoLine (TypCoded *thisDecode, char *line, BOOL guessIdent)
  1774. {
  1775.     char tok[MAXINTERNALLINE], next[MAXINTERNALLINE];
  1776.     char guessName[MAXINTERNALLINE];
  1777.     char *ptr, *thisTok, *tmp;
  1778.     int  numberMode;
  1779.     
  1780.     numberMode = SEEK_PARTNUM;
  1781.     ptr = line;
  1782.         
  1783.     guessName[0] = '\0';
  1784.         while (*ptr)
  1785.         {
  1786.             if (ReadSubjectToken (thisTok = tok, &ptr) == NULL)
  1787.                 break;
  1788.         
  1789. //    NUMBERS
  1790.         if (numberMode != IGNORE_NUMBERS)
  1791.            if (isnumber (thisTok))
  1792.            {
  1793.             if (numberMode == SEEK_PARTNUM)
  1794.             {
  1795.                 thisDecode->sequence = atoi (thisTok);
  1796.                 thisDecode->seqConfidence = LOW;
  1797.  
  1798.                 if (ReadSubjectToken (next, &ptr) == NULL)
  1799.                     break;
  1800.                 if (!_stricmp (next, "/") ||
  1801.                     !_stricmp (next, "of"))
  1802.                 {
  1803.                     numberMode = SEEK_NUMPARTS;        
  1804.                     continue;
  1805.                 }
  1806.                 else    // no numParts immediately following
  1807.                     thisTok = next;    // process the next tok
  1808.             }
  1809.             else    // numberMode == SEEK_NUMPARTS
  1810.             {
  1811.                 thisNumBlocks = atoi (tok);
  1812.                 numberMode = IGNORE_NUMBERS;
  1813.                 thisDecode->seqConfidence = HIGH;
  1814.                     continue;
  1815.             }
  1816.            }
  1817.            else if (numberMode == SEEK_NUMPARTS)
  1818. //           We had '# of non#', a red herring, seek again
  1819.             numberMode == SEEK_PARTNUM;
  1820.             
  1821. //    WORDS
  1822.         // Prefer a word containing a dot for the ident (but not a period
  1823.         // at the end of a sentence
  1824.             if ((tmp = strchr (thisTok, '.')) && isalpha(*(tmp+1)))
  1825.             strcpy (thisDecode->ident, thisTok);
  1826.             else if (guessIdent)
  1827.             {
  1828.                 // skip if already have name w/ confidence
  1829.                 if (thisDecode->ident[0] == '\0')
  1830.             {
  1831.             // check if any threads have this token as name
  1832.                    if (SearchThreadNames (thisTok))
  1833.                     strcpy (thisDecode->ident, thisTok);
  1834.  
  1835.             // Save first word found for thread name
  1836.             // prefer ident not starting with 're'
  1837.                    else if (guessName[0] == '\0' || !_strnicmp(guessName, "re", 2))
  1838.                     strcpy (guessName, thisTok);
  1839.                 }
  1840.             }
  1841.     }
  1842.     if (guessIdent && thisDecode->ident[0] == '\0')
  1843.         strcpy (thisDecode->ident, guessName);
  1844.  
  1845. #ifdef DEBUG_DECODE
  1846.     sprintf(debug, "\nSubject header: name %s, part number %d (confidence %d), num parts %d", 
  1847.         thisDecode->ident, thisDecode->sequence, thisDecode->seqConfidence, thisNumBlocks);
  1848.     DebugLog();
  1849. #endif
  1850. }
  1851.  
  1852. char *
  1853. ReadSubjectToken (char *dest, char **ptr)
  1854. {
  1855.     int len;
  1856.     register int i;
  1857.     char *str = *ptr;
  1858.     
  1859.     if (*str == '\0')
  1860.         return ('\0');
  1861.         
  1862.     len = strcspn (str, " ()[]\\/:,\"'`{};\n\r");
  1863.  
  1864. /*    Ignore (skip) all of these delimiters except '/'
  1865.  *    Return '/' as a token of length 1
  1866.  */                      
  1867.     if (len == 0)
  1868.         if (*str == '/')
  1869.             len = 1;
  1870.         else
  1871.         {    // skip this delimiter
  1872.             (*ptr)++;
  1873.             return (ReadSubjectToken (dest, ptr));
  1874.         }
  1875.  
  1876.         for (i = 0; i < len; i++)
  1877.             dest[i] = tolower(str[i]);
  1878.         dest[len] = '\0';
  1879.  
  1880.     *ptr = str + len;    // increment line ptr    
  1881. }
  1882.  
  1883. BOOL
  1884. SearchThreadNames (char *name)
  1885. {
  1886.     register int i;
  1887.     int len;
  1888.     
  1889.     len = strlen (name);
  1890.  
  1891.     for (i = 0; i < numDecodeThreads; i++)
  1892.         if (!_strnicmp (name, threadList[i]->ident, len))
  1893.             return (TRUE);
  1894.  
  1895.     return (FALSE);
  1896. }
  1897.  
  1898. /* ParseAppSpecificLine
  1899.  * returns TRUE if it handles the line, else FALSE
  1900.  *
  1901.  * Example info lines handled by this function:
  1902.  *    part=n
  1903.  *    file=abc.def
  1904.  *    pfile=xyz.abc 
  1905.  *    Archive-name: fileident/part0n        // no extension included for filename
  1906.  *
  1907.  *     section N of uuencode 5.10 of file abcd.efg   by R.E.M.
  1908.  *    section n/N   file abcd.efg   [ Wincode v2.3 ]
  1909.  *    [ Section: n/N  File: abcd.efg  Encoder: Wincode v1.4 ]
  1910.  *    section n/N abcd.efg  [EnUU 2.1]
  1911.  *  abcd.efg    section  n/N   UUXFER ver 2.0 by David M. Read
  1912.  *    POST V2.0.0 abcd.efg (Part n/N)
  1913.  */
  1914. BOOL
  1915. ParseAppSpecificLine (TypCoded *thisDecode, char *line)
  1916. {
  1917.     char *orig, *ptr;
  1918.     int seq, num, len;
  1919.     float ver;
  1920.     char name[MAXINTERNALLINE];
  1921.     char copy[MAXINTERNALLINE];
  1922.     
  1923.        for (orig = line; *orig && isspace(*orig); orig++);    // skip leading spaces
  1924.     
  1925.     if (*orig == '\0')            // blank line (or all spaces)
  1926.             return (SUCCESS);
  1927.  
  1928.     len = min(MAXINTERNALLINE-1, strlen(orig));
  1929.     strncpy (copy, orig, len);    // make a lower-case copy
  1930.     copy[len] = '\0';
  1931.     strlwr(copy);
  1932.     
  1933.     if (!strncmp(orig, "BEGIN", 5))    // specifically comparing case-sensitive
  1934.     {
  1935.         ParseInfoLine(thisDecode, copy, FALSE);
  1936.         return (TRUE);
  1937.     }
  1938.  
  1939.     if (sscanf(copy, "file=%s", name) == 1)
  1940.     {
  1941.         strcpy (thisDecode->ident, name);
  1942.         return (TRUE);
  1943.     }
  1944.  
  1945.     if (*copy == 'p')    // info headers starting with 'p'
  1946.     {
  1947.         if (sscanf(copy, "part=%d", &seq) == 1)
  1948.         {
  1949.             thisDecode->sequence = seq;
  1950.             if (!thisDecode->seqConfidence)
  1951.                 thisDecode->seqConfidence = LOW; // still don't have number of parts
  1952.             return (TRUE);
  1953.         }
  1954.         if (sscanf(copy, "pfile=%s", name) == 1)
  1955.         {
  1956.             strcpy (thisDecode->ident, name);
  1957.             return (TRUE);
  1958.         }
  1959.         /* POST */
  1960.         if (sscanf (copy, "POST V%*s %s (Part %d/%d)", name, &seq, &num) == 3)
  1961.         {
  1962.             thisDecode->sequence = seq;
  1963.             thisNumBlocks = num;
  1964.             thisDecode->seqConfidence = HIGH;
  1965.             strcpy (thisDecode->ident, name);
  1966.             return (TRUE);
  1967.         }
  1968.         return (FALSE);    // started with 'p' but we didn't have a template
  1969.     }
  1970.  
  1971.     /* note some of these look for a version number, then don't use it.  the
  1972.        version number is scanned simply to add to our confidence that this is
  1973.        a valid info line.  we want it to be included in the count - so we know
  1974.        if the line fits the template (hence don't use %*f)
  1975.     */
  1976.  
  1977.     /* R.E.M., EnUU, and WinCode v2.x all start with "section " */
  1978.     if (!strncmp(copy, "section", 7))
  1979.     {
  1980.         ptr = ©[7];
  1981.         /* R.E.M. */
  1982.         if (sscanf (ptr, " %d of uuencode %f of file %s", &seq, &ver, name) == 3)
  1983.         {    
  1984.             thisDecode->sequence = seq;
  1985.             if (!thisDecode->seqConfidence)
  1986.                 thisDecode->seqConfidence = LOW; // still don't have number of parts
  1987.                     
  1988.             strcpy (thisDecode->ident, name);
  1989.             thisContentEncoding = CODE_UU;
  1990.             return (TRUE);
  1991.         }
  1992.          /* EnUU */
  1993.          if (sscanf (ptr, " %d/%d %s [EnUU %f]", &seq, &num, name, &ver) == 4)
  1994.         {
  1995.             thisDecode->sequence = seq;
  1996.             thisNumBlocks = num;
  1997.             thisDecode->seqConfidence = HIGH; 
  1998.             strcpy (thisDecode->ident, name);
  1999.             thisContentEncoding = CODE_UU;
  2000.             return (TRUE);
  2001.         }
  2002.         /* Wincode v2.x */
  2003.         if (sscanf (ptr, " %d/%d  file %s [ Wincode v%f ]", &seq, &num, name, &ver) == 4)
  2004.         {
  2005.             thisDecode->sequence = seq;
  2006.             thisNumBlocks = num;
  2007.             thisDecode->seqConfidence = HIGH; 
  2008.             strcpy (thisDecode->ident, name);
  2009.             return (TRUE);
  2010.         }
  2011.         return (FALSE);    // started with 'section' but we didn't have a template
  2012.     }
  2013.     /* Wincode v1.x */
  2014.     if (sscanf (copy, "[ section: %d/%d  File: %s  Encoder: Wincode v%f", &seq, &num, &ver) == 4)
  2015.     {
  2016.         thisDecode->sequence = seq;
  2017.         thisNumBlocks = num;
  2018.         thisDecode->seqConfidence = HIGH; 
  2019.         strcpy (thisDecode->ident, name);
  2020.         return (TRUE);
  2021.     }
  2022.  
  2023.     /* UUXFER */
  2024.     if (sscanf (copy, "%s section %d/%d  UUXFER ver %f", name, &seq, &num, &ver) == 4)
  2025.     {    
  2026.         thisDecode->sequence = seq;
  2027.         thisNumBlocks = num;
  2028.         thisDecode->seqConfidence = HIGH; 
  2029.         strcpy (thisDecode->ident, name);
  2030.         thisContentEncoding = CODE_UU;
  2031.         return (TRUE);
  2032.     }
  2033.  
  2034.     if (sscanf(copy, "archive-name: %[^/]/part%d", name, &seq) == 2)        // %[^/] reads a string up to a slash
  2035.     {
  2036.         strcpy (thisDecode->ident, name);
  2037.         thisDecode->sequence = seq;
  2038.         if (!thisDecode->seqConfidence)
  2039.             thisDecode->seqConfidence = LOW; // still don't have number of parts
  2040.         return (TRUE);
  2041.     }
  2042.  
  2043.     return (FALSE);
  2044. }
  2045. //-------------------------------------------------------------------------
  2046. void
  2047. ExecuteDecodedFile(int num, char *fileName)
  2048. {
  2049.     char ext[4];        // these are DOS specific...
  2050. //    char name[9];
  2051.     char association[MAXINTERNALLINE];
  2052.     char execute[MAXINTERNALLINE+MAXFILENAME];
  2053.     int len;
  2054.     unsigned int err;
  2055.     char *src, *dest, *src2;
  2056.     char mybuf[MAXINTERNALLINE];
  2057.  
  2058. #ifndef WIN32
  2059.     GetFileExtension (ext, fileName);
  2060.  
  2061.         if (!_stricmp (ext, "exe"))
  2062.             strcpy (execute, fileName);
  2063.     else
  2064.     // example association: doc=C:\WIN\WINWORD\winword.exe ^.doc
  2065.  
  2066.     if ((len = GetProfileString ("Extensions", (LPCSTR)ext, "", association, MAXINTERNALLINE)) != 0)
  2067.     {
  2068.       for (src = association, dest = execute; *src; src++)
  2069.       {
  2070.         if (*src == '^')
  2071.         {
  2072.             for (src2 = fileName; *src2 && *src2 != '.'; src2++)
  2073.                *(dest++) = *src2;
  2074.         }
  2075.         else
  2076.            *(dest++) = *src;
  2077.       }
  2078.       *dest = '\0';
  2079.         }
  2080.         else
  2081.         {
  2082.         sprintf(mybuf, "Cannot execute - no association for file type %s", ext);
  2083.         UpdateThreadStatus (num, mybuf);
  2084.         return;
  2085.     }
  2086.  
  2087. #else
  2088.         FindExecutable (fileName, ".", association);
  2089.     wsprintf (execute, "%s %s", association, fileName);
  2090. #endif
  2091.     if ((err = WinExec (execute, SW_SHOWNORMAL)) < 32)
  2092.     {
  2093.         sprintf(mybuf, "Error executing %s, error %u", execute, err);
  2094.         UpdateThreadStatus (num, mybuf);
  2095.     }
  2096.     else if (CodingStatusVerbose)
  2097.     {
  2098.         sprintf(mybuf, "Executed %s", execute);
  2099.         UpdateThreadStatus (num, mybuf);
  2100.     }
  2101. }
  2102.