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

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

CA认证

开发平台：

WINDOWS

servutil.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 "serv.h"
  35. #include "secport.h"
  36. #include "collectn.h"
  37. #include "resource.h"
  38. #include "connect.h"
  39. #include "plstr.h"
  40. #include "prprf.h"
  41. #include "base64.h"
  42. #include "textgen.h"
  43. #include "protocolf.h"
  44. #include "p12res.h"
  45. #include "ctrlconn.h"
  46. #include "newproto.h"
  47. #include "messages.h"
  49. #ifdef XP_UNIX
  50. #include "private/pprio.h"
  51. #include <unistd.h>
  53. #define GET_LOCK_FILE_PATH(b)  
  54.         sprintf(b, "/tmp/.nsmc-%d-lock", (int)geteuid())
  55. #define GET_CONTROL_SOCK_PATH(b) 
  56.         sprintf(b, "/tmp/.nsmc-%d", (int)geteuid())
  58. PRFileDesc *lockfile = NULL;
  60. #endif
  62. #define DEBUG_QUEUES
  64. extern SSMCollection * connections;
  66. /* Dumps a (potentially binary) buffer using SSM_DEBUG. 
  67.    (We could have used the version in ssltrace.c, but that's
  68.    specifically tailored to SSLTRACE. Sigh. */
  69. #define DUMPBUF_LINESIZE 8
  70. void
  71. SSM_DumpBuffer(char *buf, PRIntn len)
  72. {
  73.     char hexbuf[DUMPBUF_LINESIZE*3+1];
  74.     char chrbuf[DUMPBUF_LINESIZE+1];
  75.     static const char *hex = "0123456789abcdef";
  76.     PRIntn i = 0, l = 0;
  77.     char ch, *c, *h;
  79.     hexbuf[DUMPBUF_LINESIZE*3] = '';
  80.     chrbuf[DUMPBUF_LINESIZE] = '';
  81.     (void) memset(hexbuf, 0x20, DUMPBUF_LINESIZE*3);
  82.     (void) memset(chrbuf, 0x20, DUMPBUF_LINESIZE);
  83.     h = hexbuf;
  84.     c = chrbuf;
  86.     while (i < len)
  87.     {
  88.         ch = buf[i];
  90.         if (l == DUMPBUF_LINESIZE)
  91.         {
  92.             SSM_DEBUG("%s%sn", hexbuf, chrbuf);
  93.             (void) memset(hexbuf, 0x20, DUMPBUF_LINESIZE*3);
  94.             (void) memset(chrbuf, 0x20, DUMPBUF_LINESIZE);
  95.             h = hexbuf;
  96.             c = chrbuf;
  97.             l = 0;
  98.         }
  100.         /* Convert a character to hex. */
  101.         *h++ = hex[(ch >> 4) & 0xf];
  102.         *h++ = hex[ch & 0xf];
  103.         h++;
  104.         
  105.         /* Put the character (if it's printable) into the character buffer. */
  106.         if ((ch >= 0x20) && (ch <= 0x7e))
  107.             *c++ = ch;
  108.         else
  109.             *c++ = '.';
  110.         i++; l++;
  111.     }
  112.     SSM_DEBUG("%s%sn", hexbuf, chrbuf);
  113. }
  115. PRIntn SSM_ReadThisMany(PRFileDesc * sockID, void * buffer, PRIntn thisMany)
  116. {
  117.     int got = 0;
  118.     PRIntn total = 0;
  119.   
  120.     while (total < thisMany) {
  121.         got = PR_Recv(sockID, (void *)((char *)buffer + total), thisMany-total, 
  122.                       0, PR_INTERVAL_NO_TIMEOUT);
  123.         if (got <= 0 ) break;
  124.         total += got;
  125.     } 
  127.     /* Clear the PR error if we got EOF in the final read, 
  128.        as opposed to -1 bytes. */
  129.     if (got == 0)
  130.         PR_SetError(0, 0);
  131.     
  132.     return total;
  133. }
  134.  
  135. PRIntn SSM_WriteThisMany(PRFileDesc * sockID, void * buffer, PRIntn thisMany)
  136. {
  137.   PRIntn total = 0;
  138.   
  139.   while (total < thisMany) {
  140.     PRIntn got;
  141.     got = PR_Send(sockID, (void *)((char *)buffer+total), thisMany-total, 
  142.   0, PR_INTERVAL_NO_TIMEOUT);
  143.     if (got < 0) break;
  144.     total += got;
  145.   }
  146.   return total;
  147. }
  150. SECItem * SSM_ConstructMessage(PRUintn size) 
  151. {
  152.   SECItem * ptr = NULL;
  153.   
  154. #if 0
  155.   SSM_DEBUG("allocating message of size %ld.n", (long) size);
  156. #endif
  157.   
  158.   ptr = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  159.   if (!ptr) {
  160.     PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
  161.     goto loser;
  162.   }
  163.   ptr->len = size;
  164.   if (size > 0) { 
  165.     ptr->data = (unsigned char *)PORT_ZAlloc(size);
  166.     if (!ptr->data) {
  167.       PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
  168.       goto loser;
  169.       }
  170.   }
  171.   return ptr;
  172. loser:
  173.   SSM_FreeMessage(ptr);
  174.   return NULL;
  175. }
  177. void SSM_FreeMessage(SECItem * msg)
  178. {
  179.   if (!msg) return;
  180.   if (msg->data)
  181.     PORT_Free(msg->data);
  182.   PORT_Free(msg);
  183. }
  185. void
  186. ssm_DrainAndDestroyQueue(SSMCollection **coll)
  187. {
  188.     SSMCollection *v;
  189.     PRIntn type, len;
  190.     char *data;
  192.     if ((coll == NULL) || (*coll == NULL))
  193. return;
  195.     v = *coll;
  197.     /* Drain the collection. Don't block; presumably this is
  198.        being done at destruction time. */
  199.     while(SSM_RecvQMessage(v, SSM_PRIORITY_ANY, 
  200.    &type, &len, &data, 
  201.    PR_FALSE) == PR_SUCCESS)
  202.     {
  203. if (data)
  204.     PR_Free(data);
  205.     }
  207. #if 0
  208.     /* NotifyAll on the lock and yield time. */
  209.     /* ### mwelch - Causing problems on Linux, and shouldn't even 
  210.                     be here since we don't have the queue locked, 
  211.                     so I'm removing it. */
  212.     PR_NotifyAll(v->lock);
  213. #endif
  214.     /* Destroy the collection. */
  215.     SSM_DestroyCollection(v);
  217.     /* Zero out the original member. */
  218.     *coll = NULL;
  219. }
  221. void
  222. ssm_DrainAndDestroyChildCollection(SSMCollection **coll)
  223. {
  224.     SSMCollection *v;
  225.     SSMConnection *conn;
  227.     if ((coll == NULL) || (*coll == NULL))
  228. return;
  230.     v = *coll;
  232.     /* Drain the collection. Don't block; presumably this is
  233.        being done at destruction time. */
  234.     while(SSM_Dequeue(v, SSM_PRIORITY_ANY, (void **) &conn, PR_FALSE) == PR_SUCCESS) {;}
  236.     /* Destroy the collection. */
  237.     SSM_DestroyCollection(v);
  239.     /* Zero out the original member. */
  240.     *coll = NULL;
  241. }
  243. static SSMHashTable *ssmThreads = NULL;
  245. void SSM_ConnectionThreadName(char *buf)
  246. {
  247.     PRThread * threadptr = PR_GetCurrentThread();
  248.     char *name;
  250.     buf[0] = ''; /* in case we fail */
  252.     if (!ssmThreads) return;
  254.     if (SSM_HashFind(ssmThreads, (SSMHashKey) threadptr, (void **) &name)
  255.         != SSM_SUCCESS)
  256.         return;
  257.     
  258.     if (name)
  259.         PL_strcpy(buf, name);
  260. }
  262. static SSMCollection *logSockets = NULL;
  263. static PRMonitor *logSocketLock = NULL;
  265. /* Add the filedesc to a list of sockets to receive log output */
  266. SSMStatus
  267. SSM_AddLogSocket(PRFileDesc *fd)
  268. {
  269.     SSMStatus rv = SSM_SUCCESS;
  271.     PR_ASSERT(logSockets);
  272.     PR_ASSERT(logSocketLock);
  274.     PR_EnterMonitor(logSocketLock);
  275.     rv = SSM_Enqueue(logSockets, SSM_PRIORITY_NORMAL, fd);
  276.     PR_ExitMonitor(logSocketLock);    
  278.     if (rv != SSM_SUCCESS) 
  279.         SSM_DEBUG("SSM_AddLogSocket returned error %d.n", rv);
  281.     return rv;
  282. }
  285. /* Called by a newly created thread, this associates a name with the thread. */
  286. void
  287. SSM_RegisterThread(char *threadName, SSMResource *ptr)
  288. {
  289.     SSMStatus rv = SSM_SUCCESS;
  290.     PRThread *thr = PR_GetCurrentThread();
  291.     char *value;
  293. #ifdef XP_MAC
  294.     /* 
  295.      Each thread, when registering itself using one of the two functions
  296.      below, assigns itself as private data at index (thdIndex). This is
  297.      necessary because when a thread exits, we want it to delete itself
  298.      from the list of threads we need to kill at exit time. 
  299.     */
  300.     { 
  301.       PRUintn threadIndex = GetThreadIndex();
  302.       if (threadIndex > 0) {
  303.        if (PR_GetThreadPrivate(threadIndex) != thr)
  304.        PR_SetThreadPrivate(threadIndex, thr);
  305.       }
  306.     }
  307. #endif
  309.     if (ptr)
  310.     {
  311.         PR_ASSERT(SSM_IsAKindOf(ptr, SSM_RESTYPE_RESOURCE));
  312.         /* Increment the thread count for this resource. */
  313.         SSM_LockResource(ptr);
  314.         ptr->m_threadCount++;
  315.         SSM_UnlockResource(ptr);
  316.     }
  317.     if (threadName)
  318.     {
  319.         if (ptr)
  320.             value = PR_smprintf("%s %p", threadName, ptr);
  321.         else
  322.             value = PL_strdup(threadName);
  323.     }
  324.     else
  325.         value = PR_smprintf("unknown %p/%p", thr, ptr);
  327.     if ((!ssmThreads) &&
  328.         ((rv = SSM_HashCreate(&ssmThreads)) != SSM_SUCCESS))
  329.         return;
  331.     if (!value) return;
  333.     SSM_HashInsert(ssmThreads, (SSMHashKey) thr, value);
  334. }
  336. /* Called by a newly created thread, this associates a name with the thread. */
  337. void
  338. SSM_RegisterNewThread(char *threadName, SSMResource *ptr)
  339. {
  340.     SSMStatus rv = SSM_SUCCESS;
  341.     PRThread *thr = PR_GetCurrentThread();
  342.     char *value;
  344.     if (threadName)
  345.     {
  346.         if (ptr)
  347.             value = PR_smprintf("%s %p", threadName, ptr);
  348.         else
  349.             value = PL_strdup(threadName);
  350.     }
  351.     else
  352.         value = PR_smprintf("unknown %p/%p", thr, ptr);
  354.     if ((!ssmThreads) &&
  355.         ((rv = SSM_HashCreate(&ssmThreads)) != SSM_SUCCESS))
  356.         return;
  358.     if (!value) return;
  360.     SSM_HashInsert(ssmThreads, (SSMHashKey) thr, value);
  361. }
  363. void SSM_Debug(SSMResource *conn, char *msg)
  364. {
  365. #ifdef DEBUG
  366.   char name[256];
  367.   
  368.   SSM_ConnectionThreadName(name);
  369.   printf("%s: %s", name, msg);
  370.   fflush(stdout); 
  371.   PR_Free(msg);
  372. #endif
  373. }
  375. void SSM_DebugP(char *fmt, ...)
  376. {
  377. #if defined(DEBUG)
  378.     char *tmp = NULL, *tmp2 = NULL;
  379. char *timeStamp = NULL;
  380.     PRFileDesc *sock = NULL;
  381.     PRIntn len;
  382.     PRIntn numWritten;
  383.     char name[256];
  384.     va_list argp;
  385.     PRIntn count, i;
  386.     PRUint32 rv = 0;
  387. PRExplodedTime exploded;
  389.     /* protect against another socket add */
  390.     PR_EnterMonitor(logSocketLock);
  392.     if (!logSockets)
  393.         goto done;
  394.     
  395.     count = SSM_Count(logSockets);
  396.     if (count == 0)
  397.         goto done;
  399.     va_start(argp, fmt);
  400.     tmp = PR_vsmprintf(fmt, argp);
  401.     va_end(argp);
  402.     if (!tmp)
  403.         goto done;
  405. PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &exploded);
  406. timeStamp = PR_smprintf("%02i:%02i:%02i.%03i", exploded.tm_hour, 
  407.                             exploded.tm_min, exploded.tm_sec, 
  408.                             exploded.tm_usec/1000);
  409.     SSM_ConnectionThreadName(name);
  411.     tmp2 = PR_smprintf("[%s] %s: %s", timeStamp, name, tmp);
  412.     if (!tmp2)
  413.         goto done;
  415.     len = strlen(tmp2);
  416.     count = SSM_Count(logSockets);
  418.     /* count backwards in case we get an error */
  419.     for(i=(count-1);i>=0;i--)
  420.     {
  421.         numWritten = 0;
  422.         sock = (PRFileDesc *) SSM_At(logSockets, i);
  423.         if (sock)
  424.             numWritten = PR_Write(sock, tmp2, len);
  425.         if (numWritten < len)
  426.         {
  427.             /*SSM_Remove(logSockets, sock);*/
  428.             /*PR_Close(sock);*/
  429.             /*PR_Shutdown(sock, PR_SHUTDOWN_BOTH);*/
  430.             rv = 0;
  431.         }
  432.     }
  434.  done:
  435.     if (tmp)
  436.         PR_smprintf_free(tmp);
  437.     if (tmp2)
  438.         PR_smprintf_free(tmp2);
  439. if (timeStamp) 
  440. PR_smprintf_free(timeStamp);
  441.     PR_ExitMonitor(logSocketLock);
  442. #endif
  443. }
  445. #ifdef DEBUG
  446. void
  447. SSM_InitLogging(void)
  448. {
  449.     char *suppressConsole = NULL;
  450.     char *debugFile = NULL;
  452.     /* Create the condition variable we use to control logging. */
  453.     if (!(logSocketLock = PR_NewMonitor()))
  454.         goto loser;
  455.     if (!(logSockets = SSM_NewCollection()))
  456.         goto loser; 
  458.     suppressConsole = PR_GetEnv(SSM_ENV_SUPPRESS_CONSOLE);
  459.     debugFile = PR_GetEnv(SSM_ENV_LOG_FILE);
  461.     if (!suppressConsole)
  462.     {
  463.         PRFileDesc *stdfd = PR_GetSpecialFD(PR_StandardOutput);
  464.         if (!stdfd)
  465.             stdfd = PR_GetSpecialFD(PR_StandardError);
  466.         if (stdfd)
  467.             SSM_AddLogSocket(stdfd);
  468.     }
  470.     if (debugFile)
  471.     {
  472.         PRFileDesc *fd = PR_Open(debugFile, 
  473.                                  PR_WRONLY | PR_APPEND | 
  474.                                  PR_CREATE_FILE | PR_SYNC, 
  475.                                  0644);
  476.         if (fd)
  477.             SSM_AddLogSocket(fd);
  478.     }
  480.     SSM_DEBUG("Started logging.n");
  482.     return;
  483.  loser:
  484.     fprintf(stderr, "Can't initialize logging! Exiting.n");
  485.     exit(1);
  486. }
  487. #endif
  489. SSMStatus SSM_SendQMessage(SSMCollection *q,
  490.   PRIntn priority,
  491.   PRIntn type, PRIntn length, char *data,
  492.   PRBool doBlock)
  493. {
  494.   SECItem *n = NULL;
  495.   unsigned char *c = NULL;
  496.   SSMStatus rv = PR_FAILURE;
  498.   PR_ASSERT(priority != SSM_PRIORITY_ANY);
  500. #ifdef DEBUG_QUEUES
  501.   SSM_DEBUG("SendQMessage on %lx: prio %d, type %lx, len %dn", 
  502.             (unsigned long) q, priority, (unsigned long) type, length);
  503. #endif
  505.   /* Create a new message. */
  506.   n = (SECItem *) PORT_ZAlloc(sizeof(SECItem));
  507.   if (!n)
  508.       goto loser;
  509.   
  510.   if (data && length > 0) {
  511.      c = (unsigned char *) PORT_ZAlloc(length);
  512.      if (!c)
  513.          goto loser;
  515.      memcpy(c, data, length);
  516.   }
  517.   
  518.   n->type = (SECItemType) type;
  519.   n->len = length;
  520.   n->data = c;
  522.   /* ### mwelch We'll want to put a throttle here when we
  523.                 start really securing Cartman. It's currently
  524. possible for someone to make us run out of
  525. memory very quickly by flooding us with data. */
  526.                 
  527.   /* Put the msg in the queue. */
  528.   SSM_Enqueue(q, priority, n);
  529.   return PR_SUCCESS;
  531. loser:
  532.   if (n) PORT_Free(n);
  533.   if (c) PORT_Free(c);
  534.   return rv;
  535. }
  537. SSMStatus SSM_RecvQMessage(SSMCollection *q,
  538.   PRIntn priority,
  539.   PRIntn *type, PRIntn *length, char **data,
  540.   PRBool doBlock)
  541. {
  542.   SECItem *p;
  543.   void *v;
  545. #ifdef DEBUG_QUEUES
  546.   SSM_DEBUG("RecvQMessage on %lx: %s read at prio %dn", 
  547.             (unsigned long) q, 
  548.             (doBlock ? "blocking" : "nonblocking"), 
  549.             priority);
  550. #endif
  552.   /* Remove the item at the head of the queue. */
  553.   SSM_Dequeue(q, priority, &v, doBlock);
  554.   p = (SECItem *) v;
  556.   if (!p)
  557.     return PR_FAILURE;
  559.   /* Strip out the items. */
  560.   *data = (char *)p->data;
  561.   *length = p->len;
  562.   *type = p->type;
  563.   
  564. #ifdef DEBUG_QUEUES
  565.   SSM_DEBUG("RecvQMessage on %lx: type %lx, len %dn", 
  566.             (unsigned long) q, (unsigned long) *type, 
  567.             *length);
  568. #endif
  570.   /* Free the containing SECItem. */
  571.   PORT_Free(p);
  573.   return PR_SUCCESS;
  574. }
  576. SSMStatus
  577. SSM_SECItemToSSMString(void ** ssmstring, SECItem * data)
  578. {
  579.  SSMString * result = NULL;
  581.  if (!ssmstring || !data || data->len <= 0 ) 
  582. goto loser;
  583.  
  584.  *ssmstring = NULL; /* in case we fail */
  585.  result = (SSMString *) SSMPORT_ZAlloc(sizeof(data->len) + 
  586. SSMSTRING_PADDED_LENGTH(data->len));
  587.  if (!result) 
  588. goto loser;
  589.  memcpy((char *)(&(result->m_data)), data->data, data->len);
  590.  result->m_length = data->len;
  591.  *ssmstring = result;
  592.  return PR_SUCCESS;
  594. loser:
  595.  if (result) 
  597.      PR_Free(result);
  598.  return PR_FAILURE;
  599. }
  601. SSMStatus
  602. SSM_CopyCMTItem(CMTItem * dest, CMTItem * source)
  603. {
  604.     SSMStatus rv = SSM_FAILURE;
  605.     
  606.     if (!dest || !source) 
  607.         goto loser;
  608.     
  609.     dest->len = source->len;
  610.     if (!dest->len) 
  611.         goto done;
  612.     
  613.     dest->data = (unsigned char *) PR_Malloc(dest->len);
  614.     if (!dest->data) 
  615.         goto loser;
  616.     memcpy(dest->data, source->data, dest->len);
  617.  done: 
  618.     rv = SSM_SUCCESS;
  619.  loser:
  620.     return rv;
  621. }
  624. PRFileDesc * SSM_OpenControlPort(void)
  625. {
  626.     PRFileDesc * datasocket          = NULL;
  627.     PRNetAddr servaddr;
  628.     SSMStatus status;
  629.     PRSocketOptionData sockOpData;
  630. #ifdef XP_UNIX
  631.     char lock_name_buf[32];
  632. #endif
  634.     /* disable Nagle algorithm delay for control sockets */
  635.     sockOpData.option = PR_SockOpt_NoDelay;
  636.     sockOpData.value.no_delay = PR_TRUE;
  638. #ifdef XP_UNIX
  639.     GET_LOCK_FILE_PATH(lock_name_buf);
  640.     lockfile = PR_Open(lock_name_buf, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE,
  641.        0600);
  642.     if (!lockfile)
  643. goto loser;
  645.     status = PR_TLockFile(lockfile);
  646.     if (status != PR_SUCCESS)
  647. goto loser;
  649.     datasocket = PR_Socket(AF_UNIX, SOCK_STREAM, 0);
  650.     if (!datasocket)
  651.         goto loser;
  652.     servaddr.local.family = AF_UNIX;
  653.     GET_CONTROL_SOCK_PATH(servaddr.local.path);
  654.     PR_Delete(servaddr.local.path);
  655. #else
  656.     datasocket = PR_NewTCPSocket();
  657.     if (!datasocket)
  658.         goto loser;
  660.     status = PR_SetSocketOption(datasocket, &sockOpData);
  661.     if (status != PR_SUCCESS) {
  662.         goto loser;
  663.     }
  665.     /* Bind to PSM port on loopback address: connections from non-localhosts
  666.      * will be disallowed
  667.      */
  668.     status = PR_InitializeNetAddr(PR_IpAddrLoopback, (PRUint16) PSM_PORT,
  669.   &servaddr);
  670.     if (status != PR_SUCCESS)
  671.         goto loser;
  672. #endif
  674.     status = PR_Bind(datasocket, &servaddr);
  675.     if (status != PR_SUCCESS)
  676.         goto loser;
  677.     status = PR_Listen(datasocket, MAX_CONNECTIONS);
  678.     if (status != PR_SUCCESS)
  679.         goto loser;
  681. #ifdef XP_UNIX  
  682.     SSM_DEBUG("Ready for client connection on port %s.n", servaddr.local.path);
  683. #else
  684.     SSM_DEBUG("Ready for client connection on port %d.n", PSM_PORT);
  685. #endif
  687.     return datasocket;
  688.  loser:
  689.     return NULL;
  690. }
  692. /* Make sure that the peer is on the same machine that we are */
  693. PRBool
  694. SSM_SocketPeerCheck(PRFileDesc *sock, PRBool isCtrl)
  695. {
  696.     PRBool rv = PR_FALSE;
  697.     SSMStatus st = PR_SUCCESS;
  698.     PRNetAddr theirAddr;
  699.     char localaddr[] = {0x7F,0x00,0x00,0x01};/* 127.0.0.1 in network order */
  701. #if defined(XP_UNIX) || defined(XP_MAC)
  702. #ifdef XP_UNIX
  703.     if (isCtrl)
  704.     {
  705.         /* unix domain socket == same machine */
  706.         /* ### mwelch Well, the only time this isn't true is when
  707.            one wants to join many unix machines in a cluster, but 
  708.            even in that case the cluster should be treated as a 
  709.            single machine anyway. */
  710. #endif
  711. /*
  712. GetPeerName isn't implemented on the Mac, so say yes and hope/pray for now 
  713. ### mwelch - Need to implement GetPeerName in Mac NSPR before Mac Cartman RTM 
  714. */
  715.         rv = PR_TRUE;
  716.         goto done;
  717. #ifdef XP_UNIX
  718.     }
  719. #endif
  720. #endif
  722.     st = PR_GetPeerName(sock, &theirAddr);
  723.     if (st != PR_SUCCESS)
  724.         goto done; /* default is to fail */
  726.     /* Compare against localhost IP */
  727.     if (!memcmp(&(theirAddr.inet.ip), localaddr, 4))
  728.         rv = PR_TRUE;
  730.     if (rv != PR_TRUE)
  731.         SSM_DEBUG("Failed IP address check!n");
  733.  done:
  734.     return rv;
  735. }
  737. PRFileDesc * SSM_OpenPort(void)
  738. {
  739.     PRFileDesc * datasocket          = NULL;
  740.     PRNetAddr servaddr;
  741.     SSMStatus status;
  742.     PRSocketOptionData sockOpData;
  744.     /* disable Nagle algorithm delay for data sockets */
  745.     sockOpData.option = PR_SockOpt_NoDelay;
  746.     sockOpData.value.no_delay = PR_TRUE;
  748.     datasocket = PR_NewTCPSocket();
  749.     if (!datasocket)
  750.         goto loser;
  751.     status = PR_SetSocketOption(datasocket, &sockOpData);
  752.     if (status != PR_SUCCESS) {
  753.         goto loser;
  754.     }
  756.     /* Bind to PSM port on loopback address: connections from non-localhosts
  757.      * will be disallowed
  758.      */
  759.     status = PR_InitializeNetAddr(PR_IpAddrLoopback, 0, &servaddr);
  760.     if (status != PR_SUCCESS)
  761.         goto loser;
  763.     status = PR_Bind(datasocket, &servaddr);
  764.     if (status != PR_SUCCESS)
  765.         goto loser;
  766.     status = PR_Listen(datasocket, MAX_CONNECTIONS);
  767.     if (status != PR_SUCCESS)
  768.         goto loser;
  769.   
  770.     return datasocket;
  771.  loser:
  772.     return NULL;
  773. }
  775. #if 0
  776. /* Whee. Base 64 decoding. Have to do it for basic authentication. */
  777. #define XX 127
  778. /*
  779.  * Table for decoding base64. We have this everywhere else, why not here.
  780.  */
  781. static char index64[256] = {
  782.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  783.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  784.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,62, XX,XX,XX,63,
  785.     52,53,54,55, 56,57,58,59, 60,61,XX,XX, XX,XX,XX,XX,
  786.     XX, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  787.     15,16,17,18, 19,20,21,22, 23,24,25,XX, XX,XX,XX,XX,
  788.     XX,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  789.     41,42,43,44, 45,46,47,48, 49,50,51,XX, XX,XX,XX,XX,
  790.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  791.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  792.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  793.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  794.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  795.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  796.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  797.     XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  798. };
  800. #ifdef XP_OS2_HACK
  801. /*DSR102196 - the OS/2 Visual Age compiler croaks when it tries*/
  802. /*to optomize this macro (/O+ on CSD4)                         */ 
  803. char CHAR64(int c)
  804. {
  805.    unsigned char index;
  806.    char rc;
  808.    index = (unsigned char) c;
  809.    rc = index64[index];
  810.    return rc;
  811. } 
  812. #else /*normal code...*/
  813. #define CHAR64(c)  (index64[(unsigned char)(c)])
  814. #endif
  816. /* Decode a base 64 string in place. */
  817. void decode_base64_string(char *str)
  818. {
  819.     char *s = str;
  820.     char *d = str;
  821.     char c[4];
  822.     PRIntn i;
  823.     PRBool done = PR_FALSE;
  824.     
  825.     while((!done) && (*s))
  826.     {
  827.         /* Process 4 bytes at a time. */
  828.         for(i=0;i<4;i++)
  829.             c[i] = 0;
  830.         
  831.         for(i=0;i<4;i++)
  832.         {
  833.             if ((IS_WHITESPACE(*s)) || (IS_EOL(*s)))
  834.             {
  835.                 /* End here, because we're out of bytes. */
  836.                 done = PR_TRUE;
  837.             }
  838.             else
  839.                 c[i] = *s++;
  840.         }
  841.         
  842.         /* Make sure we can at least decode one character. */
  843.         if ((!done) && ((c[0] == '=') || (c[1] == '=')))
  844.             done = PR_TRUE; /* don't even have enough for one character, leave */
  845.         
  846.         if (!done)
  847.         {
  848.             /* Decode the first character. */
  849.             c[0] = CHAR64(c[0]);
  850.             c[1] = CHAR64(c[1]);
  851.             *d++ = ((c[0]<<2) | ((c[1] & 0x30)>>4));
  852.             
  853.             /* If we have data for a second character, decode that. */
  854.             if (c[2] != '=')
  855.             {
  856.                 c[2] = CHAR64(c[2]);
  857.                 *d++ = (((c[1] & 0x0F) << 4) | ((c[2] & 0x3C) >> 2));
  858.                 
  859.                 /* If we have data for a third character, decode that. */
  860.                 if (c[3] != '=')
  861.                 {
  862.                     c[3] = CHAR64(c[3]);
  863.                     *d++ = (((c[2] & 0x03) << 6) | c[3]);
  864.                 }
  865.                 else
  866.                     done = PR_TRUE;
  867.             }
  868.             else
  869.                 done = PR_TRUE;
  870.         }
  871.     }
  873.     /* Terminate the string. */
  874.     *d = '';
  875. }
  876. #endif
  878. #ifdef DEBUG
  879. char * 
  880. SSM_StandaloneGetPasswdCallback(PK11SlotInfo *slot, PRBool retry, 
  881.                                 void *arg)
  882. {
  883.     char *result = NULL;
  884.     char *env = NULL;
  885.     SECItem theItem = {siBuffer, NULL, 0};
  887.     if (retry)
  888.     {
  889.         /* Don't spin forever, just bail */
  890.         SSM_DEBUG("Static password you provided was not accepted. "
  891.                   "Cancelling request.n");
  892.         return NULL;
  893.     }
  895.     env = PR_GetEnv(SSM_ENV_STATIC_PASSWORD);
  896.     if (!env)
  897.         goto done;
  898.     
  899.     ATOB_ConvertAsciiToItem(&theItem, env);
  900.     if (theItem.data == NULL)
  901.         goto done;
  903.     result = (char *) PR_CALLOC(theItem.len + 1);
  904.     if (!result)
  905.         goto done;
  907.     strncpy(result, (char *) theItem.data, theItem.len);
  909.  done:
  910.     if (theItem.data != NULL)
  911.         SECITEM_FreeItem(&theItem, PR_FALSE);
  912.     if (result)
  913.         SSM_DEBUG("Responding to password request with a password.n");
  914.     else
  915.         SSM_DEBUG("Responding to password callback with NULL password.n");
  917.     return result;
  918. }
  920. PRBool 
  921. SSM_StandaloneVerifyPasswdCallback(PK11SlotInfo * slot, void * arg)
  922. {
  923.     /* yeah, sure, trust me, we're the ones who are sposta be logged in */
  924.     return PR_TRUE; 
  925. }
  926. #endif
  928. SSMStatus
  929. SSM_CloseSocketWithLinger(PRFileDesc *sock)
  930. {
  931.     PRSocketOptionData opt;
  932.     SSMStatus rv = PR_SUCCESS;
  933.     
  934.     /* 
  935.        Set linger for 15 minutes.
  936.        ### mwelch This time should really depend on what has been written
  937.        to the socket. For example, if we've just written 5 megabytes of data
  938.        down a 14.4 wire, we should wait considerably longer than 15 minutes.
  939.        The point here is that there's no way to determine a constant value 
  940.        ahead of time. So, 15 minutes. (Note that generally only client sockets
  941.        are closed in this way, so we hopefully will avoid major trouble.)
  942.      */
  943.     opt.option = PR_SockOpt_Linger;
  944.     opt.value.linger.polarity = PR_TRUE;
  945.     opt.value.linger.linger = PR_SecondsToInterval(60*15);
  946.     rv = PR_SetSocketOption(sock, &opt);
  948.     /* Now close the socket. */
  949.     if (rv == PR_SUCCESS)
  950.         rv = PR_Close(sock);
  952.     return rv;
  953. }
  955. char*
  956. SSM_GetCharFromKey(const char *key, const char *locale)
  957. {
  958.     SSMTextGenContext *textGenCxt  = NULL;
  959.     char              *asciiString = NULL;
  960.     SSMStatus           rv;
  962.     rv = SSMTextGen_NewContext(NULL, NULL, NULL, NULL, &textGenCxt);
  963.     if (rv != PR_SUCCESS) {
  964.         goto loser;
  965.     }
  966.     rv = SSM_FindUTF8StringInBundles(textGenCxt, key,
  967.                                      &asciiString);
  968.     if (rv != PR_SUCCESS) {
  969.         goto loser;
  970.     }
  971.     SSMTextGen_DestroyContext(textGenCxt);
  972.     return asciiString;
  973.  loser:
  974.     if (textGenCxt != NULL) {
  975.         SSMTextGen_DestroyContext(textGenCxt);
  976.     }
  977.     if (asciiString != NULL) {
  978.         PR_Free(asciiString);
  979.     }
  980.     return NULL;
  981. }
  983. SSMStatus SSM_RequestFilePathFromUser(SSMResource *res,
  984.                                       const char  *promptKey,
  985.                                       const char  *fileRegEx,
  986.                                       PRBool       getExistingFile)
  987. {
  988.     SECItem           *filePathRequest = NULL;
  989.     char              *asciiPrompt     = NULL;
  990.     SSMStatus          rv;
  991.     FilePathRequest    request;
  993.     filePathRequest = SSM_ZNEW(SECItem);
  994.     if (filePathRequest == NULL) {
  995.         return SSM_FAILURE;
  996.     }
  997.     asciiPrompt = SSM_GetCharFromKey(promptKey, "ISO_8859-1");
  998.     if (asciiPrompt == NULL) {
  999.         goto loser;
  1000.     }
  1002.     request.resID = res->m_id;
  1003.     request.prompt = asciiPrompt;
  1004.     request.getExistingFile = (CMBool) getExistingFile;
  1005.     request.fileRegEx = fileRegEx;
  1007.     if (CMT_EncodeMessage(FilePathRequestTemplate, (CMTItem*)filePathRequest, (void*)&request) != CMTSuccess) {
  1008.         goto loser;
  1009.     }
  1010.     filePathRequest->type = (SECItemType) (SSM_EVENT_MESSAGE | SSM_FILE_PATH_EVENT);
  1011.     SSM_LockResource(res);
  1012.     rv = SSM_SendQMessage(res->m_connection->m_controlOutQ,
  1013.                           20,
  1014.                           filePathRequest->type,
  1015.                           filePathRequest->len,
  1016.                           (char*)filePathRequest->data,
  1017.                           PR_TRUE);
  1018.     SECITEM_FreeItem(filePathRequest, PR_TRUE);
  1020.     SSM_WaitResource(res, PR_INTERVAL_NO_TIMEOUT);
  1021.     SSM_UnlockResource(res);
  1022.     return (res->m_fileName == NULL) ? SSM_FAILURE : SSM_SUCCESS;
  1023.     
  1024.  loser:
  1025.     if (filePathRequest != NULL) {
  1026.         SECITEM_FreeItem(filePathRequest, PR_TRUE);
  1027.     }
  1028.     return SSM_FAILURE;
  1029. }
  1031. void SSM_HandleFilePathReply(SSMControlConnection *ctrl, 
  1032.                              SECItem              *message)
  1033. {
  1034.   SSMStatus rv;
  1035.   SSMResource  *res;
  1036.   FilePathReply reply;
  1038.   if (CMT_DecodeMessage(FilePathReplyTemplate, &reply, (CMTItem*)message) != CMTSuccess) {
  1039.       return;
  1040.   }
  1042.   rv = SSMControlConnection_GetResource(ctrl, reply.resID, &res);
  1043.   if (rv != PR_SUCCESS || res == NULL) {
  1044.       return;
  1045.   }
  1046.   if (reply.filePath != NULL) {
  1047.     if (reply.filePath[0] == '') {
  1048.       res->m_fileName = NULL;
  1049.     } else {
  1050.       res->m_fileName = PL_strdup(reply.filePath);
  1051.     }
  1052.     PR_Free(reply.filePath);
  1053.   } else {
  1054.     res->m_fileName = NULL;
  1055.     res->m_buttonType = SSM_BUTTON_CANCEL;
  1056.   }
  1057.   SSM_LockResource(res);
  1058.   SSM_NotifyResource(res);
  1059.   SSM_UnlockResource(res);
  1060.   SSM_FreeResource(res);
  1061. }
  1063. void SSM_HandleUserPromptReply(SSMControlConnection *ctrl,
  1064.                                SECItem              *msg)
  1065. {
  1066.     SSMStatus rv;
  1067.     SSMResource *res;
  1068.     PromptReply reply;
  1070.     if (CMT_DecodeMessage(PromptReplyTemplate, &reply, (CMTItem*)msg) != CMTSuccess) {
  1071.         return;
  1072.     }
  1074.     rv = SSMControlConnection_GetResource(ctrl, reply.resID, &res);
  1075.     if (rv != PR_SUCCESS || res == NULL)  {
  1076.         return;
  1077.     }
  1079.     /* XXX sjlee: if the password length was zero, it would have been 
  1080.      * translated as a null pointer through transport.  We need to restore it 
  1081.      * to an empty string.  We can do that by looking up the cancel value of 
  1082.      * the reply.
  1083.      */
  1084.     if ((reply.promptReply == NULL) && !reply.cancel) {
  1085.         reply.promptReply = "";
  1086.     }
  1087.     SSM_HandlePromptReply(res, reply.promptReply);
  1088. }
  1090. #ifdef TIMEBOMB
  1092. SECItem * SSMTimebomb_GetMessage(SSMControlConnection * control)
  1093. {
  1094.   SECItem * message = NULL;
  1095.   PRInt32 read, type, len;
  1096.   char * buffer = NULL;
  1097.   SSMStatus rv = PR_FAILURE;
  1098.  
  1099.   buffer = (char *)PORT_ZAlloc(sizeof(type)+ sizeof(len));
  1100.   if (!buffer)
  1101.     goto loser;
  1103.   SSM_DEBUG("waiting for new message from socket.n");
  1104.   read = SSM_ReadThisMany(control->m_socket,(void *)buffer,sizeof(type)+sizeof(len));
  1105.   if (read != sizeof(type)+sizeof(len))
  1106.     {
  1107.      SSM_DEBUG("Bytes read (%ld) != bytes expected (%ld). (hdr)n",
  1108.                (long) read,
  1109.                (long) (sizeof(type)+sizeof(len)));
  1110.      rv = PR_FAILURE;
  1111.      goto loser;
  1112.     }
  1113.   message = SSM_ConstructMessage(PR_ntohl(((unsigned long *)buffer)[1]));
  1114.   if (!message || !message->data)
  1115.     {
  1116.       SSM_DEBUG("Missing %s.n",(!message) ? "message" : "message data");
  1117.       rv = PR_OUT_OF_MEMORY_ERROR;
  1118.       goto loser;
  1119.     }
  1120.   message->type = PR_ntohl(((unsigned long *)buffer)[0]);
  1121.   SSM_DEBUG("reading %ld more from socket.n", message->len);
  1122.   read = SSM_ReadThisMany(control->m_socket, (void *)message->data, message->len);
  1123.   if ((unsigned int) read != message->len)
  1124.     {
  1125.      SSM_DEBUG("Bytes read (%ld) != bytes expected (%ld). (msg)n",
  1126.                            (long) read,
  1127.                            (long) message->len);
  1128.      rv = PR_GetError();
  1129.      if (rv == PR_SUCCESS) rv = PR_FAILURE;
  1130.      goto loser;
  1131.    }
  1132.   if (buffer) 
  1133.     PR_Free(buffer);
  1134.   return message;
  1135. loser:
  1136.   if (buffer)
  1137.     PR_Free(buffer);
  1138.   return NULL;
  1139. }
  1142. SSMStatus SSMTimebomb_SendMessage(SSMControlConnection * control, 
  1143.                                  SECItem * message)
  1144. {
  1145.   PRInt32 tmp, sent;
  1147.   if (!message)
  1148.     goto loser;
  1149.   /* now send message.
  1150.    * I want to do it here to keep timebomb code close together -jane */
  1151.   tmp = PR_htonl(message->type);
  1152.   sent =  SSM_WriteThisMany(control->m_socket, &tmp, sizeof(tmp));
  1153.   if (sent != sizeof(tmp))
  1154.     goto loser;
  1155.   tmp = PR_htonl(message->len);
  1156.   sent =  SSM_WriteThisMany(control->m_socket, &tmp, sizeof(tmp));
  1157.   if (sent != sizeof(tmp))
  1158.     goto loser;
  1159.   sent = SSM_WriteThisMany(control->m_socket, message->data, message->len);
  1160.   if (sent != message->len)
  1161.     goto loser;
  1162.   return SSM_SUCCESS;
  1163. loser: 
  1164.   SSM_DEBUG("timebomb: can't send error message!n");
  1165.   return SSM_FAILURE;
  1166. }
  1167. #endif
  1169. void SSM_DestroyAttrValue(SSMAttributeValue *value, PRBool freeit)
  1170. {
  1171.     if ((value->type == SSM_STRING_ATTRIBUTE) && (value->u.string.data))
  1172.         PR_Free(value->u.string.data);
  1173.     value->type = (SSMResourceAttrType) 0;
  1174.     if (freeit)
  1175.         PR_Free(value);
  1176. }
  1178. CMTStatus SSM_SSMStringToString(char ** string,
  1179.        int *len, 
  1180.        SSMString * ssmString) 
  1181. {
  1182.   char * str = NULL;
  1183.   int realLen;
  1184.   CMTStatus rv = CMTSuccess;
  1186.   if (!ssmString || !string ) { 
  1187.     rv = (CMTStatus) PR_INVALID_ARGUMENT_ERROR;
  1188.     goto loser;
  1189.   }
  1191.   /* in case we fail */
  1192.   *string = NULL;
  1193.   if (len) *len = 0;
  1195.   /* Convert from net byte order */
  1196.   realLen = SSMPR_ntohl(ssmString->m_length);
  1198.   str = (char *)PR_CALLOC(realLen+1); /* add 1 byte for end 0 */
  1199.   if (!str) {
  1200.     rv = (CMTStatus) PR_OUT_OF_MEMORY_ERROR;
  1201.     goto loser;
  1202.   }
  1203.   
  1204.   memcpy(str, (char *) &(ssmString->m_data), realLen);
  1205.   /* str[realLen]=0; */
  1207.   if (len) *len = realLen;
  1208.   *string = str;
  1209.   return rv;
  1210.   
  1211. loser:
  1212.   if (str) 
  1213.     PR_Free(str);
  1214.   if (string && *string) {
  1215.     PR_Free(*string);
  1216.     *string = NULL;
  1217.   }
  1218.   if (rv == CMTSuccess) 
  1219.     rv = CMTFailure;
  1220.   return rv;
  1221. }
  1224. CMTStatus SSM_StringToSSMString(SSMString ** ssmString, int length, 
  1225.   char * string)
  1226. {
  1227.   SSMPRUint32 len;
  1228.   SSMString *result = NULL;
  1229.   CMTStatus rv = CMTSuccess;
  1230.   
  1231.   if (!string || !ssmString) {
  1232.     rv = (CMTStatus) PR_INVALID_ARGUMENT_ERROR;
  1233.     goto loser;
  1234.   }
  1236.   *ssmString = NULL; /* in case we fail */
  1238.   if (length) len = length; 
  1239.   else len = strlen(string);
  1240.   if (len <= 0) {
  1241.     rv = (CMTStatus) PR_INVALID_ARGUMENT_ERROR;
  1242.     goto loser;
  1243.   }
  1244.   result = (SSMString *) PR_CALLOC(sizeof(PRUint32) + 
  1245.    SSMSTRING_PADDED_LENGTH(len));
  1246.   if (!result) {
  1247.     rv = (CMTStatus) PR_OUT_OF_MEMORY_ERROR;
  1248.     goto loser;
  1249.   }
  1251.   result->m_length = SSMPR_htonl(len);
  1252.   memcpy((char *) (&(result->m_data)), string, len);
  1254.   *ssmString = result;
  1255.   goto done;
  1256.   
  1257. loser:
  1258.   if (result)
  1259.     PR_Free(result);
  1260.   *ssmString = NULL;
  1261.   if (rv == CMTSuccess)
  1262.     rv = CMTFailure;
  1263. done:
  1264.   return rv;
  1265. }
  1267. #ifdef XP_UNIX
  1268. void SSM_ReleaseLockFile()
  1269. {
  1270.   if (lockfile) {
  1271.     char filePath[64];
  1272.     
  1273.     GET_LOCK_FILE_PATH(filePath);
  1274.     SSM_DEBUG("Releasing and deleting the file %sn", filePath);
  1275.     PR_UnlockFile(lockfile);
  1276.     PR_Close(lockfile);
  1277.     lockfile = NULL;
  1278.     PR_Delete(filePath);
  1279.     GET_CONTROL_SOCK_PATH(filePath);
  1280.     SSM_DEBUG("Deleting %s. (The control connection socket)n", filePath);
  1281.     PR_Delete(filePath);
  1282.   }
  1283. }
  1284. #endif
  1286. int SSM_strncasecmp(const char *s1, const char *s2, size_t count)
  1287. {
  1288.     char *myS1 = NULL, *myS2 = NULL;
  1289.     int rv, len, i;
  1291.     myS1 = strdup(s1);
  1292.     myS2 = strdup(s2);
  1293.     len = strlen(myS1);
  1294.     for (i=0;i<len;i++) {
  1295.         myS1[i] = tolower(myS1[i]);
  1296.     }
  1297.     len = strlen(myS2);
  1298.     for (i=0;i<len;i++) {
  1299.         myS2[i] = tolower(myS2[i]);
  1300.     }
  1301.     rv = strncmp(myS1,myS2,count);
  1302.     free(myS1);
  1303.     free(myS2);
  1304.     return rv;
  1305. }