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

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

CA认证

开发平台：

WINDOWS

server.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.  *  SSL server program listens on a port, accepts client connection, reads  *
  36.  *  request and responds to it                                              *
  37.  ****************************************************************************/
  39. /* Generic header files */
  41. #include <stdio.h>
  42. #include <string.h>
  44. /* NSPR header files */
  46. #include "nspr.h"
  47. #include "plgetopt.h"
  48. #include "prerror.h"
  49. #include "prnetdb.h"
  51. /* NSS header files */
  53. #include "pk11func.h"
  54. #include "secitem.h"
  55. #include "ssl.h"
  56. #include "certt.h"
  57. #include "nss.h"
  58. #include "secrng.h"
  59. #include "secder.h"
  60. #include "key.h"
  61. #include "sslproto.h"
  63. /* Custom header files */
  65. #include "sslsample.h"
  67. #ifndef PORT_Sprintf
  68. #define PORT_Sprintf sprintf
  69. #endif
  71. #define REQUEST_CERT_ONCE 1
  72. #define REQUIRE_CERT_ONCE 2
  73. #define REQUEST_CERT_ALL  3
  74. #define REQUIRE_CERT_ALL  4
  76. /* Global variables */
  77. GlobalThreadMgr   threadMGR;
  78. char             *password = NULL;
  79. CERTCertificate  *cert = NULL;
  80. SECKEYPrivateKey *privKey = NULL;
  81. int               stopping;
  83. static void
  84. Usage(const char *progName)
  85. {
  86. fprintf(stderr, 
  88. "Usage: %s -n rsa_nickname -p port [-3RFrf] [-w password]n"
  89. " [-c ciphers] [-d dbdir] n"
  90. "-3 means disable SSL v3n"
  91. "-r means request certificate on first handshake.n"
  92. "-f means require certificate on first handshake.n"
  93. "-R means request certificate on all handshakes.n"
  94. "-F means require certificate on all handshakes.n"
  95. "-c ciphers   Letter(s) chosen from the following listn"
  96. "A   SSL2 RC4 128 WITH MD5n"
  97. "B   SSL2 RC4 128 EXPORT40 WITH MD5n"
  98. "C   SSL2 RC2 128 CBC WITH MD5n"
  99. "D   SSL2 RC2 128 CBC EXPORT40 WITH MD5n"
  100. "E   SSL2 DES 64 CBC WITH MD5n"
  101. "F   SSL2 DES 192 EDE3 CBC WITH MD5n"
  102. "n"
  103. "a   SSL3 FORTEZZA DMS WITH FORTEZZA CBC SHAn"
  104. "b   SSL3 FORTEZZA DMS WITH RC4 128 SHAn"
  105. "c   SSL3 RSA WITH RC4 128 MD5n"
  106. "d   SSL3 RSA WITH 3DES EDE CBC SHAn"
  107. "e   SSL3 RSA WITH DES CBC SHAn"
  108. "f   SSL3 RSA EXPORT WITH RC4 40 MD5n"
  109. "g   SSL3 RSA EXPORT WITH RC2 CBC 40 MD5n"
  110. "h   SSL3 FORTEZZA DMS WITH NULL SHAn"
  111. "i   SSL3 RSA WITH NULL MD5n"
  112. "j   SSL3 RSA FIPS WITH 3DES EDE CBC SHAn"
  113. "k   SSL3 RSA FIPS WITH DES CBC SHAn"
  114. "l   SSL3 RSA EXPORT WITH DES CBC SHAt(new)n"
  115. "m   SSL3 RSA EXPORT WITH RC4 56 SHAt(new)n",
  116. progName);
  117. exit(1);
  118. }
  120. /* Function:  readDataFromSocket()
  121.  *
  122.  * Purpose:  Parse an HTTP request by reading data from a GET or POST.
  123.  *
  124.  */
  125. SECStatus
  126. readDataFromSocket(PRFileDesc *sslSocket, DataBuffer *buffer, char **fileName)
  127. {
  128. char  *post;
  129. int    numBytes = 0;
  130. int    newln    = 0;  /* # of consecutive newlns */
  132. /* Read data while it comes in from the socket. */
  133. while (PR_TRUE) {
  134. buffer->index = 0;
  135. newln = 0;
  137. /* Read the buffer. */
  138. numBytes = PR_Read(sslSocket, &buffer->data[buffer->index], 
  139.                    buffer->remaining);
  140. if (numBytes <= 0) {
  141. errWarn("PR_Read");
  142. return SECFailure;
  143. }
  144. buffer->dataEnd = buffer->dataStart + numBytes;
  146. /* Parse the input, starting at the beginning of the buffer.
  147.  * Stop when we detect two consecutive n's (or rn's) 
  148.  * as this signifies the end of the GET or POST portion.
  149.  * The posted data follows.
  150.  */
  151. while (buffer->index < buffer->dataEnd && newln < 2) {
  152. int octet = buffer->data[buffer->index++];
  153. if (octet == 'n') {
  154. newln++;
  155. } else if (octet != 'r') {
  156. newln = 0;
  157. }
  158. }
  160. /* Came to the end of the buffer, or second newline.
  161.  * If we didn't get an empty line ("rnrn"), then keep on reading.
  162.  */
  163. if (newln < 2) 
  164. continue;
  166. /* we're at the end of the HTTP request.
  167.  * If the request is a POST, then there will be one more
  168.  * line of data.
  169.  * This parsing is a hack, but ok for SSL test purposes.
  170.  */
  171. post = PORT_Strstr(buffer->data, "POST ");
  172. if (!post || *post != 'P') 
  173. break;
  175. /* It's a post, so look for the next and final CR/LF. */
  176. /* We should parse content length here, but ... */
  177. while (buffer->index < buffer->dataEnd && newln < 3) {
  178. int octet = buffer->data[buffer->index++];
  179. if (octet == 'n') {
  180. newln++;
  181. }
  182. }
  184. if (newln == 3)
  185. break;
  186. }
  188. /* Have either (a) a complete get, (b) a complete post, (c) EOF */
  190. /*  Execute a "GET " operation. */
  191. if (buffer->index > 0 && PORT_Strncmp(buffer->data, "GET ", 4) == 0) {
  192. int fnLength;
  194. /* File name is the part after "GET ". */
  195. fnLength = strcspn(buffer->data + 5, " rn");
  196. *fileName = (char *)PORT_Alloc(fnLength + 1);
  197. PORT_Strncpy(*fileName, buffer->data + 5, fnLength);
  198. (*fileName)[fnLength] = '';
  199. }
  201. return SECSuccess;
  202. }
  204. /* Function:  authenticateSocket()
  205.  *
  206.  * Purpose:  Configure a socket for SSL.
  207.  *
  208.  *
  209.  */
  210. PRFileDesc * 
  211. setupSSLSocket(PRFileDesc *tcpSocket, int requestCert)
  212. {
  213. PRFileDesc *sslSocket;
  214. SSLKEAType  certKEA;
  215. int         certErr = 0;
  216. SECStatus   secStatus;
  218. /* Set the appropriate flags. */
  220. sslSocket = SSL_ImportFD(NULL, tcpSocket);
  221. if (sslSocket == NULL) {
  222. errWarn("SSL_ImportFD");
  223. goto loser;
  224. }
  225.    
  226. secStatus = SSL_Enable(sslSocket, SSL_SECURITY, PR_TRUE);
  227. if (secStatus != SECSuccess) {
  228. errWarn("SSL_Enable SSL_SECURITY");
  229. goto loser;
  230. }
  232. secStatus = SSL_Enable(sslSocket, SSL_HANDSHAKE_AS_SERVER, PR_TRUE);
  233. if (secStatus != SECSuccess) {
  234. errWarn("SSL_Enable:SSL_HANDSHAKE_AS_SERVER");
  235. goto loser;
  236. }
  238. secStatus = SSL_Enable(sslSocket, SSL_REQUEST_CERTIFICATE, 
  239.                        (requestCert >= REQUEST_CERT_ONCE));
  240. if (secStatus != SECSuccess) {
  241. errWarn("SSL_Enable:SSL_REQUEST_CERTIFICATE");
  242. goto loser;
  243. }
  245. secStatus = SSL_Enable(sslSocket, SSL_REQUIRE_CERTIFICATE, 
  246.                        (requestCert == REQUIRE_CERT_ONCE));
  247. if (secStatus != SECSuccess) {
  248. errWarn("SSL_Enable:SSL_REQUIRE_CERTIFICATE");
  249. goto loser;
  250. }
  252. /* Set the appropriate callback routines. */
  254. secStatus = SSL_AuthCertificateHook(sslSocket, myAuthCertificate, 
  255.                                     CERT_GetDefaultCertDB());
  256. if (secStatus != SECSuccess) {
  257. errWarn("SSL_AuthCertificateHook");
  258. goto loser;
  259. }
  261. secStatus = SSL_BadCertHook(sslSocket, 
  262.                             (SSLBadCertHandler)myBadCertHandler, &certErr);
  263. if (secStatus != SECSuccess) {
  264. errWarn("SSL_BadCertHook");
  265. goto loser;
  266. }
  268. secStatus = SSL_HandshakeCallback(sslSocket,
  269.                                  (SSLHandshakeCallback)myHandshakeCallback,
  270.   NULL);
  271. if (secStatus != SECSuccess) {
  272. errWarn("SSL_HandshakeCallback");
  273. goto loser;
  274. }
  276. secStatus = SSL_SetPKCS11PinArg(sslSocket, password);
  277. if (secStatus != SECSuccess) {
  278. errWarn("SSL_HandshakeCallback");
  279. goto loser;
  280. }
  282. certKEA = NSS_FindCertKEAType(cert);
  284. secStatus = SSL_ConfigSecureServer(sslSocket, cert, privKey, certKEA);
  285. if (secStatus != SECSuccess) {
  286. errWarn("SSL_ConfigSecureServer");
  287. goto loser;
  288. }
  290. return sslSocket;
  292. loser:
  294. PR_Close(tcpSocket);
  295. return NULL;
  296. }
  298. /* Function:  authenticateSocket()
  299.  *
  300.  * Purpose:  Perform client authentication on the socket.
  301.  *
  302.  */
  303. SECStatus
  304. authenticateSocket(PRFileDesc *sslSocket, PRBool requireCert)
  305. {
  306. CERTCertificate *cert;
  307. SECStatus secStatus;
  309. /* Returns NULL if client authentication is not enabled or if the
  310.  * client had no certificate. */
  311. cert = SSL_PeerCertificate(sslSocket);
  312. if (cert) {
  313. /* Client had a certificate, so authentication is through. */
  314. CERT_DestroyCertificate(cert);
  315. return SECSuccess;
  316. }
  318. /* Request client to authenticate itself. */
  319. secStatus = SSL_Enable(sslSocket, SSL_REQUEST_CERTIFICATE, PR_TRUE);
  320. if (secStatus != SECSuccess) {
  321. errWarn("SSL_Enable:SSL_REQUEST_CERTIFICATE");
  322. return SECFailure;
  323. }
  325. /* If desired, require client to authenticate itself.  Note
  326.  * SSL_REQUEST_CERTIFICATE must also be on, as above.  */
  327. secStatus = SSL_Enable(sslSocket, SSL_REQUIRE_CERTIFICATE, requireCert);
  328. if (secStatus != SECSuccess) {
  329. errWarn("SSL_Enable:SSL_REQUIRE_CERTIFICATE");
  330. return SECFailure;
  331. }
  333. /* Having changed socket configuration parameters, redo handshake. */
  334. secStatus = SSL_RedoHandshake(sslSocket);
  335. if (secStatus != SECSuccess) {
  336. errWarn("SSL_RedoHandshake");
  337. return SECFailure;
  338. }
  340. /* Force the handshake to complete before moving on. */
  341. secStatus = SSL_ForceHandshake(sslSocket);
  342. if (secStatus != SECSuccess) {
  343. errWarn("SSL_ForceHandshake");
  344. return SECFailure;
  345. }
  347. return SECSuccess;
  348. }
  350. /* Function:  writeDataToSocket
  351.  *
  352.  * Purpose:  Write the client's request back to the socket.  If the client
  353.  *           requested a file, dump it to the socket.
  354.  *
  355.  */
  356. SECStatus
  357. writeDataToSocket(PRFileDesc *sslSocket, DataBuffer *buffer, char *fileName)
  358. {
  359. int headerLength;
  360. int numBytes;
  361. char messageBuffer[120];
  362. PRFileDesc *local_file_fd = NULL;
  363. char header[] = "<html><body><h1>Sample SSL server</h1><br><br>";
  364. char filehd[] = "<h2>The file you requested:</h2><br>";
  365. char reqhd[]  = "<h2>This is your request:</h2><br>";
  366. char link[]   = "Try getting a <a HREF="../testfile">file</a><br>";
  367. char footer[] = "<br><h2>End of request.</h2><br></body></html>";
  369. headerLength = PORT_Strlen(defaultHeader);
  371. /* Write a header to the socket. */
  372. numBytes = PR_Write(sslSocket, header, PORT_Strlen(header));
  373. if (numBytes < 0) {
  374. errWarn("PR_Write");
  375. goto loser;
  376. }
  378. if (fileName) {
  379. PRFileInfo  info;
  380. PRStatus    prStatus;
  382. /* Try to open the local file named.
  383.  * If successful, then write it to the client.
  384.  */
  385. prStatus = PR_GetFileInfo(fileName, &info);
  386. if (prStatus != PR_SUCCESS ||
  387.     info.type != PR_FILE_FILE ||
  388.     info.size < 0) {
  389. PORT_Free(fileName);
  390. /* Maybe a GET not sent from client.c? */
  391. goto writerequest;
  392. return SECSuccess;
  393. }
  395. local_file_fd = PR_Open(fileName, PR_RDONLY, 0);
  396. if (local_file_fd == NULL) {
  397. PORT_Free(fileName);
  398. goto writerequest;
  399. }
  401. /* Write a header to the socket. */
  402. numBytes = PR_Write(sslSocket, filehd, PORT_Strlen(filehd));
  403. if (numBytes < 0) {
  404. errWarn("PR_Write");
  405. goto loser;
  406. }
  408. /* Transmit the local file prepended by the default header
  409.  * across the socket.
  410.  */
  411. numBytes = PR_TransmitFile(sslSocket, local_file_fd, 
  412.                            defaultHeader, headerLength,
  413.                            PR_TRANSMITFILE_KEEP_OPEN,
  414.                            PR_INTERVAL_NO_TIMEOUT);
  416. /* Error in transmission. */
  417. if (numBytes < 0) {
  418. errWarn("PR_TransmitFile");
  419. /*
  420. i = PORT_Strlen(errString);
  421. PORT_Memcpy(buf, errString, i);
  422. */
  423. /* Transmitted bytes successfully. */
  424. } else {
  425. numBytes -= headerLength;
  426. fprintf(stderr, "PR_TransmitFile wrote %d bytes from %sn",
  427.         numBytes, fileName);
  428. }
  430. PORT_Free(fileName);
  431. PR_Close(local_file_fd);
  432. }
  434. writerequest:
  436. /* Write a header to the socket. */
  437. numBytes = PR_Write(sslSocket, reqhd, PORT_Strlen(reqhd));
  438. if (numBytes < 0) {
  439. errWarn("PR_Write");
  440. goto loser;
  441. }
  443. /* Write the buffer data to the socket. */
  444. if (buffer->index <= 0) {
  445. /* Reached the EOF.  Report incomplete transaction to socket. */
  446. PORT_Sprintf(messageBuffer,
  447.              "GET or POST incomplete after %d bytes.rn",
  448.              buffer->dataEnd);
  449. numBytes = PR_Write(sslSocket, messageBuffer, 
  450.                     PORT_Strlen(messageBuffer));
  451. if (numBytes < 0) {
  452. errWarn("PR_Write");
  453. goto loser;
  454. }
  455. } else {
  456. /* Display the buffer data. */
  457. fwrite(buffer->data, 1, buffer->index, stdout);
  458. /* Write the buffer data to the socket. */
  459. numBytes = PR_Write(sslSocket, buffer->data, buffer->index);
  460. if (numBytes < 0) {
  461. errWarn("PR_Write");
  462. goto loser;
  463. }
  464. /* Display security information for the socket. */
  465. printSecurityInfo(sslSocket);
  466. /* Write any discarded data out to the socket. */
  467. if (buffer->index < buffer->dataEnd) {
  468. PORT_Sprintf(buffer->data, "Discarded %d characters.rn", 
  469.              buffer->dataEnd - buffer->index);
  470. numBytes = PR_Write(sslSocket, buffer->data, 
  471.                     PORT_Strlen(buffer->data));
  472. if (numBytes < 0) {
  473. errWarn("PR_Write");
  474. goto loser;
  475. }
  476. }
  477. }
  479. /* Write a footer to the socket. */
  480. numBytes = PR_Write(sslSocket, footer, PORT_Strlen(footer));
  481. if (numBytes < 0) {
  482. errWarn("PR_Write");
  483. goto loser;
  484. }
  486. /* Write a link to the socket. */
  487. numBytes = PR_Write(sslSocket, link, PORT_Strlen(link));
  488. if (numBytes < 0) {
  489. errWarn("PR_Write");
  490. goto loser;
  491. }
  493. /* Complete the HTTP transaction. */
  494. numBytes = PR_Write(sslSocket, "EOFrnrnrn", 9);
  495. if (numBytes < 0) {
  496. errWarn("PR_Write");
  497. goto loser;
  498. }
  500. /* Do a nice shutdown if asked. */
  501. if (!strncmp(buffer->data, stopCmd, strlen(stopCmd))) {
  502. stopping = 1;
  503. }
  504. return SECSuccess;
  506. loser:
  508. /* Do a nice shutdown if asked. */
  509. if (!strncmp(buffer->data, stopCmd, strlen(stopCmd))) {
  510. stopping = 1;
  511. }
  512. return SECFailure;
  513. }
  515. /* Function:  int handle_connection()
  516.  *
  517.  * Purpose:  Thread to handle a connection to a socket.
  518.  *
  519.  */
  520. SECStatus
  521. handle_connection(void *tcp_sock, int requestCert)
  522. {
  523. PRFileDesc *       tcpSocket = (PRFileDesc *)tcp_sock;
  524. PRFileDesc *       sslSocket = NULL;
  525. SECStatus          secStatus = SECFailure;
  526. PRStatus           prStatus;
  527. PRSocketOptionData socketOption;
  528. DataBuffer         buffer;
  529. char *             fileName = NULL;
  531. /* Initialize the data buffer. */
  532. memset(buffer.data, 0, BUFFER_SIZE);
  533. buffer.remaining = BUFFER_SIZE;
  534. buffer.index = 0;
  535. buffer.dataStart = 0;
  536. buffer.dataEnd = 0;
  538. /* Make sure the socket is blocking. */
  539. socketOption.option             = PR_SockOpt_Nonblocking;
  540. socketOption.value.non_blocking = PR_FALSE;
  541. PR_SetSocketOption(tcpSocket, &socketOption);
  543. sslSocket = setupSSLSocket(tcpSocket, requestCert);
  544. if (sslSocket == NULL) {
  545. errWarn("setupSSLSocket");
  546. goto cleanup;
  547. }
  549. secStatus = SSL_ResetHandshake(sslSocket, /* asServer */ PR_TRUE);
  550. if (secStatus != SECSuccess) {
  551. errWarn("SSL_ResetHandshake");
  552. goto cleanup;
  553. }
  555. /* Read data from the socket, parse it for HTTP content.
  556.  * If the user is requesting/requiring authentication, authenticate
  557.  * the socket.  Then write the result back to the socket.  */
  558. fprintf(stdout, "nReading data from socket...nn");
  559. secStatus = readDataFromSocket(sslSocket, &buffer, &fileName);
  560. if (secStatus != SECSuccess) {
  561. goto cleanup;
  562. }
  563. if (requestCert >= REQUEST_CERT_ALL) {
  564. fprintf(stdout, "nAuthentication requested.nn");
  565. secStatus = authenticateSocket(sslSocket, 
  566.                                (requestCert == REQUIRE_CERT_ALL));
  567. if (secStatus != SECSuccess) {
  568. goto cleanup;
  569. }
  570. }
  572. fprintf(stdout, "nWriting data to socket...nn");
  573. secStatus = writeDataToSocket(sslSocket, &buffer, fileName);
  575. cleanup:
  577. /* Close down the socket. */
  578. prStatus = PR_Close(tcpSocket);
  579. if (prStatus != PR_SUCCESS) {
  580. errWarn("PR_Close");
  581. }
  583. return secStatus;
  584. }
  586. /* Function:  int accept_connection()
  587.  *
  588.  * Purpose:  Thread to accept a connection to the socket.
  589.  *
  590.  */
  591. SECStatus
  592. accept_connection(void *listener, int requestCert)
  593. {
  594. PRFileDesc *listenSocket = (PRFileDesc*)listener;
  595. PRNetAddr   addr;
  596. PRStatus    prStatus;
  598. /* XXX need an SSL socket here? */
  599. while (!stopping) {
  600. PRFileDesc *tcpSocket;
  601. SECStatus result;
  603. fprintf(stderr, "nnnAbout to call accept.n");
  605. /* Accept a connection to the socket. */
  606. tcpSocket = PR_Accept(listenSocket, &addr, PR_INTERVAL_NO_TIMEOUT);
  607. if (tcpSocket == NULL) {
  608. errWarn("PR_Accept");
  609. break;
  610. }
  612. /* Accepted the connection, now handle it. */
  613. result = launch_thread(&threadMGR, handle_connection, 
  614.                        tcpSocket, requestCert);
  616. if (result != SECSuccess) {
  617. prStatus = PR_Close(tcpSocket);
  618. if (prStatus != PR_SUCCESS) {
  619. exitErr("PR_Close");
  620. }
  621. break;
  622. }
  623. }
  625. fprintf(stderr, "Closing listen socket.n");
  627. prStatus = PR_Close(listenSocket);
  628. if (prStatus != PR_SUCCESS) {
  629. exitErr("PR_Close");
  630. }
  631. return SECSuccess;
  632. }
  634. /* Function:  void server_main()
  635.  *
  636.  * Purpose:  This is the server's main function.  It configures a socket
  637.  *  and listens to it.
  638.  *
  639.  */
  640. void
  641. server_main(
  642. unsigned short      port, 
  643. int                 requestCert, 
  644. SECKEYPrivateKey *  privKey,
  645. CERTCertificate *   cert, 
  646. PRBool              disableSSL3)
  647. {
  648. SECStatus           secStatus;
  649. PRStatus            prStatus;
  650. PRFileDesc *        listenSocket;
  651. PRNetAddr           addr;
  652. PRSocketOptionData  socketOption;
  654. /* Create a new socket. */
  655. listenSocket = PR_NewTCPSocket();
  656. if (listenSocket == NULL) {
  657. exitErr("PR_NewTCPSocket");
  658. }
  660. /* Set socket to be blocking -
  661.  * on some platforms the default is nonblocking.
  662.  */
  663. socketOption.option = PR_SockOpt_Nonblocking;
  664. socketOption.value.non_blocking = PR_FALSE;
  666. prStatus = PR_SetSocketOption(listenSocket, &socketOption);
  667. if (prStatus != PR_SUCCESS) {
  668. exitErr("PR_SetSocketOption");
  669. }
  671. /* This cipher is not on by default. The Acceptance test
  672.  * would like it to be. Turn this cipher on.
  673.  */
  674. secStatus = SSL_EnableCipher(SSL_RSA_WITH_NULL_MD5, PR_TRUE);
  675. if (secStatus != SECSuccess) {
  676. exitErr("SSL_EnableCipher:SSL_RSA_WITH_NULL_MD5");
  677. }
  679. /* Configure the network connection. */
  680. addr.inet.family = PR_AF_INET;
  681. addr.inet.ip  = PR_INADDR_ANY;
  682. addr.inet.port  = PR_htons(port);
  684. /* Bind the address to the listener socket. */
  685. prStatus = PR_Bind(listenSocket, &addr);
  686. if (prStatus != PR_SUCCESS) {
  687. exitErr("PR_Bind");
  688. }
  690. /* Listen for connection on the socket.  The second argument is
  691.  * the maximum size of the queue for pending connections.
  692.  */
  693. prStatus = PR_Listen(listenSocket, 5);
  694. if (prStatus != PR_SUCCESS) {
  695. exitErr("PR_Listen");
  696. }
  698. /* Launch thread to handle connections to the socket. */
  699. secStatus = launch_thread(&threadMGR, accept_connection, 
  700.                               listenSocket, requestCert);
  701. if (secStatus != SECSuccess) {
  702. PR_Close(listenSocket);
  703. } else {
  704. reap_threads(&threadMGR);
  705. destroy_thread_data(&threadMGR);
  706. }
  707. }
  709. /* Function: int main()
  710.  *
  711.  * Purpose:  Parses command arguments and configures SSL server.
  712.  *
  713.  */
  714. int
  715. main(int argc, char **argv)
  716. {
  717. char *              progName      = NULL;
  718. char *              nickName      = NULL;
  719. char *              cipherString  = NULL;
  720. char *              dir           = ".";
  721. int                 requestCert   = 0;
  722. unsigned short      port          = 0;
  723. SECStatus           secStatus;
  724. PRBool              disableSSL3   = PR_FALSE;
  725. PLOptState *        optstate;
  726. PLOptStatus         status;
  728. /* Zero out the thread manager. */
  729. PORT_Memset(&threadMGR, 0, sizeof(threadMGR));
  731. progName = PL_strdup(argv[0]);
  733. optstate = PL_CreateOptState(argc, argv, "3FRc:d:fp:n:rw:");
  734. while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
  735. switch(optstate->option) {
  736. case '3': disableSSL3 = PR_TRUE;                      break;
  737. case 'F': requestCert = REQUIRE_CERT_ALL;             break;
  738. case 'R': requestCert = REQUEST_CERT_ALL;             break;
  739. case 'c': cipherString = PL_strdup(optstate->value);  break;
  740. case 'd': dir = PL_strdup(optstate->value);           break;
  741. case 'f': requestCert = REQUIRE_CERT_ONCE;            break;
  742. case 'n': nickName = PL_strdup(optstate->value);      break;
  743. case 'p': port = PORT_Atoi(optstate->value);          break;
  744. case 'r': requestCert = REQUEST_CERT_ONCE;            break;
  745. case 'w': password = PL_strdup(optstate->value);      break;
  746. default:
  747. case '?': Usage(progName);
  748. }
  749. }
  751. if (nickName == NULL || port == 0)
  752. Usage(progName);
  754. /* Call the NSPR initialization routines. */
  755. PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  757. /* Set the cert database password callback. */
  758. PK11_SetPasswordFunc(myPasswd);
  760. /* Initialize NSS. */
  761. secStatus = NSS_Init(dir);
  762. if (secStatus != SECSuccess) {
  763. exitErr("NSS_Init");
  764. }
  766. /* Set the policy for this server (REQUIRED - no default). */
  767. secStatus = NSS_SetDomesticPolicy();
  768. if (secStatus != SECSuccess) {
  769. exitErr("NSS_SetDomesticPolicy");
  770. }
  772. /* XXX keep this? */
  773. /* all the SSL2 and SSL3 cipher suites are enabled by default. */
  774. if (cipherString) {
  775. int ndx;
  777. /* disable all the ciphers, then enable the ones we want. */
  778. disableSSL2Ciphers();
  779. disableSSL3Ciphers();
  781. while (0 != (ndx = *cipherString++)) {
  782. int *cptr;
  783. int  cipher;
  785. if (! isalpha(ndx))
  786. Usage(progName);
  787. cptr = islower(ndx) ? ssl3CipherSuites : ssl2CipherSuites;
  788. for (ndx &= 0x1f; (cipher = *cptr++) != 0 && --ndx > 0; ) 
  789. /* do nothing */;
  790. if (cipher) {
  791. SECStatus status;
  792. status = SSL_CipherPrefSetDefault(cipher, SSL_ALLOWED);
  793. if (status != SECSuccess) 
  794. errWarn("SSL_CipherPrefSetDefault()");
  795. }
  796. }
  797. }
  799. /* Get own certificate and private key. */
  800. cert = PK11_FindCertFromNickname(nickName, password);
  801. if (cert == NULL) {
  802. exitErr("PK11_FindCertFromNickname");
  803. }
  805. privKey = PK11_FindKeyByAnyCert(cert, password);
  806. if (privKey == NULL) {
  807. exitErr("PK11_FindKeyByAnyCert");
  808. }
  810. /* Configure the server's cache for a multi-process application
  811.  * using default timeout values (24 hrs) and directory location (/tmp). 
  812.  */
  813. SSL_ConfigMPServerSIDCache(256, 0, 0, NULL);
  815. /* Launch server. */
  816. server_main(port, requestCert, privKey, cert, disableSSL3);
  818. /* Shutdown NSS and exit NSPR gracefully. */
  819. NSS_Shutdown();
  820. PR_Cleanup();
  821. return 0;
  822. }