开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
ssltap.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：38k
源码类别：

CA认证

开发平台：

WINDOWS

ssltap.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. /*
  35.  * ssltap.c
  36.  *
  37.  * Version 1.0 : Frederick Roeber : 11 June 1997
  38.  * Version 2.0 : Steve Parkinson  : 13 November 1997
  39.  * Version 3.0 : Nelson Bolyard   : 22 July 1998
  40.  * Version 3.1 : Nelson Bolyard   : 24 May  1999
  41.  *
  42.  * changes in version 2.0:
  43.  *  Uses NSPR20
  44.  *  Shows structure of SSL negotiation, if enabled.
  45.  *
  46.  * This "proxies" a socket connection (like a socks tunnel), but displays the
  47.  * data is it flies by.
  48.  *
  49.  * In the code, the 'client' socket is the one on the client side of the
  50.  * proxy, and the server socket is on the server side.
  51.  *
  52.  */
  54. #include "nspr.h"
  55. #include "plstr.h"
  56. #include "secutil.h"
  57. #include <memory.h> /* for memcpy, etc. */
  58. #include <string.h>
  59. #include <time.h>
  61. #include "plgetopt.h"
  63. #define VERSIONSTRING "$Revision: 1.1 $ ($Date: 2000/03/31 20:12:54 $) $Author: relyea%netscape.com $"
  66. struct _DataBufferList;
  67. struct _DataBuffer;
  69. typedef struct _DataBufferList {
  70.   struct _DataBuffer *first,*last;
  71.   int size;
  72.   int isEncrypted;
  73. } DataBufferList;
  75. typedef struct _DataBuffer {
  76.   unsigned char *buffer;
  77.   int length;
  78.   int offset;  /* offset of first good byte */
  79.   struct _DataBuffer *next;
  80. } DataBuffer;
  83. DataBufferList
  84.   clientstream = {NULL, NULL, 0, 0},
  85.   serverstream = {NULL, NULL, 0, 0};
  87. struct sslhandshake {
  88.   PRUint8 type;
  89.   PRUint32 length;
  90. };
  92. typedef struct _SSLRecord {
  93.   PRUint8 type;
  94.   PRUint8 ver_maj,ver_min;
  96.   PRUint8 length[2];
  97. } SSLRecord;
  99. typedef struct _ClientHelloV2 {
  100.   PRUint8 length[2];
  101.   PRUint8 type;
  102.   PRUint8 version[2];
  103.   PRUint8 cslength[2];
  104.   PRUint8 sidlength[2];
  105.   PRUint8 rndlength[2];
  106.   PRUint8 csuites[1];
  107. } ClientHelloV2;
  109. typedef struct _ServerHelloV2 {
  110.   PRUint8 length[2];
  111.   PRUint8 type;
  112.   PRUint8 sidhit;
  113.   PRUint8 certtype;
  114.   PRUint8 version[2];
  115.   PRUint8 certlength[2];
  116.   PRUint8 cslength[2];
  117.   PRUint8 cidlength[2];
  118. } ServerHelloV2;
  120. typedef struct _ClientMasterKeyV2 {
  121.   PRUint8 length[2];
  122.   PRUint8 type;
  124.   PRUint8 cipherkind[3];
  125.   PRUint8 clearkey[2];
  126.   PRUint8 secretkey[2];
  128. } ClientMasterKeyV2;
  132. #define TAPBUFSIZ 16384
  134. #define DEFPORT 1924
  135. #include <ctype.h>
  137. int hexparse=0;
  138. int sslparse=0;
  139. int sslhexparse=0;
  140. int looparound=0;
  141. int fancy=0;
  142. int isV2Session=0;
  144. #define GET_SHORT(x) ((PRUint16)(((PRUint16)((PRUint8*)x)[0]) << 8) + ((PRUint16)((PRUint8*)x)[1]))
  145. #define GET_24(x) ((PRUint32)   (  
  146.  (((PRUint32)((PRUint8*)x)[0]) << 16) 
  147.  +                          
  148.  (((PRUint32)((PRUint8*)x)[1]) << 8)  
  149.  +                          
  150.  (((PRUint32)((PRUint8*)x)[2]) << 0)  
  151.  ) )
  153. void print_hex(int amt, unsigned char *buf);
  154. void read_stream_bytes(unsigned char *d, DataBufferList *db, int length);
  156. void myhalt(int dblsize,int collectedsize) {
  158.   while(1) ;
  160. }
  162. const char *get_error_text(int error) {
  163.   switch (error) {
  164.   case PR_IO_TIMEOUT_ERROR:
  165.     return "Timeout";
  166.     break;
  167.   case PR_CONNECT_REFUSED_ERROR:
  168.     return "Connection refused";
  169.     break;
  170.   case PR_NETWORK_UNREACHABLE_ERROR:
  171.     return "Network unreachable";
  172.     break;
  173.   case PR_BAD_ADDRESS_ERROR:
  174.     return "Bad address";
  175.     break;
  176.   case PR_CONNECT_RESET_ERROR:
  177.     return "Connection reset";
  178.     break;
  179.   case PR_PIPE_ERROR:
  180.     return "Pipe error";
  181.     break;
  182.   }
  184.   return "";
  185. }
  191. void check_integrity(DataBufferList *dbl) {
  192.   DataBuffer *db;
  193.   int i;
  195.   db = dbl->first;
  196.   i =0;
  197.   while (db) {
  198.     i+= db->length - db->offset;
  199.     db = db->next;
  200.   }
  201.   if (i != dbl->size) {
  202.     myhalt(dbl->size,i);
  203.   }
  204. }
  206. /* Free's the DataBuffer at the head of the list and returns the pointer
  207.  * to the new head of the list.
  208.  */
  209. DataBuffer * 
  210. free_head(DataBufferList *dbl)
  211. {
  212.   DataBuffer *db       = dbl->first;
  213.   PR_ASSERT(db->offset >= db->length);
  214.   if (db->offset >= db->length) {
  215.     dbl->first = db->next;
  216.     if (dbl->first == NULL) {
  217.       dbl->last = NULL;
  218.     }
  219.     PR_Free(db->buffer);
  220.     PR_Free(db);
  221.     db = dbl->first;
  222.   }
  223.   return db;
  224. }
  226. void 
  227. read_stream_bytes(unsigned char *d, DataBufferList *dbl, int length) {
  228.   int         copied  = 0;
  229.   DataBuffer *db = dbl->first;
  231.   if (!db) {
  232.     PR_fprintf(PR_STDERR,"assert failed - dbl->first is nulln");
  233.     exit(8);
  234.   }
  235.   while (length) {
  236.     int         toCopy;
  237.     /* find the number of bytes to copy from the head buffer */
  238.     /* if there's too many in this buffer, then only copy 'length' */
  239.     toCopy = PR_MIN(db->length - db->offset, length);
  241.     memcpy(d + copied, db->buffer + db->offset, toCopy);
  242.     copied     += toCopy;
  243.     db->offset += toCopy;
  244.     length     -= toCopy;
  245.     dbl->size  -= toCopy;
  247.     /* if we emptied the head buffer */
  248.     if (db->offset >= db->length) {
  249.       db = free_head(dbl);
  250.     }
  251.   }
  253.   check_integrity(dbl);
  255. }
  257. void
  258. flush_stream(DataBufferList *dbl)
  259. {
  260.     DataBuffer *db = dbl->first;
  261.     check_integrity(dbl);
  262.     while (db) {
  263. db->offset = db->length;
  264.      db = free_head(dbl);
  265.     }
  266.     dbl->size = 0;
  267.     check_integrity(dbl);
  268. }
  271. const char * V2CipherString(int cs_int) {
  272.   char *cs_str;
  273.   cs_str = NULL;
  274.   switch (cs_int) {
  276.   case 0x010080:    cs_str = "SSL2/RSA/RC4-128/MD5";       break;
  277.   case 0x020080:    cs_str = "SSL2/RSA/RC4-40/MD5";    break;
  278.   case 0x030080:    cs_str = "SSL2/RSA/RC2CBC128/MD5";     break;
  279.   case 0x040080:    cs_str = "SSL2/RSA/RC2CBC40/MD5";  break;
  280.   case 0x050080:    cs_str = "SSL2/RSA/IDEA128CBC/MD5";    break;
  281.   case 0x060040:    cs_str = "SSL2/RSA/DES56-CBC/MD5";      break;
  282.   case 0x0700C0:    cs_str = "SSL2/RSA/3DES192EDE-CBC/MD5"; break;
  284.   case 0x000001:    cs_str = "SSL3/RSA/NULL/MD5";             break;
  285.   case 0x000002:    cs_str = "SSL3/RSA/NULL/SHA";             break;
  286.   case 0x000003:    cs_str = "SSL3/RSA/RC4-40/MD5";       break;
  287.   case 0x000004:    cs_str = "SSL3/RSA/RC4-128/MD5";          break;
  288.   case 0x000005:    cs_str = "SSL3/RSA/RC4-128/SHA";          break;
  289.   case 0x000006:    cs_str = "SSL3/RSA/RC2CBC40/MD5";     break;
  290.   case 0x000007:    cs_str = "SSL3/RSA/IDEA128CBC/SHA";       break;
  291.   case 0x000008:    cs_str = "SSL3/RSA/DES40-CBC/SHA";         break;
  292.   case 0x000009:    cs_str = "SSL3/RSA/DES56-CBC/SHA";         break;
  293.   case 0x00000A:    cs_str = "SSL3/RSA/3DES192EDE-CBC/SHA";    break;
  295.   case 0x00000B:    cs_str = "SSL3/DH-DSS/DES40-CBC/SHA";      break;
  296.   case 0x00000C:    cs_str = "SSL3/DH_DSS/DES56-CBC/SHA";      break;
  297.   case 0x00000D:    cs_str = "SSL3/DH-DSS/DES192EDE3CBC/SHA"; break;
  298.   case 0x00000E:    cs_str = "SSL3/DH-RSA/DES40-CBC/SHA";      break;
  299.   case 0x00000F:    cs_str = "SSL3/DH_RSA/DES56-CBC/SHA";      break;
  300.   case 0x000010:    cs_str = "SSL3/DH-RSA/3DES192EDE-CBC/SHA"; break;
  302.   case 0x000011:    cs_str = "SSL3/DHE-DSS/DES40-CBC/SHA";      break;
  303.   case 0x000012:    cs_str = "SSL3/DHE_DSS/DES56-CBC/SHA";      break;
  304.   case 0x000013:    cs_str = "SSL3/DHE-DSS/DES192EDE3CBC/SHA"; break;
  305.   case 0x000014:    cs_str = "SSL3/DHE-RSA/DES40-CBC/SHA";      break;
  306.   case 0x000015:    cs_str = "SSL3/DHE_RSA/DES56-CBC/SHA";      break;
  307.   case 0x000016:    cs_str = "SSL3/DHE-RSA/3DES192EDE-CBC/SHA"; break;
  309.   case 0x000017:    cs_str = "SSL3/DH-anon/RC4-40/MD5";     break;
  310.   case 0x000018:    cs_str = "SSL3/DH-anon/RC4-128/MD5";        break;
  311.   case 0x000019:    cs_str = "SSL3/DH-anon/DES40-CBC/SHA";       break;
  312.   case 0x00001A:    cs_str = "SSL3/DH-anon/DES56-CBC/SHA";       break;
  313.   case 0x00001B:    cs_str = "SSL3/DH-anon/3DES192EDE-CBC/SHA"; break;
  315.   case 0x00001C:    cs_str = "SSL3/FORTEZZA-DMS/NULL/SHA";      break;
  316.   case 0x00001D:    cs_str = "SSL3/FORTEZZA-DMS/FORTEZZA-CBC/SHA";  break;
  317.   case 0x00001E:    cs_str = "SSL3/FORTEZZA-DMS/RC4-128/SHA";  break;
  319.   case 0x000062:    cs_str = "TLS/RSA_EXPORT1024/DES56_CBC/SHA";   break;
  320.   case 0x000064:    cs_str = "TLS/RSA_EXPORT1024/RC4-56/SHA";    break;
  321.   case 0x000063:    cs_str = "TLS/DHE-DSS_EXPORT1024/DES56-CBC/SHA"; break;
  322.   case 0x000065:    cs_str = "TLS/DHE-DSS_EXPORT1024/RC4-56/SHA";  break;
  323.   case 0x000066:    cs_str = "TLS/DHE-DSS/RC4-128/SHA";    break;
  325.   case 0x00ffe1:    cs_str = "SSL3/RSA-FIPS/DES56-CBC/SHA";         break;
  326.   case 0x00ffe0:    cs_str = "SSL3/RSA-FIPS/3DES192EDE-CBC/SHA";    break;
  328.   default:          cs_str = "????/????????/?????????/???";     break;
  329.   }
  331.   return cs_str;
  332. }
  334. void partial_packet(int thispacket, int size, int needed)
  335. {
  336.   PR_fprintf(PR_STDOUT,"(%u bytes", thispacket);
  337.   if (thispacket < needed) {
  338.     PR_fprintf(PR_STDOUT,", making %u", size);
  339.   }
  340.   PR_fprintf(PR_STDOUT," of %u", needed);
  341.   if (size > needed) {
  342.     PR_fprintf(PR_STDOUT,", with %u left over", size - needed);
  343.   }
  344.   PR_fprintf(PR_STDOUT,")n");
  345. }
  347. char * get_time_string(void)
  348. {
  349.   struct tm *tm;
  350.   char      *cp;
  351.   char      *eol;
  352.   time_t     tt;
  354.   time(&tt);
  355. #if 0
  356.   tm = localtime(&tt);
  357.   cp = asctime(tm);
  358. #else
  359.   cp = ctime(&tt);
  360. #endif
  361.   eol = strchr(cp, 'n');
  362.   if (eol) 
  363.     *eol = 0;
  364.   return cp;
  365. }
  367. void print_sslv2(DataBufferList *s, unsigned char *tbuf, unsigned int alloclen)
  368. {
  369.   ClientHelloV2 *chv2;
  370.   ServerHelloV2 *shv2;
  371.   unsigned char *pos;
  372.   unsigned int   p;
  373.   unsigned int   q;
  374.   PRUint32       len;
  376.   chv2 = (ClientHelloV2 *)tbuf;
  377.   shv2 = (ServerHelloV2 *)tbuf;
  378.   if (s->isEncrypted) {
  379.     PR_fprintf(PR_STDOUT," [ssl2]  Encrypted {...}n");
  380.     return;
  381.   }
  382.   PR_fprintf(PR_STDOUT," [%s]", get_time_string() );
  383.   switch(chv2->type) {
  384.   case 1:
  385.     PR_fprintf(PR_STDOUT," [ssl2]  ClientHelloV2 {n");
  386.     PR_fprintf(PR_STDOUT,"           version = {0x%02x, 0x%02x}n",
  387.        (PRUint32)chv2->version[0],(PRUint32)chv2->version[1]);
  388.     PR_fprintf(PR_STDOUT,"           cipher-specs-length = %d (0x%02x)n",
  389.        (PRUint32)(GET_SHORT((chv2->cslength))),
  390.        (PRUint32)(GET_SHORT((chv2->cslength))));
  391.     PR_fprintf(PR_STDOUT,"           sid-length = %d (0x%02x)n",
  392.        (PRUint32)(GET_SHORT((chv2->sidlength))),
  393.        (PRUint32)(GET_SHORT((chv2->sidlength))));
  394.     PR_fprintf(PR_STDOUT,"           challenge-length = %d (0x%02x)n",
  395.        (PRUint32)(GET_SHORT((chv2->rndlength))),
  396.        (PRUint32)(GET_SHORT((chv2->rndlength))));
  397.     PR_fprintf(PR_STDOUT,"           cipher-suites = { n");
  398.     for (p=0;p<GET_SHORT((chv2->cslength));p+=3) {
  399.       const char *cs_str=NULL;
  400.       PRUint32 cs_int=0;
  401.       cs_int = GET_24((&chv2->csuites[p]));
  402.       cs_str = V2CipherString(cs_int);
  404.       PR_fprintf(PR_STDOUT,"                (0x%06x) %sn",
  405.   cs_int, cs_str);
  406.     }
  407.     q = p;
  408.     PR_fprintf(PR_STDOUT,"                }n");
  409.     if (chv2->sidlength) {
  410.       PR_fprintf(PR_STDOUT,"           session-id = { ");
  411.       for (p=0;p<GET_SHORT((chv2->sidlength));p+=2) {
  412. PR_fprintf(PR_STDOUT,"0x%04x ",(PRUint32)(GET_SHORT((&chv2->csuites[p+q]))));
  413.       }
  414.     }
  415.     q += p;
  416.     PR_fprintf(PR_STDOUT,"}n");
  417.     if (chv2->rndlength) {
  418.       PR_fprintf(PR_STDOUT,"           challenge = { ");
  419.       for (p=0;p<GET_SHORT((chv2->rndlength));p+=2) {
  420. PR_fprintf(PR_STDOUT,"0x%04x ",(PRUint32)(GET_SHORT((&chv2->csuites[p+q]))));
  421.       }
  422.       PR_fprintf(PR_STDOUT,"}n");
  423.     }
  424.     PR_fprintf(PR_STDOUT,"}n");
  425.     break;
  426.     /* end of V2 CLientHello Parsing */
  428.   case 2:  /* Client Master Key  */
  429.     {
  430.     const char *cs_str=NULL;
  431.     PRUint32 cs_int=0;
  432.     ClientMasterKeyV2 *cmkv2;
  433.     cmkv2 = (ClientMasterKeyV2 *)chv2;
  434.     isV2Session = 1;
  436.     PR_fprintf(PR_STDOUT," [ssl2]  ClientMasterKeyV2 { n");
  438.     cs_int = GET_24(&cmkv2->cipherkind[0]);
  439.     cs_str = V2CipherString(cs_int);
  440.     PR_fprintf(PR_STDOUT,"         cipher-spec-chosen = (0x%06x) %sn",
  441.        cs_int, cs_str);
  443.     PR_fprintf(PR_STDOUT,"         clear-portion = %d bitsn",
  444.        8*(PRUint32)(GET_SHORT((cmkv2->clearkey))));
  446.     PR_fprintf(PR_STDOUT,"      }n");
  447.     clientstream.isEncrypted = 1;
  448.     serverstream.isEncrypted = 1;
  449.     }
  450.     break;
  453.   case 3:
  454.     PR_fprintf(PR_STDOUT," [ssl2]  Client Finished V2 {...}n");
  455.     isV2Session = 1;
  456.     break;
  459.   case 4:  /* V2 Server Hello */
  460.     isV2Session = 1;
  462.     PR_fprintf(PR_STDOUT," [ssl2]  ServerHelloV2 {n");
  463.     PR_fprintf(PR_STDOUT,"           sid hit = {0x%02x}n",
  464.        (PRUintn)shv2->sidhit);
  465.     PR_fprintf(PR_STDOUT,"           version = {0x%02x, 0x%02x}n",
  466.        (PRUint32)shv2->version[0],(PRUint32)shv2->version[1]);
  467.     PR_fprintf(PR_STDOUT,"           cipher-specs-length = %d (0x%02x)n",
  468.        (PRUint32)(GET_SHORT((shv2->cslength))),
  469.        (PRUint32)(GET_SHORT((shv2->cslength))));
  470.     PR_fprintf(PR_STDOUT,"           sid-length = %d (0x%02x)n",
  471.        (PRUint32)(GET_SHORT((shv2->cidlength))),
  472.        (PRUint32)(GET_SHORT((shv2->cidlength))));
  474.     pos = (unsigned char *)shv2;
  475.     pos += 2;   /* skip length header */
  476.     pos += 11;  /* position pointer to Certificate data area */
  477.     q = GET_SHORT(&shv2->certlength);
  478.     if (q >alloclen) {
  479.       goto eosh;
  480.     }
  481.     pos += q;  /* skip certificate */
  483.     PR_fprintf(PR_STDOUT,"           cipher-suites = { ");
  484.     len = GET_SHORT((shv2->cslength));
  485.     for (p = 0; p < len; p += 3) {
  486.       const char *cs_str=NULL;
  487.       PRUint32 cs_int=0;
  488.       cs_int = GET_24((pos+p));
  489.       cs_str = V2CipherString(cs_int);
  490.       PR_fprintf(PR_STDOUT,"n              ");
  491.       PR_fprintf(PR_STDOUT,"(0x%06x) %s", cs_int, cs_str);
  492.     }
  493.     pos += len;
  494.     PR_fprintf(PR_STDOUT,"   }n"); /* End of cipher suites */
  495.     len = (PRUint32)GET_SHORT((shv2->cidlength));
  496.     if (len) {
  497.       PR_fprintf(PR_STDOUT,"           connection-id = { ");
  498.       for (p = 0; p < len; p += 2) {
  499. PR_fprintf(PR_STDOUT,"0x%04x ", (PRUint32)(GET_SHORT((pos + p))));
  500.       }
  501.       PR_fprintf(PR_STDOUT,"   }n"); /* End of connection id */
  502.     }
  503. eosh:
  504.     PR_fprintf(PR_STDOUT,"n              }n"); /* end of ServerHelloV2 */
  505.     if (shv2->sidhit) {
  506.       clientstream.isEncrypted = 1;
  507.       serverstream.isEncrypted = 1;
  508.     }
  509.     break;
  511.   case 5:
  512.     PR_fprintf(PR_STDOUT," [ssl2]  Server Verify V2 {...}n");
  513.     isV2Session = 1;
  514.     break;
  516.   case 6:
  517.     PR_fprintf(PR_STDOUT," [ssl2]  Server Finished V2 {...}n");
  518.     isV2Session = 1;
  519.     break;
  521.   case 7:
  522.     PR_fprintf(PR_STDOUT," [ssl2]  Request Certificate V2 {...}n");
  523.     isV2Session = 1;
  524.     break;
  526.   case 8:
  527.     PR_fprintf(PR_STDOUT," [ssl2]  Client Certificate V2 {...}n");
  528.     isV2Session = 1;
  529.     break;
  531.   default:
  532.     PR_fprintf(PR_STDOUT," [ssl2]  UnknownType 0x%02x {...}n",
  533.   (PRUint32)chv2->type);
  534.     break;
  535.   }
  536. }
  543. void print_ssl3_handshake(unsigned char *tbuf, 
  544.                           unsigned int   alloclen,
  545.                           SSLRecord *    sr)
  546. {
  547.   struct sslhandshake sslh; 
  548.   unsigned char *     hsdata;  
  549.   int                 offset=0;
  551.   PR_fprintf(PR_STDOUT,"   handshake {n");
  553.   while (offset < alloclen) {
  554.     sslh.type = tbuf[offset]; 
  555.     sslh.length = GET_24(tbuf+offset+1);
  556.     hsdata= &tbuf[offset+4];
  558.     if (sslhexparse) print_hex(4,tbuf+offset);
  560.     PR_fprintf(PR_STDOUT,"      type = %d (",sslh.type);
  561.     switch(sslh.type) {
  562.     case 0:  PR_fprintf(PR_STDOUT,"hello_request)n");   break;
  563.     case 1:  PR_fprintf(PR_STDOUT,"client_hello)n");    break;
  564.     case 2:  PR_fprintf(PR_STDOUT,"server_hello)n");    break;
  565.     case 11: PR_fprintf(PR_STDOUT,"certificate)n");     break;
  566.     case 12: PR_fprintf(PR_STDOUT,"server_key_exchange)n");  break;
  567.     case 13: PR_fprintf(PR_STDOUT,"certificate_request)n");  break;
  568.     case 14: PR_fprintf(PR_STDOUT,"server_hello_done)n");    break;
  569.     case 15: PR_fprintf(PR_STDOUT,"certificate_verify)n");   break;
  570.     case 16: PR_fprintf(PR_STDOUT,"client_key_exchange)n");  break;
  571.     case 20: PR_fprintf(PR_STDOUT,"finished)n");         break;
  572.     default: PR_fprintf(PR_STDOUT,"unknown)n");
  573.     }
  575.     PR_fprintf(PR_STDOUT,"      length = %d (0x%06x)n",sslh.length,sslh.length);
  576.     switch (sslh.type) {
  578.     case 1: /* client hello */
  579.       switch (sr->ver_maj)  {
  580.       case 2:  /* ssl version 2 */
  581. PR_fprintf(PR_STDOUT,"         ClientHelloV2 {...}n");
  582. break;
  583.       case 3:  /* ssl version 3 */
  584. {
  585.   int sidlength,pos,csuitelength,w;
  586.   PR_fprintf(PR_STDOUT,"         ClientHelloV3 {n");
  587.   PR_fprintf(PR_STDOUT,"            client_version = {%d, %d}n",
  588.      (PRUint8)hsdata[0],(PRUint8)hsdata[1]);
  589.   PR_fprintf(PR_STDOUT,"            random = {...}n");
  590.   if (sslhexparse) print_hex(32,&hsdata[2]);
  591.   PR_fprintf(PR_STDOUT,"            session ID = {n");
  592.   sidlength = (int)hsdata[2+32];
  593.   PR_fprintf(PR_STDOUT,"                length = %dn",sidlength);
  594.   PR_fprintf(PR_STDOUT,"                contents = {..}n");
  595.   if (sslhexparse) print_hex(sidlength,&hsdata[2+32+1]);
  596.   PR_fprintf(PR_STDOUT,"            }n");
  597.   pos = 2+32+1+sidlength;
  598.   csuitelength = GET_SHORT((hsdata+pos));
  599.   PR_fprintf(PR_STDOUT,"            cipher_suites[%d] = { n",
  600.      csuitelength/2);
  601.   if (csuitelength%1) {
  602.     PR_fprintf(PR_STDOUT,
  603.        "*error in protocol - csuitelength shouldn't be odd*n");
  604.   }
  606.   for (w=0; w<csuitelength; w+=2) {
  607.     const char *cs_str=NULL;
  608.     PRUint32 cs_int=0;
  609.     cs_int = GET_SHORT((hsdata+pos+2+w));
  610.     cs_str = V2CipherString(cs_int);
  612.     PR_fprintf(PR_STDOUT,
  613.       "                (0x%04x) %sn", cs_int, cs_str);
  614.   }
  616.   /*   for (w=0;w<csuitelength;w+=2) {
  617.     PR_fprintf(PR_STDOUT,"0x%04x ",GET_SHORT((hsdata+pos+2+w)));
  618.   } */
  620.   PR_fprintf(PR_STDOUT,"n               }n");
  621.   PR_fprintf(PR_STDOUT,"         }n");
  625. } /* end of ssl version 3 */
  626. break;
  627.       default:
  628. PR_fprintf(PR_STDOUT,"           ClientHelloUndefinedVersion{}n");
  629.       } /* end of switch sr->ver_maj */
  630.       break;
  632.     case 2: /* server hello */
  633.       {
  634. int sidlength, pos;
  635. const char *cs_str=NULL;
  636. PRUint32 cs_int=0;
  637. PR_fprintf(PR_STDOUT,"         ServerHello {n");
  638. PR_fprintf(PR_STDOUT,"            server_version = {%d, %d}n",
  639.    (PRUint8)hsdata[0],(PRUint8)hsdata[1]);
  640. PR_fprintf(PR_STDOUT,"            random = {...}n");
  641. if (sslhexparse) print_hex(32,&hsdata[2]);
  642. PR_fprintf(PR_STDOUT,"            session ID = {n");
  643. sidlength = (int)hsdata[2+32];
  644. PR_fprintf(PR_STDOUT,"                length = %dn",sidlength);
  645. PR_fprintf(PR_STDOUT,"                contents = {..}n");
  646. if (sslhexparse) print_hex(sidlength,&hsdata[2+32+1]);
  647. PR_fprintf(PR_STDOUT,"            }n");
  648. pos = 2+32+1+sidlength;
  649. cs_int = GET_SHORT((hsdata+pos));
  650. cs_str = V2CipherString(cs_int);
  651. PR_fprintf(PR_STDOUT,"            cipher_suite = (0x%04x) %sn",
  652.    cs_int, cs_str);
  653. PR_fprintf(PR_STDOUT,"         }n");
  654.       }
  655.       break;
  659.     case 11: /* certificate */
  660.       {
  661. PRFileDesc *cfd;
  662. int         pos;
  663. int         certslength;
  664. int         certlength;
  665. int         certbytesread = 0;
  666. static int  certFileNumber;
  667. char        certFileName[20];
  669. PR_fprintf(PR_STDOUT,"         CertificateChain {n");
  670. certslength = GET_24(hsdata);
  671. PR_fprintf(PR_STDOUT,"            chainlength = %d (0x%04x)n",
  672. certslength,certslength);
  673. pos = 3;
  674. while (certbytesread < certslength) {
  675.   certlength = GET_24((hsdata+pos));
  676.   pos += 3;
  677.   PR_fprintf(PR_STDOUT,"            Certificate {n");
  678.   PR_fprintf(PR_STDOUT,"               size = %d (0x%04x)n",
  679. certlength,certlength);
  681.   PR_snprintf(certFileName, sizeof certFileName, "cert.%03d",
  682.               ++certFileNumber);
  683.   cfd = PR_Open(certFileName, PR_WRONLY|PR_CREATE_FILE, 0664);
  684.   if (!cfd) {
  685.     PR_fprintf(PR_STDOUT,
  686.                "               data = { couldn't save file '%s' }n",
  687.        certFileName);
  688.   } else {
  689.     PR_Write(cfd, (hsdata+pos), certlength);
  690.     PR_fprintf(PR_STDOUT,
  691.                "               data = { saved in file '%s' }n",
  692.        certFileName);
  693.     PR_Close(cfd);
  694.   }
  696.   PR_fprintf(PR_STDOUT,"            }n");
  697.   pos           += certlength;
  698.   certbytesread += certlength+3;
  699. }
  700. PR_fprintf(PR_STDOUT,"         }n");
  701.       }
  702.       break;
  704.     case 13: /* certificate request */
  705.       if (sslhexparse) { 
  706. PR_fprintf(PR_STDOUT,"         CertificateRequest {n");
  707.         print_hex(sslh.length, hsdata);
  708. PR_fprintf(PR_STDOUT,"         }n");
  709.       }
  710.       break;
  712.     case 16: /* client key exchange */
  713.       {
  714. PR_fprintf(PR_STDOUT,"         ClientKeyExchange {n");
  715. PR_fprintf(PR_STDOUT,"            message = {...}n");
  716. PR_fprintf(PR_STDOUT,"         }n");
  717.       }
  718.       break;
  720.     }  /* end of switch sslh.type */
  721.     offset += sslh.length + 4; /* +4 because of length (3 bytes) and type (1 byte) */
  722.   } /* while */
  723.   PR_fprintf(PR_STDOUT,"   }n");
  724. }
  727. void print_ssl(DataBufferList *s, int length, unsigned char *buffer)
  728. {
  729.   /* --------------------------------------------------------  */
  730.   /* first, create a new buffer object for this piece of data. */
  732.   DataBuffer *db;
  733.   int i,l;
  735.   if (s->size == 0 && length > 0 && buffer[0] >= 32 && buffer[0] < 128) {
  736.     /* Not an SSL record, treat entire buffer as plaintext */
  737.     PR_Write(PR_STDOUT,buffer,length);
  738.     return;
  739.   }
  742.   check_integrity(s);
  744.   i = 0;
  745.   l = length;
  747.   db = PR_NEW(struct _DataBuffer);
  749.   db->buffer = (unsigned char*)PR_Malloc(length);
  750.   db->length = length;
  751.   db->offset = 0;
  752.   memcpy(db->buffer, buffer, length);
  753.   db->next = NULL;
  755.   /* now, add it to the stream */
  757.   if (s->last != NULL) s->last->next = db;
  758.   s->last = db;
  759.   s->size += length;
  760.   if (s->first == NULL) s->first = db;
  762.   check_integrity(s);
  764.   /*------------------------------------------------------- */
  765.   /* now we look at the stream to see if we have enough data to
  766.      decode  */
  768.   while (s->size > 0 ) {
  769.     unsigned char *tbuf = NULL;
  771.     SSLRecord sr;
  772.     unsigned alloclen;
  773.     unsigned recordsize;
  775.     check_integrity(s);
  777.     if ( s->first == NULL) {
  778.       PR_fprintf(PR_STDOUT,"ERROR: s->first is nulln");
  779.       exit(9);
  780.     }
  782.     /* in the case of an SSL 2 client-hello (which is all ssltap supports) */
  783.     /* will have the high-bit set, whereas an SSL 3 client-hello will not  */
  784.     /* SSL2 can also send records that begin with the high bit clear.
  785.      * This code will incorrectly handle them. XXX
  786.      */
  787.     if (isV2Session || s->first->buffer[s->first->offset] & 0x80) {
  788.       /* it's an SSL 2 packet */
  789.       unsigned char lenbuf[3];
  791.       /* first, we check if there's enough data for it to be an SSL2-type
  792.        * record.  What a pain.*/
  793.       if (s->size < sizeof lenbuf) {
  794. partial_packet(length, s->size, sizeof lenbuf);
  795. return;
  796.       }
  798.       /* read the first two bytes off the stream. */
  799.       read_stream_bytes(lenbuf, s, sizeof(lenbuf));
  800.       alloclen = ((unsigned int)(lenbuf[0] & 0x7f) << 8) + lenbuf[1] + 
  801.                  ((lenbuf[0] & 0x80) ? 2 : 3);
  802.       PR_fprintf(PR_STDOUT, "alloclen = %u bytesn", alloclen);
  804.       /* put 'em back on the head of the stream. */
  805.       db = PR_NEW(struct _DataBuffer);
  807.       db->length = sizeof lenbuf;
  808.       db->buffer = (unsigned char*) PR_Malloc(db->length);
  809.       db->offset = 0;
  810.       memcpy(db->buffer, lenbuf, sizeof lenbuf);
  812.       db->next = s->first;
  813.       s->first = db;
  814.       if (s->last == NULL) 
  815. s->last = db;
  816.       s->size += db->length;
  818.       /* if there wasn't enough, go back for more. */
  819.       if (s->size < alloclen) {
  820. check_integrity(s);
  821. partial_packet(length, s->size, alloclen);
  822. return;
  823.       }
  824.       partial_packet(length, s->size, alloclen);
  826.       /* read in the whole record. */
  827.       tbuf = PR_Malloc(alloclen);
  828.       read_stream_bytes(tbuf, s, alloclen);
  830.       print_sslv2(s, tbuf, alloclen);
  831.       PR_FREEIF(tbuf);
  832.       check_integrity(s);
  834.       continue;
  835.     }
  837.     /***********************************************************/
  838.     /* It's SSL v3 */
  839.     /***********************************************************/
  840.     check_integrity(s);
  842.     if (s->size < sizeof(SSLRecord)) {
  843.       partial_packet(length, s->size, sizeof(SSLRecord));
  844.       return;
  845.     }
  847.     read_stream_bytes((unsigned char *)&sr, s, sizeof sr);
  849.     /* we have read the stream bytes. Look at the length of
  850.        the ssl record. If we don't have enough data to satisfy this
  851.        request, then put the bytes we just took back at the head
  852.        of the queue */
  853.     recordsize = GET_SHORT(sr.length);
  855.     if (recordsize > s->size) {
  856.       db = PR_NEW(struct _DataBuffer);
  858.       db->length = sizeof sr;
  859.       db->buffer = (unsigned char*) PR_Malloc(db->length);
  860.       db->offset = 0;
  861.       memcpy(db->buffer, &sr, sizeof sr);
  862.       db->next = s->first;
  864.       /* now, add it back on to the head of the stream */
  866.       s->first = db;
  867.       if (s->last == NULL) 
  868.         s->last = db;
  869.       s->size += db->length;
  871.       check_integrity(s);
  872.       partial_packet(length, s->size, recordsize);
  873.       return;
  874.     }
  875.     partial_packet(length, s->size, recordsize);
  878.     PR_fprintf(PR_STDOUT,"SSLRecord { [%s]n", get_time_string() );
  879.     if (sslhexparse) {
  880.       print_hex(5,(unsigned char*)&sr);
  881.     }
  883.     check_integrity(s);
  885.     PR_fprintf(PR_STDOUT,"   type    = %d (",sr.type);
  886.     switch(sr.type) {
  887.     case 20 :
  888.       PR_fprintf(PR_STDOUT,"change_cipher_spec)n");
  889.       break;
  890.     case 21 :
  891.       PR_fprintf(PR_STDOUT,"alert)n");
  892.       break;
  893.     case 22 :
  894.       PR_fprintf(PR_STDOUT,"handshake)n");
  895.       break;
  896.     case 23 :
  897.       PR_fprintf(PR_STDOUT,"application_data)n");
  898.       break;
  899.     default:
  900.       PR_fprintf(PR_STDOUT,"unknown)n");
  901.       break;
  902.     }
  903.     PR_fprintf(PR_STDOUT,"   version = { %d,%d }n",
  904.        (PRUint32)sr.ver_maj,(PRUint32)sr.ver_min);
  905.     PR_fprintf(PR_STDOUT,"   length  = %d (0x%x)n",
  906.      (PRUint32)GET_SHORT(sr.length), (PRUint32)GET_SHORT(sr.length));
  909.     alloclen = recordsize;
  910.     PR_ASSERT(s->size >= alloclen);
  911.     if (s->size >= alloclen) {
  912.       tbuf = (unsigned char*) PR_Malloc(alloclen);
  913.       read_stream_bytes(tbuf, s, alloclen);
  915.       if (s->isEncrypted) {
  916. PR_fprintf(PR_STDOUT,"            < encrypted >n");
  917.       } else 
  919.       switch(sr.type) {
  920.       case 20 : /* change_cipher_spec */
  921. if (sslhexparse) print_hex(alloclen,tbuf);
  922. s->isEncrypted = 1;  /* mark to say we can only dump hex form now on */
  923. break;
  925.       case 21 : /* alert */
  926. switch(tbuf[0]) {
  927. case 1: PR_fprintf(PR_STDOUT, "   warning: "); break;
  928. case 2: PR_fprintf(PR_STDOUT, "   fatal: "); break;
  929. default: PR_fprintf(PR_STDOUT, "   unknown level %d: ", tbuf[0]); break;
  930. }
  932. switch(tbuf[1]) {
  933. case 0:   PR_fprintf(PR_STDOUT, "close notifyn"); break;
  934. case 10:  PR_fprintf(PR_STDOUT, "unexpected messagen"); break;
  935. case 20:  PR_fprintf(PR_STDOUT, "bad record macn"); break;
  936. case 21:  PR_fprintf(PR_STDOUT, "decryption failedn"); break;
  937. case 22:  PR_fprintf(PR_STDOUT, "record overflown"); break;
  938. case 30:  PR_fprintf(PR_STDOUT, "decompression failuren"); break;
  939. case 40:  PR_fprintf(PR_STDOUT, "handshake failuren"); break;
  940. case 41:  PR_fprintf(PR_STDOUT, "no certificaten"); break;
  941. case 42:  PR_fprintf(PR_STDOUT, "bad certificaten"); break;
  942. case 43:  PR_fprintf(PR_STDOUT, "unsupported certificaten"); break;
  943. case 44:  PR_fprintf(PR_STDOUT, "certificate revokedn"); break;
  944. case 45:  PR_fprintf(PR_STDOUT, "certificate expiredn"); break;
  945. case 46:  PR_fprintf(PR_STDOUT, "certificate unknownn"); break;
  946. case 47:  PR_fprintf(PR_STDOUT, "illegal parametern"); break;
  947. case 48:  PR_fprintf(PR_STDOUT, "unknown CAn"); break;
  948. case 49:  PR_fprintf(PR_STDOUT, "access deniedn"); break;
  949. case 50:  PR_fprintf(PR_STDOUT, "decode errorn"); break;
  950. case 51:  PR_fprintf(PR_STDOUT, "decrypt errorn"); break;
  951. case 60:  PR_fprintf(PR_STDOUT, "export restrictionn"); break;
  952. case 70:  PR_fprintf(PR_STDOUT, "protocol versionn"); break;
  953. case 71:  PR_fprintf(PR_STDOUT, "insufficient securityn"); break;
  954. case 80:  PR_fprintf(PR_STDOUT, "internal errorn"); break;
  955. case 90:  PR_fprintf(PR_STDOUT, "user canceledn"); break;
  956. case 100: PR_fprintf(PR_STDOUT, "no renegotiationn"); break;
  957. default:  PR_fprintf(PR_STDOUT, "unknown error %dn", tbuf[1]); break;
  958. }
  960. if (sslhexparse) print_hex(alloclen,tbuf);
  961. break;
  963.       case 22 : /* handshake */ 
  964.         print_ssl3_handshake( tbuf, alloclen, &sr );
  965. break;
  967.       case 23 : /* application data */
  968.       default:
  969. print_hex(alloclen,tbuf);
  970. break;
  971.       }
  972.     }
  973.     PR_fprintf(PR_STDOUT,"}n");
  974.     PR_FREEIF(tbuf);
  975.     check_integrity(s);
  976.   }
  977. }
  979. void print_hex(int amt, unsigned char *buf) {
  980.   int i,j,k;
  981.   char *string = (char*)PR_Malloc(5000);
  982.   char t[20];
  985.   for(i=0;i<amt;i++) {
  986.     t[1] =0;
  988.     if (i%16 ==0) {  /* if we are at the beginning of a line */
  989.       PR_fprintf(PR_STDOUT,"%4x:",i); /* print the line number  */
  990.       strcpy(string,"");
  991.     }
  993.     if (i%4 == 0) {
  994.       PR_fprintf(PR_STDOUT," ");
  995.     }
  997.     t[0] = buf[i];
  999.     if (!isprint(t[0])) {
  1000.       t[0] = '.';
  1001.     }
  1002.     if (fancy)  {
  1003.       switch (t[0]) {
  1004.       case '<':
  1005.         strcpy(t,"&lt;");
  1006.         break;
  1007.       case '>':
  1008.         strcpy(t,"&gt;");
  1009.         break;
  1010.       case '&':
  1011.         strcpy(t,"&amp;");
  1012.         break;
  1013.       }
  1014.     }
  1015.     strcat(string,t);
  1017.     PR_fprintf(PR_STDOUT,"%02x ",(PRUint8) buf[i]);
  1019.     /* if we've reached the end of the line - add the string */
  1020.     if (i%16 == 15) PR_fprintf(PR_STDOUT," | %sn",string);
  1021.   }
  1022.   /* we reached the end of the buffer,*/
  1023.   /* do we have buffer left over? */
  1024.   j = i%16;
  1025.   if (j > 0) {
  1026.     for (k=0;k<(16-j);k++) PR_fprintf(PR_STDOUT,"   ");
  1027.     PR_fprintf(PR_STDOUT," |%sn",string);
  1028.   }
  1029.   PR_Free(string);
  1030. }
  1032. void Usage(void) {
  1033.   PR_fprintf(PR_STDERR, "SSLTAP (C) 1997, 1998 Netscape Communications Corporation.n");
  1034.   PR_fprintf(PR_STDERR, "Usage: ssltap [-vhfsxl] [-p port] hostname:portn");
  1035.   PR_fprintf(PR_STDERR, "   -v      [prints version string]n");
  1036.   PR_fprintf(PR_STDERR, "   -h      [outputs hex instead of ASCII]n");
  1037.   PR_fprintf(PR_STDERR, "   -f      [turn on Fancy HTML coloring]n");
  1038.   PR_fprintf(PR_STDERR, "   -s      [turn on SSL decoding]n");
  1039.   PR_fprintf(PR_STDERR, "   -x      [turn on extra SSL hex dumps]n");
  1040.   PR_fprintf(PR_STDERR, "   -p port [specify rendezvous port (default 1924)]n");
  1041.   PR_fprintf(PR_STDERR, "   -l      [loop - continue to wait for more connections]n");
  1044. }
  1046. void
  1047. showErr(const char * msg) {
  1048.   PRErrorCode  err       = PR_GetError();
  1049.   const char * errString;
  1051.   if (err == PR_UNKNOWN_ERROR)
  1052.     err = PR_CONNECT_RESET_ERROR; /* bug in NSPR. */
  1053.   errString = SECU_Strerror(err);
  1055.   if (!errString)
  1056.     errString = "(no text available)";
  1057.   PR_fprintf(PR_STDERR, "Error %d: %s: %s", err, errString, msg);
  1058. }
  1060. int main(int argc,  char *argv[])
  1061. {
  1062.   char *hostname;
  1063.   PRUint16 rendport=DEFPORT,port;
  1064.   PRHostEnt hp;
  1065.   PRStatus r;
  1066.   PRNetAddr na_client,na_server,na_rend;
  1067.   PRFileDesc *s_server,*s_client,*s_rend; /*rendezvous */
  1068.   char netdbbuf[PR_NETDB_BUF_SIZE];
  1069.   int c_count=0;
  1070.   PLOptState *optstate;
  1071.   PLOptStatus status;
  1073.   optstate = PL_CreateOptState(argc,argv,"fvxhslp:");
  1074.     while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
  1075.     switch (optstate->option) {
  1076.     case 'f':
  1077.       fancy++;
  1078.       break;
  1079.     case 'h':
  1080.       hexparse++;
  1081.       break;
  1082.     case 'v':
  1083.       PR_fprintf(PR_STDOUT,"Version: %sn",VERSIONSTRING);
  1084.       break;
  1085.     case 's':
  1086.       sslparse++;
  1087.       break;
  1088.     case 'x':
  1089.       sslhexparse++;
  1090.       break;
  1091.     case 'l':
  1092.       looparound++;
  1093.       break;
  1094.     case 'p':
  1095.       rendport = atoi(optstate->value);
  1096.       break;
  1097.     case '':
  1098.       hostname = PL_strdup(optstate->value);
  1099.     }
  1100.   }
  1101.   if (status == PL_OPT_BAD)
  1102.     Usage();
  1104.   if (fancy) {
  1105.     if (!hexparse && !sslparse) {
  1106.       PR_fprintf(PR_STDERR,
  1107. "Note: use of -f without -s or -h not recommended, n"
  1108. "as the output looks a little strange. It may be useful, howevern");
  1109.     }
  1110.   }
  1112.   if(! hostname ) Usage(), exit(2);
  1114.   {
  1115.     char *colon = (char *)strchr(hostname, ':');
  1116.     if (!colon) {
  1117.       PR_fprintf(PR_STDERR,
  1118.       "You must specify the host AND port you wish to connect ton");
  1119.       Usage(), exit(3);
  1120.     }
  1121.     port = atoi(&colon[1]);
  1122.     *colon = '';
  1124.     if (port == 0) {
  1125. PR_fprintf(PR_STDERR, "Port must be a nonzero number.n");
  1126. exit(4);
  1127.       }
  1128.   }
  1130.   /* find the 'server' IP address so we don't have to look it up later */
  1132.   if (fancy) {
  1133.       PR_fprintf(PR_STDOUT,"<HTML><HEAD><TITLE>SSLTAP output</TITLE></HEAD>n");
  1134.       PR_fprintf(PR_STDOUT,"<BODY><PRE>n");
  1135.     }
  1136.   PR_fprintf(PR_STDERR,"Looking up "%s"...n", hostname);
  1137.   r = PR_GetHostByName(hostname,netdbbuf,PR_NETDB_BUF_SIZE,&hp);
  1138.   if (r) {
  1139.     showErr("Host Name lookup failedn");
  1140.     exit(5);
  1141.   }
  1143.   PR_EnumerateHostEnt(0,&hp,0,&na_server);
  1144.   PR_InitializeNetAddr(PR_IpAddrNull,port,&na_server);
  1145.   /* set up the port which the client will connect to */
  1147.   r = PR_InitializeNetAddr(PR_IpAddrAny,rendport,&na_rend);
  1148.   if (r == PR_FAILURE) {
  1149.     PR_fprintf(PR_STDERR,
  1150.     "PR_InitializeNetAddr(,%d,) failed with error %dn",PR_GetError());
  1151.     exit(0);
  1152.   }
  1155.   s_rend = PR_NewTCPSocket();
  1156.   if (!s_rend) {
  1157.     showErr("Couldn't create socketn");
  1158.     exit(6);
  1159.   }
  1161.   if (PR_Bind(s_rend, &na_rend )) {
  1162.     PR_fprintf(PR_STDERR,"Couldn't bind to port %d (error %d)n",rendport, PR_GetError());
  1163.     exit(-1);
  1164.   }
  1166.   if ( PR_Listen(s_rend, 5)) {
  1167.     showErr("Couldn't listenn");
  1168.     exit(-1);
  1169.   }
  1171.   PR_fprintf(PR_STDERR,"Proxy socket ready and listeningn");
  1172.   do { /* accept one connection and process it. */
  1173.       PRPollDesc pds[2];
  1175.       s_client = PR_Accept(s_rend,&na_client,PR_SecondsToInterval(3600));
  1176.       if (s_client == NULL) {
  1177. showErr("accept timed outn");
  1178. exit(7);
  1179.       }
  1181.       s_server = PR_NewTCPSocket();
  1182.       if (s_server == NULL) {
  1183. showErr("couldn't open new socket to connect to server n");
  1184. exit(8);
  1185.       }
  1187.       r = PR_Connect(s_server,&na_server,PR_SecondsToInterval(5));
  1189.       if ( r == PR_FAILURE )
  1190.         {
  1191.   showErr("Couldn't connectn");
  1192.   return -1;
  1193.         }
  1195.       if (looparound) {
  1196. if (fancy)  PR_fprintf(PR_STDOUT,"<p><HR><H2>");
  1197. PR_fprintf(PR_STDOUT,"Connection #%d [%s]n", c_count+1,
  1198.                      get_time_string());
  1199. if (fancy)  PR_fprintf(PR_STDOUT,"</H2>");
  1200. }
  1203.       PR_fprintf(PR_STDOUT,"Connected to %s:%dn", hostname, port);
  1205. #define PD_C 0
  1206. #define PD_S 1
  1208.       pds[PD_C].fd = s_client;
  1209.       pds[PD_S].fd = s_server;
  1210.       pds[PD_C].in_flags = PR_POLL_READ;
  1211.       pds[PD_S].in_flags = PR_POLL_READ;
  1213.       /* make sure the new connections don't start out encrypted. */
  1214.       clientstream.isEncrypted = 0;
  1215.       serverstream.isEncrypted = 0;
  1216.       isV2Session = 0;
  1218.       while( (pds[PD_C].in_flags & PR_POLL_READ) != 0 ||
  1219.              (pds[PD_S].in_flags & PR_POLL_READ) != 0 )
  1220.         {  /* Handle all messages on the connection */
  1221.   PRInt32 amt;
  1222.   PRInt32 wrote;
  1223.   unsigned char buffer[ TAPBUFSIZ ];
  1225.   amt = PR_Poll(pds,2,PR_INTERVAL_NO_TIMEOUT);
  1226.   if (amt <= 0) {
  1227.     if (amt)
  1228. showErr( "PR_Poll failed.n");
  1229.     else
  1230. showErr( "PR_Poll timed out.n");
  1231.     break;
  1232.   }
  1234.   if (pds[PD_C].out_flags & PR_POLL_EXCEPT) {
  1235.     showErr( "Exception on client-side socket.n");
  1236.     break;
  1237.   }
  1239.   if (pds[PD_S].out_flags & PR_POLL_EXCEPT) {
  1240.     showErr( "Exception on server-side socket.n");
  1241.     break;
  1242.   }
  1245. /* read data, copy it to stdout, and write to other socket */
  1247.   if ((pds[PD_C].in_flags  & PR_POLL_READ) != 0 &&
  1248.       (pds[PD_C].out_flags & PR_POLL_READ) != 0 ) {
  1250.     amt = PR_Read(s_client, buffer, sizeof(buffer));
  1252.     if ( amt < 0)  {
  1253.       showErr( "Client socket read failed.n");
  1254.       break;
  1255.     }
  1257.     if( amt == 0 ) {
  1258.       PR_fprintf(PR_STDOUT, "Read EOF on Client socket. [%s]n",
  1259.                             get_time_string() );
  1260.       pds[PD_C].in_flags &= ~PR_POLL_READ;
  1261.       PR_Shutdown(s_server, PR_SHUTDOWN_SEND);
  1262.       continue;
  1263.     }
  1265.     PR_fprintf(PR_STDOUT,"--> [n");
  1266.     if (fancy) PR_fprintf(PR_STDOUT,"<font color=blue>");
  1268.     if (hexparse)  print_hex(amt, buffer);
  1269.     if (sslparse)  print_ssl(&clientstream,amt,buffer);
  1270.     if (!hexparse && !sslparse)  PR_Write(PR_STDOUT,buffer,amt);
  1271.     if (fancy) PR_fprintf(PR_STDOUT,"</font>");
  1272.     PR_fprintf(PR_STDOUT,"]n");
  1274.     wrote = PR_Write(s_server, buffer, amt);
  1275.     if (wrote != amt )  {
  1276.       if (wrote < 0) {
  1277.         showErr("Write to server socket failed.n");
  1278. break;
  1279.       } else {
  1280. PR_fprintf(PR_STDERR, "Short write to server socket!n");
  1281.       }
  1282.     }
  1283.   }  /* end of read from client socket. */
  1285. /* read data, copy it to stdout, and write to other socket */
  1286.   if ((pds[PD_S].in_flags  & PR_POLL_READ) != 0 &&
  1287.       (pds[PD_S].out_flags & PR_POLL_READ) != 0 ) {
  1289.     amt = PR_Read(s_server, buffer, sizeof(buffer));
  1291.     if ( amt < 0)  {
  1292.       showErr( "error on server-side socket.n");
  1293.       break;
  1294.     }
  1296.     if( amt == 0 ) {
  1297.       PR_fprintf(PR_STDOUT, "Read EOF on Server socket. [%s]n",
  1298.                             get_time_string() );
  1299.       pds[PD_S].in_flags &= ~PR_POLL_READ;
  1300.       PR_Shutdown(s_client, PR_SHUTDOWN_SEND);
  1301.       continue;
  1302.     } 
  1304.     PR_fprintf(PR_STDOUT,"<-- [n");
  1305.     if (fancy) PR_fprintf(PR_STDOUT,"<font color=red>");
  1306.     if (hexparse)  print_hex(amt, (unsigned char *)buffer);
  1307.     if (sslparse)  print_ssl(&serverstream,amt,(unsigned char *)buffer);
  1308.     if (!hexparse && !sslparse)  PR_Write(PR_STDOUT,buffer,amt);
  1309.     if (fancy) PR_fprintf(PR_STDOUT,"</font>");
  1310.     PR_fprintf(PR_STDOUT,"]n");
  1313.     wrote = PR_Write(s_client, buffer, amt);
  1314.     if (wrote != amt )  {
  1315.       if (wrote < 0) {
  1316.         showErr("Write to client socket failed.n");
  1317. break;
  1318.       } else {
  1319. PR_fprintf(PR_STDERR, "Short write to client socket!n");
  1320.       }
  1321.     }
  1323.   } /* end of read from server socket. */
  1325. /* Loop, handle next message. */
  1327.         } /* handle messages during a connection loop */
  1328.       PR_Close(s_client);
  1329.       PR_Close(s_server);
  1330.       flush_stream(&clientstream);
  1331.       flush_stream(&serverstream);
  1333.       c_count++;
  1334.       PR_fprintf(PR_STDERR,"Connection %d Complete [%s]n", c_count,
  1335.                             get_time_string() );
  1336.     }  while (looparound); /* accept connection and process it. */
  1337.     PR_Close(s_rend);
  1338.     return 0;
  1339. }