home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / text_cla / cpt.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-12  |  19.7 KB  |  923 lines
  1. //////////////////////////////////////////////////////////////////////// 
  2. //+ 
  3. //  Module Name:  cpt.cpp 
  4. // 
  5. //  Description:  CPT specific routines to EnCryPT data 
  6. //                 
  7. //                Method is 255 byte swap with optional convolutions 
  8. //                to increase strength of encryption. 
  9. // 
  10. //                Can be used on any file (text, binary, etc.) 
  11. // 
  12. //                NOTE:  Although this method will keep most people and 
  13. //                       most hackers from decoding your data, 
  14. //                       it is NOT intended for use on government or 
  15. //                       DoD data which requires specific security 
  16. //                       performance.   
  17. // 
  18. // 
  19. //  Include Modules Referenced:  cpt.h 
  20. // 
  21. //  Written by:  John Tal 
  22. // 
  23. // 
  24. //  Modification history: 
  25. // 
  26. //  Date         Engineer     Mod #          Modification Description 
  27. // 
  28. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  29. //- 
  30. //////////////////////////////////////////////////////////////////////// 
  31.  
  32.  
  33.   
  34. #include <stdio.h> 
  35. #include <stdlib.h> 
  36.  
  37. #include <memincs.h> 
  38. #include <cpt.h> 
  39.  
  40.  
  41.   
  42. //////////////////////////////////////////////////////////////////////// 
  43. //+ 
  44. // Function Name:   lpad 
  45. // 
  46. // Class:           STRUTIL_C 
  47. // 
  48. // Security:        Private 
  49. // 
  50. // Description:     Left pad a field with blanks 
  51. // 
  52. // Parameters 
  53. //    In:           str = string to pad 
  54. //                  width = width to pad 
  55. // 
  56. // Return Codes:    SHORT = C_OK always returned 
  57. // 
  58. // Written by:      John Tal 
  59. // 
  60. // 
  61. // Modification History: 
  62. // 
  63. //  Date         Engineer     Mod #          Modification Description 
  64. // 
  65. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  66. // 
  67. //- 
  68. //////////////////////////////////////////////////////////////////////// 
  69.  
  70. STRUTIL_C::lpad(CHAR * str,INT width) 
  71. { 
  72.     C_DEF_MODULE("STRUTIL_C::lpad") 
  73.  
  74.     INT i,w; 
  75.  
  76.     w = strlen(str); 
  77.  
  78.     /**************************************** 
  79.           if needs padding 
  80.     ****************************************/ 
  81.     if(width > w) 
  82.     { 
  83.        /*  move bytes */ 
  84.        /* 
  85.            123 
  86.            12    3 
  87.            1    23 
  88.                123 
  89.        */ 
  90.        for(i = 0; i < w; i++) 
  91.           str[width-i-1] = str[w-i-1]; 
  92.  
  93.        /*  pad with spaces */ 
  94.        for(i = 0; i < (width - w); i++) 
  95.           str[i] = ' '; 
  96.  
  97.        /*  mark end */ 
  98.        str[width] = '\0'; 
  99.     } 
  100.  
  101.     /**************************************** 
  102.           if needs truncating 
  103.     ****************************************/ 
  104.     if(width < w)    
  105.        str[width] = '\0'; 
  106.  
  107.     C_RETURN 
  108. } 
  109.  
  110.   
  111. //////////////////////////////////////////////////////////////////////// 
  112. //+ 
  113. // Function Name:   srep 
  114. // 
  115. // Class:           STRUTIL_C 
  116. // 
  117. // Security:        Public 
  118. // 
  119. // Description:     String replacement of characters 
  120. // 
  121. // Parameters 
  122. //    In:           ch = string to check 
  123. //                  dh = character to search for 
  124. //                  eh = character to replace with 
  125. // 
  126. // Return Codes:    SHORT = C_OK always returned 
  127. // 
  128. // Written by:      John Tal 
  129. // 
  130. // 
  131. // Modification History: 
  132. // 
  133. //  Date         Engineer     Mod #          Modification Description 
  134. // 
  135. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  136. // 
  137. //- 
  138. //////////////////////////////////////////////////////////////////////// 
  139.  
  140. SHORT STRUTIL_C::srep(CHAR * ch,CHAR dh,CHAR eh) 
  141. { 
  142.    C_DEF_MODULE("STRUTIL_C::srep") 
  143.  
  144.    INT i; 
  145.  
  146.    for(i = 0; i < strlen(ch); i++) 
  147.       if(ch[i] == dh) 
  148.          ch[i] = eh; 
  149.    
  150.    C_RETURN 
  151. } 
  152.  
  153.   
  154. //////////////////////////////////////////////////////////////////////// 
  155. //+ 
  156. // Function Name:   SetJob 
  157. // 
  158. // Class:           CPT_C 
  159. // 
  160. // Security:        Public 
  161. // 
  162. // Description:     Set Job type to CPT_CODE or CPT_DECODE 
  163. // 
  164. // Parameters 
  165. //    In:           Job type to set to 
  166. // 
  167. // Return Codes:    SHORT = C_OK always returned 
  168. // 
  169. // Written by:      John Tal 
  170. // 
  171. // 
  172. // Modification History: 
  173. // 
  174. //  Date         Engineer     Mod #          Modification Description 
  175. // 
  176. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  177. // 
  178. //- 
  179. //////////////////////////////////////////////////////////////////////// 
  180.  
  181. SHORT  CPT_C::SetJobType(INT iJob) 
  182. { 
  183.    C_DEF_MODULE("CPT_C::SetJobType") 
  184.  
  185.    iJobType = iJob; 
  186.  
  187.    C_RETURN 
  188. } 
  189.  
  190.   
  191. //////////////////////////////////////////////////////////////////////// 
  192. //+ 
  193. // Function Name:   MemoryKeyGen 
  194. // 
  195. // Class:           CPT_C 
  196. // 
  197. // Security:        Public 
  198. // 
  199. // Description:     Generate a key set in memory 
  200. // 
  201. // Parameters 
  202. //    In:           iConvolutionSet = set to generate keys for 
  203. // 
  204. // Return Codes:    SHORT = C_OK always returned 
  205. // 
  206. // Written by:      John Tal 
  207. // 
  208. // 
  209. // Modification History: 
  210. // 
  211. //  Date         Engineer     Mod #          Modification Description 
  212. // 
  213. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  214. // 
  215. //- 
  216. //////////////////////////////////////////////////////////////////////// 
  217.  
  218. SHORT  CPT_C::MemoryKeyGen(INT iConvolutionSet) 
  219. { 
  220.    C_DEF_MODULE("CPT_C::MemoryKeyGen") 
  221.  
  222.    unsigned top; 
  223.    INT f; 
  224.    INT i; 
  225.    UCHAR  hold_area[256]; 
  226.  
  227. #ifdef ANNOUNCE 
  228.    if(iSet == 0) 
  229.      printf("\nGenerating Keys - Please Stand By"); 
  230. #endif 
  231.  
  232.    for(i = 0; i < ASCIIBYTES+1; i++) 
  233.    { 
  234.       hold_area[i] = i; 
  235.       cBytes[CPT_ENCODE][iConvolutionSet][i] = -1; 
  236.    } 
  237.  
  238.    srand(iSet); 
  239.  
  240.    /* 
  241.    **  Use 'quick' randomizer 
  242.    **  It copies the top element that has not been selected when 
  243.    **  a duplicate random number is found. 
  244.    */ 
  245.  
  246.    for(top = 256; top > 0; top--) 
  247.    { 
  248.        f = (rand() % 256); 
  249.        cBytes[CPT_ENCODE][iConvolutionSet][top-1] = hold_area[f]; 
  250.        if(f != top-1) 
  251.           hold_area[f] = hold_area[top-1]; 
  252.    } 
  253.  
  254.    C_RETURN 
  255. } 
  256.   
  257. //////////////////////////////////////////////////////////////////////// 
  258. //+ 
  259. // Function Name:   CptUsrGetKeyData 
  260. // 
  261. // Class:           (Standalone) 
  262. // 
  263. // Security:        N/A 
  264. // 
  265. // Description:     Get key set parms from user 
  266. // 
  267. // Parameters 
  268. //    In:           pcSeedPathName = File being looked for 
  269. // 
  270. // Return Codes:    SHORT = FIO_OK = file exists 
  271. //                        = FIO_NO_FILE = file does not exist 
  272. // 
  273. // Written by:      John Tal 
  274. // 
  275. // 
  276. // Modification History: 
  277. // 
  278. //  Date         Engineer     Mod #          Modification Description 
  279. // 
  280. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  281. // 
  282. //- 
  283. //////////////////////////////////////////////////////////////////////// 
  284.  
  285. SHORT  CptGetKeyData(VOID) 
  286. { 
  287.    C_DEF_MODULE("CptGetKeyData") 
  288.  
  289.    INT keynum; 
  290.    INT i; 
  291.    CHAR  szKeyStr[CPT_KEYSTR_LEN + 1]; 
  292.    CHAR  szKeyFile[CPT_FILE_LEN + 1]; 
  293.    STRUTIL_C  cStrUtil; 
  294.  
  295.    printf("\n\n\nEnter Reference Number For This Key "); 
  296.    scanf("%d",&i); 
  297.    sprintf(szKeyStr,"%d",i); 
  298.    cStrUtil.lpad(szKeyStr,4); 
  299.    cStrUtil.srep(szKeyStr,' ','0'); 
  300.  
  301.    cCpt.SetKeyStr(szKeyStr); 
  302.  
  303.    strcpy(szKeyFile,"key_"); 
  304.    strcat(szKeyFile,szKeyStr); 
  305.    strcat(szKeyFile,".cpt"); 
  306.  
  307.    cCpt.SetKeyFile(szKeyFile); 
  308.  
  309.    printf("\nEnter Convolutions (Usally 1, higher = tighter security) "); 
  310.    scanf("%d",i); 
  311.  
  312.    cCpt.SetConvolutions(i); 
  313.  
  314.    C_RETURN 
  315. } 
  316.   
  317. //////////////////////////////////////////////////////////////////////// 
  318. //+ 
  319. // Function Name:   GenKeys 
  320. // 
  321. // Class:           CPT_C 
  322. // 
  323. // Security:        Protected 
  324. // 
  325. // Description:     Create keys. 
  326. // 
  327. // Parameters 
  328. //    In:           NONE 
  329. // 
  330. // Return Codes:    SHORT = C_OK always returned 
  331. // 
  332. // Written by:      John Tal 
  333. // 
  334. // 
  335. // Modification History: 
  336. // 
  337. //  Date         Engineer     Mod #          Modification Description 
  338. // 
  339. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  340. // 
  341. //- 
  342. //////////////////////////////////////////////////////////////////////// 
  343.  
  344. SHORT  CPT_C::GenKeys(VOID) 
  345. { 
  346.    C_DEF_MODULE("CPT_C::GenKeys") 
  347.  
  348.    INT i; 
  349.  
  350.    for(i = 0; i < iConvolutions; i++) 
  351.    { 
  352.       C_STATUS = KeyGen(i); 
  353.    } 
  354.  
  355.    C_RETURN 
  356. } 
  357.   
  358. //////////////////////////////////////////////////////////////////////// 
  359. //+ 
  360. // Function Name:   WriteKeys 
  361. // 
  362. // Class:           CPT_C 
  363. // 
  364. // Security:        Public 
  365. // 
  366. // Description:     Write key file. 
  367. // 
  368. // Parameters 
  369. //    In:           NONE 
  370. // 
  371. // Return Codes:    SHORT = C_OK = success 
  372. //                         !C_OK = failure 
  373. // 
  374. // Written by:      John Tal 
  375. // 
  376. // 
  377. // Modification History: 
  378. // 
  379. //  Date         Engineer     Mod #          Modification Description 
  380. // 
  381. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  382. // 
  383. //- 
  384. //////////////////////////////////////////////////////////////////////// 
  385.   
  386.  
  387. SHORT  CPT_C::WriteKeys(VOID) 
  388. { 
  389.    INT iC; 
  390.    INT i; 
  391.  
  392.    KeyFile = fopen(szKeyFile,"w+"); 
  393.    if(KeyFile == NULL) 
  394.       C_LEAVE(C_NOTOK) 
  395.     
  396.    fprintf(KeyFile,"%s %s %s %d\n",  
  397.            CPT_ID, CPT_VER, szKeyStr, iConvolutions); 
  398.  
  399.    for(iC = 0; iC < iConvolutions; iC++) 
  400.    { 
  401.      for(i = 0; i < ASCIIBYTES+1; i++) 
  402.        fprintf(KeyFile,"%d\n", -> cBytes[CPT_ENCODE][iC][i]); 
  403.    } 
  404.  
  405.    fclose(KeyFile); 
  406.    KeyFile = NULL; 
  407.  
  408. C_MODULE_EXIT: 
  409.  
  410.    C_RETURN 
  411. } 
  412.  
  413.    
  414. SHORT CPT_C::OpenKeyFile(VOID) 
  415. { 
  416.    C_DEF_MODULE("CPT_C::OpenKeyFile") 
  417.  
  418.    KeyFile = fopen(szKeyFile,"w+"); 
  419.    if(KeyFile == NULL) 
  420.       C_LEAVE(C_NOTOK) 
  421.  
  422. C_MODULE_EXIT: 
  423.    
  424.    C_RETURN 
  425. } 
  426.  
  427. SHORT CPT_C::CloseKeyFile(VOID) 
  428. { 
  429.    C_DEF_MODULE("CPT_C::CloseKeyFile") 
  430.  
  431.    fclose(KeyFile); 
  432.    KeyFile = NULL; 
  433.    
  434.    C_RETURN 
  435. } 
  436.  
  437. SHORT CPT_C::OpenInFile(VOID) 
  438. { 
  439.    C_DEF_MODULE("CPT_C::OpenInFile") 
  440.  
  441.    InFile = fopen(szInFile,"rb"); 
  442.    if(InFile == NULL) 
  443.       C_LEAVE(C_NOTOK) 
  444.  
  445. C_MODULE_EXIT: 
  446.  
  447.    C_RETURN 
  448. } 
  449.    
  450. SHORT CPT_C::CloseInFile(VOID) 
  451. { 
  452.    C_DEF_MODULE("CPT_C::CloseInFile") 
  453.  
  454.    fclose(InFile); 
  455.    InFile = NULL; 
  456.    
  457.    C_RETURN 
  458. } 
  459.  
  460.  
  461. SHORT CPT_C::OpenOutFile(VOID) 
  462. { 
  463.    C_DEF_MODULE("CPT_C::OpenOutFile") 
  464.  
  465.    OutFile = fopen(szOutFile,"w+b"); 
  466.    if(OutFile == NULL) 
  467.       C_LEAVE(C_NOTOK) 
  468.  
  469. C_MODULE_EXIT: 
  470.  
  471.    C_RETURN 
  472. } 
  473.    
  474. SHORT CPT_C::CloseOutFile(VOID) 
  475. { 
  476.    C_DEF_MODULE("CPT_C::CloseInFile") 
  477.  
  478.    fclose(OutFile); 
  479.    OutFile = NULL; 
  480.    
  481.    C_RETURN 
  482. } 
  483.  
  484.   
  485. SHORT  CPT_C::SetConvolutions(INT iConvs) 
  486. { 
  487.    C_DEF_MODULE("CPT_C::SetConvolutions") 
  488.  
  489.    iConvolutions = iConvs; 
  490.  
  491.    if(iConvolutions > CPT_MAX_CONVOLUTIONS) 
  492.       iConvolutions = CPT_MAX_CONVOLUTIONS; 
  493.  
  494.    C_RETURN 
  495. } 
  496.  
  497. SHORT  CPT_C::SetKeyFileName(PCHAR pcData) 
  498. { 
  499.    C_DEF_MODULE("CPT_C::SetKeyFileName") 
  500.  
  501.    strcpy(szKeyFile,pcData) 
  502.  
  503.    C_RETURN 
  504. } 
  505.  
  506. SHORT  CPT_C::SetKeyStr(PCHAR pcData) 
  507. { 
  508.    C_DEF_MODULE("CPT_C::SetKeyStr") 
  509.  
  510.    strcpy(szKeyStr,pcData) 
  511.  
  512.    C_RETURN 
  513. } 
  514.  
  515. SHORT  CPT_C::SetInFile(PCHAR pcData) 
  516. { 
  517.    C_DEF_MODULE("CPT_C::SetInFile") 
  518.  
  519.    strcpy(szInFile,pcData) 
  520.  
  521.    C_RETURN 
  522. } 
  523.  
  524.  
  525. SHORT  CPT_C::SetOutFile(PCHAR pcData) 
  526. { 
  527.    C_DEF_MODULE("CPT_C::SetOutFile") 
  528.  
  529.    strcpy(szOutFile,szKey) 
  530.  
  531.    C_RETURN 
  532. } 
  533.  
  534.  
  535. SHORT  CPT_C::SetKeyFile(FILE *fp) 
  536. { 
  537.    C_DEF_MODULE("CPT_C::SetKeyFile") 
  538.  
  539.    KeyFile = fp; 
  540.  
  541.    C_RETURN 
  542. } 
  543.  
  544.  
  545.   
  546. //////////////////////////////////////////////////////////////////////// 
  547. //+ 
  548. // Function Name:   ReadInKeys 
  549. // 
  550. // Class:           CPT_C 
  551. // 
  552. // Security:        Public 
  553. // 
  554. // Description:     Read in keys from file 
  555. // 
  556. // Parameters 
  557. //    In:           NONE 
  558. // 
  559. // Return Codes:    SHORT = C_OK = success 
  560. //                         !C_OK = failure 
  561. // 
  562. // Written by:      John Tal 
  563. // 
  564. // 
  565. // Modification History: 
  566. // 
  567. //  Date         Engineer     Mod #          Modification Description 
  568. // 
  569. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  570. // 
  571. //- 
  572. //////////////////////////////////////////////////////////////////////// 
  573.   
  574. SHORT  CPT_C::ReadInKeys(VOID) 
  575. { 
  576.    C_DEF_MODULE("CPT_C::ReadInKeys") 
  577.  
  578.    CHAR data[5]; 
  579.    INT i,i2,iC; 
  580.  
  581.    fscanf(KeyFile,"%s %s %s %d", 
  582.           szCptId, 
  583.           szCptVers, 
  584.           szCptKeyId, 
  585.           &iConvolutions); 
  586.  
  587.    for(iC = 0; iC < iConvolutions; iC++) 
  588.    { 
  589.      for(i = 0; i < ASCIIBYTES+1; i++) 
  590.      { 
  591.         fgets(data,BUFSIZE,KeyFile); 
  592.         i2 = atoi(data); 
  593. #ifdef DEBUG 
  594.         printf("Read %d (%c) at %d (%c)\n", i2,i2,i,i); 
  595. #endif 
  596.         cBytes[CPT_ENCODE][iC][i] = i2; 
  597.      } 
  598.    }    
  599.     
  600.    if(iJob == CPT_DECODE) 
  601.       ReverseKeys(); 
  602.  
  603. C_MODULE_EXIT: 
  604.  
  605.    C_RETURN 
  606. } 
  607.   
  608. //////////////////////////////////////////////////////////////////////// 
  609. //+ 
  610. // Function Name:   ReverseKeys 
  611. // 
  612. // Class:           CPT_C 
  613. // 
  614. // Security:        Protected 
  615. // 
  616. // Description:     Reverse a key set 
  617. // 
  618. // Parameters 
  619. //    In:           NONE 
  620. // 
  621. // Return Codes:    SHORT = C_OK always returned 
  622. // 
  623. // Written by:      John Tal 
  624. // 
  625. // 
  626. // Modification History: 
  627. // 
  628. //  Date         Engineer     Mod #          Modification Description 
  629. // 
  630. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  631. // 
  632. //- 
  633. //////////////////////////////////////////////////////////////////////// 
  634.   
  635. SHORT  CPT_C::ReverseKeys(VOID) 
  636. { 
  637.     C_DEF_MODULE("CPT_C::ReverseKeys") 
  638.  
  639.     INT i,scan,iC; 
  640.  
  641.     for(iC = 0; iC < iConvolutions; iC++) 
  642.     for(i = 0; i < ASCIIBYTES+1; i++) 
  643.        for(scan = 0; scan < ASCIIBYTES+1; scan++) 
  644.           if(cBytes[CPT_ENCODE][iC][scan] == i) 
  645.           { 
  646.              cBytes[CPT_DECODE][iC][i] = scan; 
  647. #ifdef DEBUG 
  648.              printf("%d (%c) used at %d (%c)\n",scan,scan,i,i); 
  649. #endif 
  650.           } 
  651.  
  652.     C_RETURN 
  653. } 
  654.   
  655. //////////////////////////////////////////////////////////////////////// 
  656. //+ 
  657. // Function Name:   CodeFile 
  658. // 
  659. // Class:           CPT_C 
  660. // 
  661. // Security:        Public 
  662. // 
  663. // Description:     Apply keys in conversion from input file to output file. 
  664. //                  Is called for both encoding and decoding. 
  665. // 
  666. // Parameters 
  667. //    In:           NONE 
  668. // 
  669. // Return Codes:    SHORT = C_OK = success 
  670. //                         !C_OK = failure 
  671. // 
  672. // Written by:      John Tal 
  673. // 
  674. // 
  675. // Modification History: 
  676. // 
  677. //  Date         Engineer     Mod #          Modification Description 
  678. // 
  679. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  680. // 
  681. //- 
  682. //////////////////////////////////////////////////////////////////////// 
  683.  
  684. SHORT  CPT_C::CodeFile(VOID) 
  685. { 
  686.     C_DEF_MODULE("CPT_C::CodeFile") 
  687.  
  688.     INT i,iC,iBytesRead; 
  689.     UCHAR szBuffer[BUFSIZE + 1]; 
  690.  
  691.     /* 
  692.     **  Reset convolution ptr 
  693.     */ 
  694.  
  695.     iC = 0; 
  696.  
  697.     do 
  698.     { 
  699.        iBytesRead = fread(szBuffer,1,BUFSIZE,InFile); 
  700.        if(iBytesRead > 0) 
  701.        { 
  702.           CodeBuffer(szBuffer,szBuffer,iBytesRead); 
  703.           fwrite(szBuffer,1,iBytesRead,OutFile); 
  704.        } 
  705.  
  706.     } while(iBytesRead != 0); 
  707.  
  708. C_MODULE_EXIT: 
  709.  
  710.     C_RETURN 
  711. } 
  712.   
  713. //////////////////////////////////////////////////////////////////////// 
  714. //+ 
  715. // Function Name:   CodeBuffer 
  716. // 
  717. // Class:           CPT_C 
  718. // 
  719. // Security:        Protected 
  720. // 
  721. // Description:     Apply key translation/coding on a buffer 
  722. // 
  723. // Parameters 
  724. //    In:           NONE 
  725. // 
  726. // Return Codes:    SHORT = C_OK = success 
  727. //                         !C_OK = failure 
  728. // 
  729. // Written by:      John Tal 
  730. // 
  731. // 
  732. // Modification History: 
  733. // 
  734. //  Date         Engineer     Mod #          Modification Description 
  735. // 
  736. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  737. // 
  738. //- 
  739. //////////////////////////////////////////////////////////////////////// 
  740.  
  741. SHORT  CPT_C::CodeBuffer(CHAR * pcBufIn,CHAR * pcBufOut,INT iBufLen) 
  742. { 
  743.    INT iPos; 
  744.  
  745.    for(iPos = 0; iPos < iBufLen; iPos++) 
  746.    { 
  747. #ifdef DEBUG 
  748.       printf("using %d %c  for %d (%c)\n", cBytes[iJob][iC][pcBufIn[iPos]],pCptWA -> 
  749. #endif 
  750.       pcBufOut[iPos] = cBytes[iJob][iC][pcBufIn[iPos]]; 
  751.       if(->iConvolutions > 1) 
  752.          AdjustConvolution(); 
  753.    } 
  754. } 
  755.  
  756.   
  757. //////////////////////////////////////////////////////////////////////// 
  758. //+ 
  759. // Function Name:   Adjust Convolution 
  760. // 
  761. // Class:           CPT_C 
  762. // 
  763. // Security:        Protected 
  764. // 
  765. // Description:     Adjust convolutoin prt as part of buffer coding process 
  766. // 
  767. // Parameters 
  768. //    In:           NONE 
  769. // 
  770. // Return Codes:    SHORT = C_OK = success 
  771. //                         !C_OK = failure 
  772. // 
  773. // Written by:      John Tal 
  774. // 
  775. // 
  776. // Modification History: 
  777. // 
  778. //  Date         Engineer     Mod #          Modification Description 
  779. // 
  780. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  781. // 
  782. //- 
  783. //////////////////////////////////////////////////////////////////////// 
  784.   
  785. SHORT  AdjustConvolution(CPT_WORK_AREA_P ) 
  786. { 
  787.    C_DEF_MODULE("CPT_C::AdjustConvolution") 
  788.  
  789.    iC++; 
  790.    if(iC >= iConvolutions) 
  791.       iC = 0; 
  792.  
  793.    C_RETURN 
  794. } 
  795.  
  796.   
  797. //////////////////////////////////////////////////////////////////////// 
  798. //+ 
  799. // Function Name:   UsrCode 
  800. // 
  801. // Class:           (Standalone) 
  802. // 
  803. // Security:        N/A 
  804. // 
  805. // Description:     Get Code/decode info from user 
  806. // 
  807. // Parameters 
  808. //    In:           NONE 
  809. // 
  810. // Return Codes:    SHORT = C_OK = success 
  811. //                         !C_OK = failure 
  812. // 
  813. // Written by:      John Tal 
  814. // 
  815. // 
  816. // Modification History: 
  817. // 
  818. //  Date         Engineer     Mod #          Modification Description 
  819. // 
  820. //  12-Feb-1992  Tal          v 1.0-001      Initial conversion to C++ 
  821. // 
  822. //- 
  823. //////////////////////////////////////////////////////////////////////// 
  824.   
  825. SHORT  CptUsrCode(VOID) 
  826. { 
  827.     C_DEF_MODULE("CptUsrCode") 
  828.  
  829.     INT  keynum; 
  830.     CHAR key_str[16]; 
  831.     CHAR job_code[4]; 
  832.  
  833.     if(iJob == CPT_ENCODE) 
  834.        strcpy(job_code,""); 
  835.     else 
  836.        strcpy(job_code,"DE-"); 
  837.  
  838.     printf("\n\n\nYOU must keep trak of which key you used on which file.\n"); 
  839.     printf("\n\nKey Number To Use "); 
  840.     scanf("%d",&keynum); 
  841.     fflush(stdin); 
  842.  
  843.     sprintf(key_str,"%d",keynum); 
  844.     lpad(key_str,4); 
  845.     srep(key_str,' ','0'); 
  846.     strcpy(szKeyFile,"key_"); 
  847.     strcat(szKeyFile,key_str); 
  848.     strcat(szKeyFile,".cpt"); 
  849.  
  850.     printf("\nFile To %sCode ",job_code); 
  851.     gets(szInFile); 
  852.  
  853.     printf("\n\nName For %sCoded Result File ",job_code); 
  854.     gets(szOutFile); 
  855.  
  856.     C_STATUS = CptReadInKeys(); 
  857.  
  858.     if(C_STATUS) 
  859.        C_LEAVE(C_STATUS) 
  860.  
  861.     C_STATUS = CptCodeFile(); 
  862.  
  863. C_MODULE_EXIT: 
  864.  
  865.     C_RETURN 
  866.  
  867. } 
  868.  
  869.  
  870.   
  871. #ifdef TEST 
  872. /****************************************************************************** 
  873. *+ 
  874. **  Cpt Test Function 
  875. ** 
  876. *- 
  877. */ 
  878.  
  879.  
  880. main() 
  881. { 
  882.   INT  pick; 
  883.   CHAR fDone = C_FALSE; 
  884.   CPT_WORK_AREA_T  stCptWA; 
  885.   CPT_WORK_AREA_P  ; 
  886.  
  887.  
  888.   memset(&stCptWA,0,sizeof(CPT_WORK_AREA_T)); 
  889.    = &stCptWA; 
  890.  
  891.   do 
  892.   { 
  893.     pick = 0; 
  894.     printf("\n\n\nWhich Of These Do You Want To Do\n"); 
  895.     printf("  1  Generate Keys\n"); 
  896.     printf("  2  Code File\n"); 
  897.     printf("  3  De-Code File\n\n"); 
  898.     printf("  0  None Of These"); 
  899.      
  900.     scanf("%d",&pick); 
  901.  
  902.     switch(pick){ 
  903.        case 0 : fDone = C_TRUE; 
  904.                 break; 
  905.        case 1 : CptGetKeyData();  
  906.                 CptGenKeys(); 
  907.                 break; 
  908.        case 2 : CptSetJob(,CPT_ENCODE); 
  909.                 CptUsrCode(); 
  910.                 break; 
  911.        case 3 : CptSetJob(,CPT_DECODE); 
  912.                 CptUsrCode(); 
  913.                 break; 
  914.        default: ; 
  915.      } 
  916.   } while (!fDone); 
  917.     
  918. } 
  919.  
  920.  
  921. #endif 
  922.  
  923.