home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / Programming / Source / WAIS / ir / transprt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  11.4 KB  |  459 lines
  1.  
  2. /* this is a krufty transport layer for comm mediums that can not handle
  3.  * all 8 bits of ascii.
  4.  * Written by Harry Morris, modified by brewster.
  5.  * Hexcode written by Steve Swartz
  6.  * 
  7.  */
  8.  
  9. /* to do
  10.  *
  11.  *  compression
  12.  *  encryption
  13.  */
  14.  
  15. /* change log:
  16.  * 7/7/90 -brewster
  17.  * merged arts and harry's changes 7/7/90 -brewster
  18.  *
  19.  * 11/6/90 -tracy
  20.  * shift 6 bytes starting from [ as IBM gateway program
  21.  * masks out characters [\]^` in input,
  22.  * append H and I to the function names corresponding to the
  23.  * oroginal coding and the modified one. 'I' indicates IBM. 
  24.  */
  25.  
  26. #include "transprt.h"
  27. #include "wmessage.h" 
  28. #include "ustubs.h"
  29.  
  30. /*---------------------------------------------------------------------*/
  31. static char alphaH[] = /* Must be 65 consecutive ascii characters */
  32.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnop";
  33.  
  34.  
  35. /*---------------------------------------------------------------------*/
  36.  
  37. static void hexCodeH _AP((char* data,long* len));
  38.  
  39. static void
  40. hexCodeH(data,len)
  41. char* data;
  42. long* len;
  43. /* compose a message for sending over ascii terminal lines. Input is '*len'
  44.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  45.  *
  46.  * Encoding goes like this. Let capital letters represent bits:
  47.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  48.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  49.  *
  50.  * 1 byte at end: ABCDEFGH
  51.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  52.  *
  53.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  54.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  55.  */
  56. {
  57.   long i, j;
  58.   
  59.   switch (*len % 3)
  60.     {
  61.     case 2:
  62.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  63.       data[j]   = alphaH[64];
  64.       data[j-1] = alphaH[data[i-1] & 0x0f];
  65.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  66.       data[j-3] = alphaH[data[i-2] & 0x3F];
  67.       break;
  68.     case 1:
  69.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  70.       data[j]   = alphaH[64];
  71.       data[j-1] = alphaH[64];
  72.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2];
  73.       data[j-3] = alphaH[data[i-2] & 0x3F];
  74.       break;
  75.     default:
  76.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  77.       break;
  78.     }
  79.   
  80.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  81.     { 
  82.       data[j]   = alphaH[data[i] & 0x3F];
  83.       data[j-1] = alphaH[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  84.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  85.       data[j-3] = alphaH[data[i-2] & 0x3F];
  86.     }
  87. }
  88.  
  89. /*---------------------------------------------------------------------*/
  90.  
  91. static void hexDecodeH _AP((char* data,long* len));
  92.  
  93. static void
  94. hexDecodeH(data,len)
  95. char* data;
  96. long* len;
  97. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  98.  *  will always be divisble by 4. Output is the binary bytes that were 
  99.  *  encoded into 'data'.
  100.  *
  101.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  102.  *  from ascii data to the 'bX' values has to become more complicated than
  103.  *  data[] - alpha[0].
  104.  */
  105. {
  106.   unsigned char b0, b1, b2, b3;
  107.   long i, j;
  108.  
  109.   
  110.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  111.     {
  112.       b0 = (data[j-4] & 0x07F) - alphaH[0];
  113.       b1 = (data[j-3] & 0x07F) - alphaH[0];
  114.       b2 = (data[j-2] & 0x07F) - alphaH[0];
  115.       b3 = (data[j-1] & 0x07F) - alphaH[0];
  116.       data[i-3] = b0 | (b1 & 0x30) << 2;
  117.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  118.       data[i-1] = b3 | (b2 & 0x30) << 2;
  119.     }
  120.  
  121.   *len = *len/4 * 3 - 2;
  122.   b0 = (data[j-4] & 0x07F) - alphaH[0];
  123.   b1 = (data[j-3] & 0x07F) - alphaH[0];
  124.   b2 = (data[j-2] & 0x07F) - alphaH[0];
  125.   b3 = (data[j-1] & 0x07F) - alphaH[0];
  126.   data[i-3] = b0 | (b1 & 0x30) << 2;
  127.  
  128.   if (b2 != 64)    
  129.     {
  130.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  131.       (*len)++;
  132.     }
  133.  
  134.   if (b3 != 64)
  135.     {
  136.       data[i-1] = b3 | (b2 & 0x30) << 2;
  137.       (*len)++;
  138.     }
  139. }
  140.  
  141. /*---------------------------------------------------------------------*/
  142.  
  143. void
  144. transportCodeH(data,len)
  145. char* data;
  146. long* len;
  147. /* krufty serial line transport layer - encode in hex and append in cr */
  148. /* Now it also writes a wais packet header on to the front of the packet.
  149.  *   --art 
  150.  */
  151. { 
  152.   hexCodeH(data,len);
  153.   data[*len] = '\r';
  154.   data[*len + 1] = '\0';
  155.   *len += 1;
  156. }
  157.  
  158. /*---------------------------------------------------------------------*/
  159.  
  160. void
  161. transportDecodeH(data,len)
  162. char* data;
  163. long* len;
  164. /* decode above */
  165. /* This does not have to deal with the wais packet header since it has
  166.    been removed at the end of the read.  */
  167. { 
  168.   if (*len == 0)
  169.     return;
  170.     
  171.   *len -= 1;
  172.   hexDecodeH(data,len);
  173. }
  174.  
  175. /*---------------------------------------------------------------------
  176.  Below are the set of transport coding/decoding functions for clients
  177.  dialing through IBM to DowQuest. Unlike the above one that
  178.  uses 65 consecutive ASCII character for the coding/decoding table,
  179.  table entries after charcater 'Z' are shift 6 characters.
  180.  *--------------------------------------------------------------------*/ 
  181.  
  182. #define LAST_NON_SHIFT_CHAR 90
  183. #define SHIFT_OFFSET   6
  184.  
  185. static char alphaI[] = 
  186.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv";
  187.  
  188.  
  189. static void hexCodeI _AP((char* data,long* len));
  190.  
  191. static void
  192. hexCodeI(data,len)
  193. char* data;
  194. long* len;
  195. /* compose a message for sending over ascii terminal lines. Input is '*len'
  196.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  197.  *
  198.  * Encoding goes like this. Let capital letters represent bits:
  199.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  200.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  201.  *
  202.  * 1 byte at end: ABCDEFGH
  203.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  204.  *
  205.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  206.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  207.  */
  208. {
  209.   long i, j;
  210.   
  211.   switch (*len % 3)
  212.     {
  213.     case 2:
  214.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  215.       data[j]   = alphaI[64];
  216.       data[j-1] = alphaI[data[i-1] & 0x0f];
  217.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  218.       data[j-3] = alphaI[data[i-2] & 0x3F];
  219.       break;
  220.     case 1:
  221.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  222.       data[j]   = alphaI[64];
  223.       data[j-1] = alphaI[64];
  224.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2];
  225.       data[j-3] = alphaI[data[i-2] & 0x3F];
  226.       break;
  227.     default:
  228.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  229.       break;
  230.     }
  231.   
  232.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  233.     { 
  234.       data[j]   = alphaI[data[i] & 0x3F];
  235.       data[j-1] = alphaI[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  236.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  237.       data[j-3] = alphaI[data[i-2] & 0x3F];
  238.     }
  239. }
  240.  
  241. /*---------------------------------------------------------------------*/
  242.  
  243. static void hexDecodeI _AP((char* data,long * len));
  244.  
  245. static void
  246. hexDecodeI(data,len)
  247. char* data;
  248. long* len;
  249. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  250.  *  will always be divisble by 4. Output is the binary bytes that were 
  251.  *  encoded into 'data'.
  252.  *
  253.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  254.  *  from ascii data to the 'bX' values has to become more complicated than
  255.  *  data[] - alpha[0].
  256.  */
  257. {
  258.   unsigned char b0, b1, b2, b3;
  259.   long i, j;
  260.  
  261.   for ( i=0; i < *len ; i++ )
  262.     if ( data[i] > LAST_NON_SHIFT_CHAR ) data[i] -= SHIFT_OFFSET;
  263.   
  264.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  265.     {
  266.       b0 = (data[j-4] & 0x07F) - alphaI[0];
  267.       b1 = (data[j-3] & 0x07F) - alphaI[0];
  268.       b2 = (data[j-2] & 0x07F) - alphaI[0];
  269.       b3 = (data[j-1] & 0x07F) - alphaI[0];
  270.       data[i-3] = b0 | (b1 & 0x30) << 2;
  271.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  272.       data[i-1] = b3 | (b2 & 0x30) << 2;
  273.     }
  274.  
  275.   *len = *len/4 * 3 - 2;
  276.   b0 = (data[j-4] & 0x07F) - alphaI[0];
  277.   b1 = (data[j-3] & 0x07F) - alphaI[0];
  278.   b2 = (data[j-2] & 0x07F) - alphaI[0];
  279.   b3 = (data[j-1] & 0x07F) - alphaI[0];
  280.   data[i-3] = b0 | (b1 & 0x30) << 2;
  281.  
  282.   if (b2 != 64)    
  283.     {
  284.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  285.       (*len)++;
  286.     }
  287.  
  288.   if (b3 != 64)
  289.     {
  290.       data[i-1] = b3 | (b2 & 0x30) << 2;
  291.       (*len)++;
  292.     }
  293. }
  294.  
  295. /*---------------------------------------------------------------------*/
  296.  
  297. void
  298. transportCodeI(data,len)
  299. char* data;
  300. long* len;
  301. /* krufty serial line transport layer - encode in hex and append in cr */
  302. /* Now it also writes a wais packet header on to the front of the packet.
  303.  *   --art 
  304.  */
  305. { 
  306.   hexCodeI(data,len);
  307.   data[*len] = '\r';
  308.   data[*len + 1] = '\0';
  309.   *len += 1;
  310. }
  311.  
  312. /*---------------------------------------------------------------------*/
  313.  
  314. void
  315. transportDecodeI(data,len)
  316. char* data;
  317. long* len;
  318. /* decode above */
  319. /* This does not have to deal with the wais packet header since it has
  320.    been removed at the end of the read.  */
  321. { 
  322.   if (*len == 0)
  323.     return;
  324.     
  325.   *len -= 1;
  326.   hexDecodeI(data,len);
  327. }
  328.  
  329. /*---------------------------------------------------------------------*/
  330.  
  331.  
  332. #ifdef NOTDEFINED /* here for back compatibility */
  333.  
  334. static void hexCode _AP((char* data,long * len));
  335.  
  336. static void
  337. hexCode(data,len)
  338. char* data;
  339. long* len;
  340. /* compose a message for sending over ascii terminal lines.  The data is hex,
  341.  */
  342. { long i;
  343.   for (i = *len-1; i >= 0; i--)
  344.     { data[i*2+1] = (data[i]&0x0F) + 'a';
  345.       data[i*2] = ((data[i]>>4)&0x0F) + 'a';
  346.     }
  347.   data[*len*2] = '\0';
  348.   *len = *len * 2;
  349. }
  350.  
  351. /*---------------------------------------------------------------------------*/
  352.  
  353. static void hexDecode _AP((char* data,long * len));
  354.  
  355. static void
  356. hexDecode(data,len)
  357. char* data;
  358. long* len;
  359. /* converts a buffer full of dataLen bytes of hex in place into the
  360. equivalent binary form. len is filled with the actual number of binary bytes.
  361.  */
  362. { long i;
  363.   *len = *len / 2;
  364.   for (i = 0; i < *len; i++)
  365.     { long temp = 0;
  366.       temp = (data[i*2]-'a')<<4;
  367.       temp += data[i*2+1]-'a';
  368.       data[i] = (char)temp;
  369.     }
  370.   data[*len] = '\0';
  371. }
  372.  
  373. #endif /* def NOTDEFINED */
  374. /*---------------------------------------------------------------------------*/
  375.  
  376. boolean
  377. transportCode(encoding,data,len)
  378. long encoding;
  379. char* data;
  380. long* len;
  381. /* krufty serial line transport layer - encode in hex and add trailing nl */
  382. {
  383.   switch (encoding){
  384.   case NO_ENCODING:
  385.     /* do nothing */
  386.     return(true);
  387.   case HEX_ENCODING:
  388.     transportCodeH(data,len);
  389.     return(true);
  390.   case IBM_HEXCODING:
  391.     transportCodeI(data,len);
  392.     return(true);
  393.   default:
  394.     return(false);
  395.   }
  396. }
  397.  
  398. /*---------------------------------------------------------------------------*/
  399.  
  400. boolean
  401. transportDecode(encoding,data,len)
  402. long encoding;
  403. char* data;
  404. long* len;
  405. /* decode above */
  406. {
  407.   switch (encoding){
  408.   case NO_ENCODING:
  409.     /* do nothing */
  410.     return(true);
  411.   case HEX_ENCODING:
  412.     transportDecodeH(data,len);
  413.     return(true);
  414.   case IBM_HEXCODING:
  415.     transportDecodeI(data,len);
  416.     return(true);
  417.   default:
  418.     return(false);
  419.   }
  420. }
  421.  
  422. /*---------------------------------------------------------------------------*/
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429. #ifdef old /* from the bad old days */
  430.  
  431.  
  432. /*---------------------------------------------------------------------------*/
  433.  
  434. void
  435. transportCode(data,len)
  436. char* data;
  437. long* len;
  438. /* krufty serial line transport layer - encode in hex and add trailing nl */
  439. {
  440.   hexCode(data,len);
  441.   data[*len] = '\r';
  442.   data[*len+1] = '\0';
  443. }
  444.  
  445. /*---------------------------------------------------------------------------*/
  446.  
  447. void
  448. transportDecode(data,len)
  449. char* data;
  450. long* len;
  451. /* decode above */
  452. {
  453.   hexDecode(data,len);
  454. }
  455.  
  456. /*---------------------------------------------------------------------------*/
  457.  
  458. #endif /* old */
  459.