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

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

CA认证

开发平台：

WINDOWS

newproto.c：源码内容
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* 
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  34. #include <string.h>
  35. #include <assert.h>
  36. #ifdef WIN32
  37. #include <winsock.h>
  38. #endif
  39. #ifdef XP_MAC
  40. #include "macsocket.h"
  41. #endif
  42. #ifdef XP_UNIX
  43. #include "sys/types.h"
  44. #include "netinet/in.h" /* for ntohl & htonl */
  45. #endif
  46. #ifdef XP_OS2_EMX
  47. #include <sys/param.h>
  48. #endif
  49. #ifdef XP_OS2_VACPP
  50. #include <utils.h>
  51. #endif
  52. #ifdef XP_BEOS
  53. #include "ByteOrder.h"
  54. #endif
  56. #include "newproto.h"
  58. char SSMVersionString[] = "1.3";
  60. CMT_Alloc_fn cmt_alloc = malloc;
  61. CMT_Free_fn cmt_free = free;
  63. #define ASSERT(x) assert(x)
  65. #define CM_ntohl ntohl
  66. #define CM_htonl htonl
  68. char* SSM_GetVersionString(void)
  69. {
  70.     char *newString;
  71.     int strLen;
  73.     strLen = strlen(SSMVersionString);
  74.     newString = (char*)malloc(sizeof(char)*(strLen+1));
  75.     if (newString) {
  76.         memcpy(newString,SSMVersionString, strlen(SSMVersionString));
  77.         newString[strLen]='';
  78.     }
  79.     return newString;
  80. }
  83. /*************************************************************
  84.  *
  85.  * CMT_Init
  86.  *
  87.  *
  88.  ************************************************************/
  89. void
  90. CMT_Init(CMT_Alloc_fn allocfn, CMT_Free_fn freefn)
  91. {
  92.     cmt_alloc = allocfn;
  93.     cmt_free = freefn;
  94. }
  96. static CMTStatus
  97. decode_int(unsigned char **curptr, void *dest, CMInt32 *remaining)
  98. {
  99.     CMInt32 datalen = sizeof(CMInt32);
  101.     if (*remaining < datalen)
  102.         return CMTFailure;
  103.     *(CMInt32 *)dest = ntohl(**(CMInt32 **)curptr);
  104.     *remaining -= datalen;
  105.     *curptr += datalen;
  106.     return CMTSuccess;
  107. }
  109. static CMTStatus
  110. decode_string(unsigned char **curptr, CMInt32 *len,
  111.               unsigned char **data, CMInt32 *remaining)
  112. {
  113.     CMTStatus rv;
  114.     CMInt32 datalen;
  116.     rv = decode_int(curptr, len, remaining);
  117.     if (rv != CMTSuccess)
  118.         return CMTFailure;
  120.     /* NULL string */
  121.     if (*len == 0) {
  122.         *data = NULL;
  123.         goto done;
  124.     }
  126.     datalen = (*len + 3) & ~3;
  127.     if (*remaining < datalen)
  128.         return CMTFailure;
  130.     *data = (unsigned char *) cmt_alloc(*len + 1);
  131.     if (*data == NULL)
  132.         return CMTFailure;
  134.     memcpy(*data, *curptr, *len);
  135.     (*data)[*len] = 0;
  136.     *remaining -= datalen;
  137.     *curptr += datalen;
  138. done:
  139.     return CMTSuccess;
  140. }
  142. /*************************************************************
  143.  * CMT_DecodeMessage
  144.  *
  145.  * Decode msg into dest as specified by tmpl.
  146.  *
  147.  ************************************************************/
  148. CMTStatus
  149. CMT_DecodeMessage(CMTMessageTemplate *tmpl, void *dest, CMTItem *msg)
  150. {
  151.     unsigned char *curptr, *destptr, *list;
  152. void ** ptr;
  153.     CMInt32 remaining, len, choiceID = 0, listSize, listCount = 0;
  154.     CMBool inChoice = CM_FALSE, foundChoice = CM_FALSE, inList = CM_FALSE;
  155.     CMInt32 listItemSize = 0;
  156.     CMTStatus rv = CMTSuccess;
  157. CMTMessageTemplate *startOfList, *p;
  158. CMBool inStructList = CM_FALSE;
  160.     curptr = msg->data;
  161.     remaining = msg->len;
  163.     while(tmpl->type != CMT_DT_END) {
  164.         /* XXX Maybe this should be a more formal state machine? */
  165.         if (inChoice) {
  166.             if (tmpl->type == CMT_DT_END_CHOICE) {
  167.                 if (!foundChoice)
  168.                     goto loser;
  169.                 inChoice = CM_FALSE;
  170.                 foundChoice = CM_FALSE;
  171.                 tmpl++;
  172.                 continue;
  173.             }
  174.             if (choiceID != tmpl->choiceID) {
  175.                 tmpl++;
  176.                 continue;  /* Not this option */
  177.             } else {
  178.                 foundChoice = CM_TRUE;
  179.             }
  180.         }
  181.         if (inList) {
  182.             destptr = &list[listCount * listItemSize];
  183.             listCount++;
  184.         } else {
  185. if (inStructList) {
  186. destptr = tmpl->offset + list;
  187. } else {
  188. destptr = tmpl->offset + (unsigned char *)dest;
  189. }
  190.         }
  191.         switch (tmpl->type) {
  192.           case CMT_DT_RID:
  193.           case CMT_DT_INT:
  194.           case CMT_DT_BOOL:
  195.             rv = decode_int(&curptr, destptr, &remaining);
  196.             if (rv != CMTSuccess)
  197.                 goto loser;
  198.             break;
  199.           case CMT_DT_STRING:
  200.             rv = decode_string(&curptr, &len, (unsigned char **)destptr,
  201.                                &remaining);
  202.             if (rv != CMTSuccess)
  203.                 goto loser;
  204.             break;
  205.           case CMT_DT_ITEM:
  206.             rv = decode_string(&curptr, (long *) &((CMTItem *)destptr)->len,
  207.                                &((CMTItem *)destptr)->data, &remaining);
  208.             if (rv != CMTSuccess)
  209.                 goto loser;
  210.             break;
  211.           case CMT_DT_LIST:
  212.             /* XXX This is too complicated */
  213.             rv = decode_int(&curptr, destptr, &remaining);
  214.             if (rv != CMTSuccess)
  215.                 goto loser;
  216.             listSize = *(CMInt32 *)destptr;
  217.             tmpl++;
  218.             if (tmpl->type == CMT_DT_STRING) {
  219.                 listItemSize = sizeof(unsigned char *);
  220.             } else if (tmpl->type == CMT_DT_ITEM) {
  221.                 listItemSize = sizeof(CMTItem);
  222.             } else {
  223.                 listItemSize = sizeof(CMInt32);
  224.             }
  225.             if (listSize == 0) {
  226.                 list = NULL;
  227.             } else {
  228.                 list = (unsigned char *) cmt_alloc(listSize * listItemSize);
  229.             }
  230.             *(void **)(tmpl->offset + (unsigned char *)dest) = list;
  231.             inList = CM_TRUE;
  232.             listCount = 0;
  233.             break;
  234.           case CMT_DT_STRUCT_LIST:
  235.             /* XXX This is too complicated */
  236.             rv = decode_int(&curptr, destptr, &remaining);
  237.             if (rv != CMTSuccess)
  238.                 goto loser;
  239.             listSize = *(CMInt32 *)destptr;
  240.             tmpl++;
  241. if (tmpl->type != CMT_DT_STRUCT_PTR) {
  242. goto loser;
  243. }
  244. ptr = (void**)(tmpl->offset + (unsigned char *)dest);
  245. startOfList = tmpl;
  246. p = tmpl;
  247. listItemSize = 0;
  248. while (p->type != CMT_DT_END_STRUCT_LIST) {
  249. if (p->type == CMT_DT_STRING) {
  250. listItemSize += sizeof(unsigned char *);
  251. } else if (p->type == CMT_DT_ITEM) {
  252. listItemSize += sizeof(CMTItem);
  253. } else if (p->type == CMT_DT_INT) {
  254.                 listItemSize += sizeof(CMInt32);
  255.         }
  256. p++;
  257. }
  258.             if (listSize == 0) {
  259.                 list = NULL;
  260.             } else {
  261.                 list = (unsigned char *) cmt_alloc(listSize * listItemSize);
  262.             }
  263.             *ptr = list;
  264.             inStructList = CM_TRUE;
  265.             listCount = 0;
  266.             break;
  267.   case CMT_DT_END_STRUCT_LIST:
  268. listCount++;
  269. if (listCount == listSize) {
  270. inStructList = CM_FALSE;
  271. } else {
  272. list += listItemSize;
  273. tmpl = startOfList;
  274. }
  275. break;
  276.           case CMT_DT_CHOICE:
  277.             rv = decode_int(&curptr, destptr, &remaining);
  278.             if (rv != CMTSuccess)
  279.                 goto loser;
  280.             choiceID = *(CMInt32 *)destptr;
  281.             inChoice = CM_TRUE;
  282.             foundChoice = CM_FALSE;
  283.             break;
  284.           case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
  285.           case CMT_DT_END:
  286.           default:
  287.             ASSERT(0);
  288.             break;
  289.         }
  290.         if (inList) {
  291.             if (listCount == listSize) {
  292.                 inList = CM_FALSE;
  293.                 tmpl++;
  294.             }
  295.         } else {
  296.             tmpl++;
  297.         }
  298.     }
  299. loser:
  300.     /* Free the data buffer */
  301.     if (msg->data) {
  302.         cmt_free(msg->data);
  303.         msg->data = NULL;
  304.     }
  305.     return rv;
  306. }
  308. static CMTStatus
  309. calc_msg_len(CMTMessageTemplate *tmpl, void *src, CMInt32 *len_out)
  310. {
  311.     CMInt32 len = 0, choiceID = 0, listSize, listItemSize, listCount;
  312.     unsigned char *srcptr, *list;
  313.     CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
  314. CMTMessageTemplate *startOfList, *p;
  315. CMBool inStructList = CM_FALSE;
  317.     while(tmpl->type != CMT_DT_END) {
  318.         if (inChoice) {
  319.             if (tmpl->type == CMT_DT_END_CHOICE) {
  320.                 if (!foundChoice)
  321.                     goto loser;
  322.                 inChoice = CM_FALSE;
  323.                 foundChoice = CM_FALSE;
  324.                 tmpl++;
  325.                 continue;
  326.             }
  327.             if (choiceID != tmpl->choiceID) {
  328.                 tmpl++;
  329.                 continue;  /* Not this option */
  330.             } else {
  331.                 foundChoice = CM_TRUE;
  332.             }
  333.         }
  334.         if (inList) {
  335.             srcptr = &list[listCount * listItemSize];
  336.             listCount++;
  337.         } else if (inStructList) {
  338. srcptr = tmpl->offset + list;
  339. } else {
  340.             srcptr = tmpl->offset + (unsigned char *)src;
  341.         }
  342.         switch(tmpl->type) {
  343.           case CMT_DT_RID:
  344.           case CMT_DT_INT:
  345.           case CMT_DT_BOOL:
  346.             len += sizeof(CMInt32);
  347.             break;
  348.           case CMT_DT_STRING:
  349.             len += sizeof(CMInt32);
  350.             /* Non NULL string */
  351.             if (*(char**)srcptr) {
  352.                 len += (strlen(*(char**)srcptr) + 4) & ~3;
  353.             }
  354.             break;
  355.           case CMT_DT_ITEM:
  356.             len += sizeof(CMInt32);
  357.             len += (((CMTItem *)srcptr)->len + 3) & ~3;
  358.             break;
  359.           case CMT_DT_LIST:
  360.             len += sizeof(CMInt32);
  361.             listSize = *(CMInt32 *)srcptr;
  362.             tmpl++;
  363.             if (tmpl->type == CMT_DT_STRING) {
  364.                 listItemSize = sizeof(unsigned char *);
  365.             } else if (tmpl->type == CMT_DT_ITEM) {
  366.                 listItemSize = sizeof(CMTItem);
  367.             } else {
  368.                 listItemSize = sizeof(CMInt32);
  369.             }
  370.             list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
  371.             listCount = 0;
  372.             inList = CM_TRUE;
  373.             break;
  374.   case CMT_DT_STRUCT_LIST:
  375. len += sizeof(CMInt32);
  376. listSize = *(CMInt32 *)srcptr;
  377. tmpl++;
  378. if (tmpl->type != CMT_DT_STRUCT_PTR) {
  379. goto loser;
  380. }
  381. list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
  382. startOfList = tmpl;
  383. p = tmpl;
  384. listItemSize = 0;
  385. while (p->type != CMT_DT_END_STRUCT_LIST) {
  386. if (p->type == CMT_DT_STRING) {
  387. listItemSize += sizeof(unsigned char *);
  388. } else if (p->type == CMT_DT_ITEM) {
  389. listItemSize += sizeof(CMTItem);
  390. } else if (p->type == CMT_DT_INT) {
  391. listItemSize += sizeof(CMInt32);
  392. }
  393. p++;
  394. }
  395. listCount = 0;
  396. inStructList = CM_TRUE;
  397. break;
  398.   case CMT_DT_END_STRUCT_LIST:
  399. listCount++;
  400. if (listCount == listSize) {
  401. inStructList = CM_FALSE;
  402. } else {
  403. list += listItemSize;
  404. tmpl = startOfList;
  405. }
  406. break;
  407.           case CMT_DT_CHOICE:
  408.             len += sizeof(CMInt32);
  409.             choiceID = *(CMInt32 *)srcptr;
  410.             inChoice = CM_TRUE;
  411.             foundChoice = CM_FALSE;
  412.             break;
  413.           case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
  414.           case CMT_DT_END:
  415.           default:
  416.             ASSERT(0);
  417.             break;
  418.         }
  419.         if (inList) {
  420.             if (listCount == listSize) {
  421.                 inList = CM_FALSE;
  422.                 tmpl++;
  423.             }
  424.         } else {
  425.             tmpl++;
  426.         }
  427.     }
  428.     *len_out = len;
  429.     return CMTSuccess;
  430. loser:
  431.     return CMTFailure;
  432. }
  434. static CMTStatus
  435. encode_int(unsigned char **curptr, void *src, CMInt32 *remaining)
  436. {
  437.     CMInt32 datalen = sizeof(CMInt32);
  439.     if (*remaining < datalen)
  440.         return CMTFailure;
  441.     **(CMInt32 **)curptr = CM_htonl(*(CMInt32 *)src);
  442.     *remaining -= datalen;
  443.     *curptr += datalen;
  444.     return CMTSuccess;
  445. }
  447. static CMTStatus
  448. encode_string(unsigned char **curptr, CMInt32 len,
  449.               unsigned char *data, CMInt32 *remaining)
  450. {
  451.     CMTStatus rv;
  452.     CMInt32 datalen;
  454.     rv = encode_int(curptr, &len, remaining);
  455.     if (rv != CMTSuccess)
  456.         return CMTFailure;
  458.     /* NULL string */
  459.     if (len == 0) {
  460.         goto done;
  461.     }
  463.     datalen = (len + 3) & ~3;
  464.     if (*remaining < datalen)
  465.         return CMTFailure;
  467.     memcpy(*curptr, data, len);
  468.     *remaining -= datalen;
  469.     *curptr += datalen;
  470. done:
  471.     return CMTSuccess;
  472. }
  474. /*************************************************************
  475.  * CMT_EncodeMessage
  476.  *
  477.  * Encode src into msg as specified by tmpl.
  478.  *
  479.  ************************************************************/
  480. CMTStatus
  481. CMT_EncodeMessage(CMTMessageTemplate *tmpl, CMTItem *msg, void *src)
  482. {
  483.     CMInt32 choiceID = 0, listSize, listItemSize, listCount, remaining;
  484.     unsigned char *srcptr, *curptr, *list;
  485.     CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
  486.     CMTStatus rv = CMTSuccess;
  487. CMTMessageTemplate *startOfList, *p;
  488. CMBool inStructList = CM_FALSE;
  490.     rv = calc_msg_len(tmpl, src, (long *) &msg->len);
  491.     if (rv != CMTSuccess)
  492.         goto loser;
  493.     curptr = msg->data = (unsigned char *) cmt_alloc(msg->len);
  494.     if(msg->data == NULL)
  495.         goto loser;
  496.     remaining = msg->len;
  498.     while(tmpl->type != CMT_DT_END) {
  499.         if (inChoice) {
  500.             if (tmpl->type == CMT_DT_END_CHOICE) {
  501.                 if (!foundChoice)
  502.                     goto loser;
  503.                 inChoice = CM_FALSE;
  504.                 foundChoice = CM_FALSE;
  505.                 tmpl++;
  506.                 continue;
  507.             }
  508.             if (choiceID != tmpl->choiceID) {
  509.                 tmpl++;
  510.                 continue;  /* Not this option */
  511.             } else {
  512.                 foundChoice = CM_TRUE;
  513.             }
  514.         }
  515.         if (inList) {
  516.             srcptr = &list[listCount * listItemSize];
  517.             listCount++;
  518.         } else {
  519. if (inStructList) {
  520. srcptr = tmpl->offset + list;
  521. } else {
  522. srcptr = tmpl->offset + (unsigned char *)src;
  523. }
  524.         }
  525.         switch(tmpl->type) {
  526.           case CMT_DT_RID:
  527.           case CMT_DT_INT:
  528.           case CMT_DT_BOOL:
  529.             rv = encode_int(&curptr, srcptr, &remaining);
  530.             if (rv != CMTSuccess)
  531.                 goto loser;
  532.             break;
  533.           case CMT_DT_STRING:
  534.              if (*(char**)srcptr) {
  535.                  /* Non NULL string */
  536.                  rv = encode_string(&curptr, (long) strlen(*(char**)srcptr), 
  537.                                   *(unsigned char**)srcptr, &remaining);
  538.              } else {
  539.                  /* NULL string */
  540.                  rv = encode_string(&curptr, 0L, *(unsigned char**)srcptr, &remaining);
  541.              }
  542.              if (rv != CMTSuccess)
  543.                 goto loser;
  544.              break;
  545.           case CMT_DT_ITEM:
  546.             rv = encode_string(&curptr, ((CMTItem *)srcptr)->len,
  547.                                ((CMTItem *)srcptr)->data, &remaining);
  548.             if (rv != CMTSuccess)
  549.                 goto loser;
  550.             break;
  551.           case CMT_DT_LIST:
  552.             rv = encode_int(&curptr, srcptr, &remaining);
  553.             if (rv != CMTSuccess)
  554.                 goto loser;
  555.             listSize = *(CMInt32 *)srcptr;
  556.             tmpl++;
  557.             if (tmpl->type == CMT_DT_STRING) {
  558.                 listItemSize = sizeof(unsigned char *);
  559.             } else if (tmpl->type == CMT_DT_ITEM) {
  560.                 listItemSize = sizeof(CMTItem);
  561.             } else {
  562.                 listItemSize = sizeof(CMInt32);
  563.             }
  564.             list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
  565.             listCount = 0;
  566.             inList = CM_TRUE;
  567.             break;
  568.   case CMT_DT_STRUCT_LIST:
  569.             rv = encode_int(&curptr, srcptr, &remaining);
  570.             if (rv != CMTSuccess)
  571.                 goto loser;
  572.             listSize = *(CMInt32 *)srcptr;
  573. tmpl++;
  574. if (tmpl->type != CMT_DT_STRUCT_PTR) {
  575. goto loser;
  576. }
  577. list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
  578. startOfList = tmpl;
  579. p = tmpl;
  580. listItemSize = 0;
  581. while (p->type != CMT_DT_END_STRUCT_LIST) {
  582. if (p->type == CMT_DT_STRING) {
  583. listItemSize += sizeof(unsigned char *);
  584. } else if (p->type == CMT_DT_ITEM) {
  585. listItemSize += sizeof(CMTItem);
  586. } else if (p->type == CMT_DT_INT) {
  587. listItemSize += sizeof(CMInt32);
  588. }
  589. p++;
  590. }
  591. listCount = 0;
  592. inStructList = CM_TRUE;
  593. break;
  594.   case CMT_DT_END_STRUCT_LIST:
  595. listCount++;
  596. if (listCount == listSize) {
  597. inStructList = CM_FALSE;
  598. } else {
  599. list += listItemSize;
  600. tmpl = startOfList;
  601. }
  602. break;
  603.           case CMT_DT_CHOICE:
  604.             rv = encode_int(&curptr, srcptr, &remaining);
  605.             if (rv != CMTSuccess)
  606.                 goto loser;
  607.             choiceID = *(CMInt32 *)srcptr;
  608.             inChoice = CM_TRUE;
  609.             foundChoice = CM_FALSE;
  610.             break;
  611.           case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
  612.           case CMT_DT_END:
  613.           default:
  614.             ASSERT(0);
  615.             break;
  616.         }
  617.         if (inList) {
  618.             if (listCount == listSize) {
  619.                 inList = CM_FALSE;
  620.                 tmpl++;
  621.             }
  622.         } else {
  623.             tmpl++;
  624.         }
  625.     }
  626.     return CMTSuccess;
  627. loser:
  628.     return CMTFailure;
  629. }