home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / nsprpub / pr / src / md / mac / macsockclient.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  12.7 KB  |  559 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /*
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  * 
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  * 
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. #include <errno.h>
  20.  
  21. #define OTUNIXERRORS 1        /* We want OpenTransport error codes */
  22. #include <OpenTransport.h>
  23. #include <OpenTptInternet.h>    // All the internet typedefs
  24.  
  25. #include "macsock.h" /* from macsock library */
  26. #include "primpl.h"
  27.  
  28. void _MD_InitNetAccess()
  29. {
  30. }
  31.  
  32. static void macsock_map_error(int err)
  33. {
  34.     switch (err) {
  35.         case EBADF:
  36.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  37.             break;
  38.         case EADDRNOTAVAIL:
  39.             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
  40.             break;
  41.         case EINPROGRESS:
  42.             PR_SetError(PR_IN_PROGRESS_ERROR, err);
  43.             break;
  44.         case EWOULDBLOCK:
  45.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  46.             break;
  47.         case ENOTSOCK:
  48.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  49.             break;
  50.         case EAFNOSUPPORT:
  51.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  52.             break;
  53.         case ETIMEDOUT:
  54.             PR_SetError(PR_IO_TIMEOUT_ERROR, err);
  55.             break;
  56.         case ECONNREFUSED:
  57.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  58.             break;
  59.         case ENETUNREACH:
  60.             PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
  61.             break;
  62.         case EADDRINUSE:
  63.             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
  64.             break;
  65.         case EFAULT:
  66.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  67.             break;
  68.         /*
  69.          * UNIX domain sockets are not supported in NSPR
  70.          */
  71.         case EACCES:
  72.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  73.             break;
  74.         case EINTR:
  75.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  76.             break;
  77.         case EINVAL:
  78.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  79.             break;
  80.         case EIO:
  81.             PR_SetError(PR_IO_ERROR, err);
  82.             break;
  83.         case ENOENT:
  84.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  85.             break;
  86.         case ENXIO:
  87.             PR_SetError(PR_IO_ERROR, err);
  88.             break;
  89.         case EPROTOTYPE:
  90.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  91.             break;
  92.         default:
  93.             PR_SetError(PR_UNKNOWN_ERROR, err);
  94.             break;
  95.     }
  96. }
  97.  
  98. // Errors returned:
  99. // ENETDOWN - no MacTCP driver
  100. // EPROTONOSUPPORT - bad socket type/protocol
  101. // ENOBUFS - not enough space for another socket, or failure in socket creation routine
  102. PRInt32 _MD_socket(int domain, int type, int protocol)
  103. {
  104.     int    err;
  105.     
  106.     err = macsock_socket(domain, type, protocol);
  107.     if (err == -1) {
  108.         macsock_map_error(errno);
  109.         return -1;
  110.      }
  111.      
  112.     return err;
  113. }
  114.  
  115. // Errors:
  116. // EBADF -- bad socket id
  117. // EFAULT -- bad address format
  118. PRInt32 _MD_bind(PRFileDesc *fd, PRNetAddr *addr, PRUint32 addrlen)
  119. {
  120.     int    err;
  121.     int sID = fd->secret->md.osfd;
  122.     
  123.     err = macsock_bind(sID, (const struct sockaddr *)addr, addrlen);
  124.     if (err == -1) {
  125.         macsock_map_error(errno);
  126.         return -1;
  127.      }
  128.      
  129.     return err;
  130. }    
  131.  
  132. // Errors:
  133. // EBADF -- bad socket id
  134. // EOPNOTSUPP -- socket is already connected, and closing
  135. // EISCONN -- already connected
  136. // EINPROGRESS -- connecting right now
  137. PRInt32 _MD_listen(PRFileDesc *fd, PRIntn backlog)
  138. {
  139.     int    err;
  140.     int sID = fd->secret->md.osfd;
  141.  
  142.     err = macsock_listen(sID, backlog);
  143.     if (err == -1) {
  144.         macsock_map_error(errno);
  145.         return -1;
  146.      }
  147.      
  148.     return err;
  149. }    
  150.  
  151. // Errors:
  152. // EBADF -- bad socket id
  153. PRInt32 _MD_getsockname(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen)
  154. {
  155.     int    err;
  156.     int sID = fd->secret->md.osfd;
  157.  
  158.     err = macsock_getsockname(sID, (struct sockaddr *)addr, (int *)addrlen);
  159.     if (err == -1) {
  160.         macsock_map_error(errno);
  161.         return -1;
  162.      }
  163.      
  164.     return err;
  165. }    
  166.  
  167. // Errors: 
  168. // EBADF - bad socket id
  169. // ENOPROTOOPT - The option is unknown
  170. PRStatus _MD_getsockopt(PRFileDesc *fd, PRInt32 level, PRInt32 optname, char* optval, PRInt32* optlen)
  171. {
  172.     int    err;
  173.     int sID = fd->secret->md.osfd;
  174.  
  175.     err = macsock_getsockopt(sID, level, optname, optval, optlen);
  176.     if (err == -1) {
  177.         macsock_map_error(errno);
  178.         return PR_FAILURE;
  179.      }
  180.      
  181.     return PR_SUCCESS;
  182. }
  183.  
  184. // Errors:
  185. // EBADF - bad socket id
  186. // ENOTCONN - socket hasnâ•’t been properly created 
  187. PRStatus _MD_setsockopt(PRFileDesc *fd, PRInt32 level, PRInt32 optname, const char* optval, PRInt32 optlen)
  188. {
  189.     int    err;
  190.     int sID = fd->secret->md.osfd;
  191.  
  192.     err = macsock_setsockopt(sID, level, optname, optval, optlen);
  193.     if (err == -1) {
  194.         macsock_map_error(errno);
  195.         return PR_FAILURE;
  196.      }
  197.      
  198.     return PR_SUCCESS;
  199. }
  200.  
  201. PRInt32 _MD_socketavailable(PRFileDesc *fd, size_t *bytes)
  202. {
  203.     int    err;
  204.     int sID = fd->secret->md.osfd;
  205.  
  206.     // Careful of the return value here.  0 => failure, 1 => success
  207.     err = macsock_socketavailable(sID, bytes);
  208.     if (err == 0) {
  209.         _PR_MD_CURRENT_THREAD()->md.osErrCode = -1;
  210.         return -1;
  211.      }
  212.      
  213.     return 0;
  214. }
  215.  
  216. PRInt32 _MD_accept(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout)
  217. {
  218. #pragma unused (timeout)
  219.  
  220.     int    err;
  221.     int sID = fd->secret->md.osfd;
  222.  
  223.     err = macsock_accept(sID, (struct sockaddr *)addr, (int *)addrlen);
  224.     if (err == -1) {
  225.         macsock_map_error(errno);
  226.         return -1;
  227.      }
  228.      
  229.     return err;
  230. }
  231.  
  232. // Connect
  233. // check the arguments validity
  234. // issue the connect call to the stream
  235. // Errors:
  236. //    EBADF -- bad socket id, bad MacTCP stream
  237. //    EAFNOSUPPORT -- bad address format
  238. //    EADDRINUSE -- we are listening, or duplicate socket
  239. //  EINPROGRESS -- we are connecting right now
  240. //  EISCONN -- already connected
  241. //  ECONNREFUSED -- other side has closed, or open has failed
  242. //  EALREADY -- we are connected
  243. //  EINTR -- user interrupted
  244. PRInt32 _MD_connect(PRFileDesc *fd, PRNetAddr *addr, PRUint32 addrlen, PRIntervalTime timeout)
  245. {
  246. #pragma unused (timeout)
  247.  
  248.     int    err;
  249.     int sID = fd->secret->md.osfd;
  250.  
  251.     err = macsock_connect(sID, (struct sockaddr *)addr, addrlen);
  252.     if (err == -1) {
  253.         macsock_map_error(errno);
  254.         return -1;
  255.      }
  256.      
  257.     return err;
  258. }
  259.  
  260. // Errors:
  261. // EBADF - bad socket ID
  262. // ENOTCONN - no such connection
  263. PRInt32 _MD_recv(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout)
  264. {
  265. #pragma unused (timeout)
  266.  
  267.     int    err;
  268.     int sID = fd->secret->md.osfd;
  269.  
  270.     err = macsock_recv(sID, buf, amount, flags);
  271.     if (err == -1) {
  272.         macsock_map_error(errno);
  273.         return -1;
  274.      }
  275.      
  276.     return err;
  277. }
  278.  
  279. PRInt32 _MD_send(PRFileDesc *fd,const void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout)
  280. {
  281. #pragma unused (timeout)
  282.  
  283.     int    err;
  284.     int sID = fd->secret->md.osfd;
  285.  
  286.     err = macsock_send(sID, buf, amount, flags);
  287.     if (err == -1) {
  288.         macsock_map_error(errno);
  289.         return -1;
  290.      }
  291.      
  292.     return err;
  293. }
  294.  
  295. PRInt32 _MD_recvfrom(PRFileDesc *fd, void *buf, PRInt32 amount, 
  296.                                PRIntn flags, PRNetAddr *addr, PRUint32 *addrlen,
  297.                                PRIntervalTime timeout)
  298. {
  299. #pragma unused (timeout)
  300.  
  301.     int    err;
  302.     int sID = fd->secret->md.osfd;
  303.  
  304.     err = macsock_recvfrom(sID, buf, amount, flags, (struct sockaddr *)addr, (int *)addrlen);
  305.     if (err == -1) {
  306.         macsock_map_error(errno);
  307.         return -1;
  308.      }
  309.      
  310.     return err;
  311. }
  312.  
  313.                                
  314. PRInt32 _MD_sendto(PRFileDesc *fd,const void *buf, PRInt32 amount, 
  315.                                PRIntn flags, PRNetAddr *addr, PRUint32 addrlen,
  316.                                PRIntervalTime timeout)
  317. {
  318. #pragma unused (timeout)
  319.  
  320.     int    err;
  321.     int sID = fd->secret->md.osfd;
  322.  
  323.     err = macsock_sendto(sID, buf, amount, flags, (struct sockaddr *)addr, addrlen);
  324.     if (err == -1) {
  325.         macsock_map_error(errno);
  326.         return -1;
  327.      }
  328.      
  329.     return err;
  330. }
  331.  
  332. // Errors:
  333. // EBADF -- bad socket id
  334. PRInt32 _MD_closesocket(PRInt32 osfd)
  335. {
  336.     int    err;
  337.     int sID = osfd;
  338.  
  339.     err = macsock_close(sID);
  340.     if (err == -1) {
  341.         macsock_map_error(errno);
  342.         return -1;
  343.      }
  344.      
  345.     return err;
  346. }
  347.  
  348. PRInt32 _MD_writev(PRFileDesc *fd, struct PRIOVec *iov, PRInt32 iov_size, PRIntervalTime timeout)
  349. {
  350. #pragma unused (fd, iov, iov_size, timeout)
  351.  
  352.     PR_ASSERT(0);
  353.     _PR_MD_CURRENT_THREAD()->md.osErrCode = unimpErr;
  354.     return -1;
  355. }                               
  356.  
  357. PRInt32 _MD_shutdown(PRFileDesc *fd, PRIntn how)
  358. {
  359.     int    err;
  360.     int sID = fd->secret->md.osfd;
  361.  
  362.     err = macsock_shutdown(sID, how);
  363.     if (err == -1) {
  364.         macsock_map_error(errno);
  365.         return -1;
  366.      }
  367.      
  368.     return err;
  369. }                               
  370.  
  371. PRStatus _MD_getpeername(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen)
  372. {
  373.     int    err;
  374.     int sID = fd->secret->md.osfd;
  375.  
  376.     err = macsock_getpeername(sID, (struct sockaddr *)addr, (int *)addrlen);
  377.     if (err == -1) {
  378.         macsock_map_error(errno);
  379.         return PR_FAILURE;
  380.      }
  381.      
  382.     return PR_SUCCESS;
  383. }
  384.  
  385. void _MD_makenonblock(PRFileDesc *fd)
  386. {
  387.     int    err;
  388.     int sID = fd->secret->md.osfd;
  389.     int optval =1;
  390.  
  391.     err = macsock_setsockopt(sID, SOL_SOCKET, FIONBIO, (const void *)&optval, 0);
  392.     if (err == -1) {
  393.         macsock_map_error(errno);
  394.      }
  395. }                               
  396.  
  397. struct hostent *gethostbyname(const char * name)
  398. {
  399.     return macsock_gethostbyname((char *)name);
  400. }
  401.  
  402. struct hostent *gethostbyaddr(const void *addr, int addrlen, int type)
  403. {
  404.     return macsock_gethostbyaddr(addr, addrlen, type);
  405. }
  406.  
  407. PRStatus _MD_gethostname(char *name, int namelen)
  408. {
  409.     int    err;
  410.  
  411.     err = macsock_gethostname(name, namelen);
  412.     if (err != noErr) {
  413.         macsock_map_error(err);
  414.         return PR_FAILURE;
  415.      }
  416.      
  417.     return PR_SUCCESS;
  418. }
  419.  
  420. #define kIPName        "ip"
  421. static struct protoent sIPProto = {kIPName, NULL, INET_IP};
  422. static struct protoent sTCPProto = {kTCPName, NULL, INET_TCP};
  423. static struct protoent sUDPProto = {kUDPName, NULL, INET_UDP};
  424.  
  425. struct protoent *getprotobyname(const char * name)
  426. {
  427.     if (strcmp(name, kIPName) == 0)
  428.         return (&sIPProto);
  429.         
  430.     if (strcmp(name, kTCPName) == 0)
  431.         return (&sTCPProto);
  432.         
  433.     if (strcmp(name, kUDPName) == 0)
  434.         return (&sUDPProto);
  435.         
  436. ErrorExit:
  437.     _PR_MD_CURRENT_THREAD()->md.osErrCode = paramErr;
  438.     return NULL;
  439. }
  440.  
  441.  
  442. struct protoent *getprotobynumber(int number)
  443. {
  444.     if (number == INET_IP)
  445.         return (&sIPProto);
  446.         
  447.     if (number == INET_TCP)
  448.         return (&sTCPProto);
  449.         
  450.     if (number == INET_UDP)
  451.         return (&sUDPProto);
  452.         
  453. ErrorExit:
  454.     _PR_MD_CURRENT_THREAD()->md.osErrCode = paramErr;
  455.     return NULL;
  456. }
  457.  
  458. PRInt32 _MD_poll(PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout)
  459. {
  460.     PRPollDesc *pd, *epd;
  461.     PRInt32 n;
  462.  
  463.     fd_set rd, wt, ex;
  464.     struct timeval tv, *tvp = NULL;
  465.     int maxfd = -1;
  466.  
  467.     FD_ZERO(&rd);
  468.     FD_ZERO(&wt);
  469.     FD_ZERO(&ex);
  470.  
  471.     for (pd = pds, epd = pd + npds; pd < epd; pd++) {
  472.         PRInt32 osfd;
  473.         PRInt16 in_flags = pd->in_flags;
  474.         PRFileDesc *bottom = pd->fd;
  475.  
  476.         if (NULL == bottom) {
  477.             continue;
  478.         }
  479.         while (bottom->lower != NULL) {
  480.             bottom = bottom->lower;
  481.         }
  482.         osfd = bottom->secret->md.osfd;
  483.  
  484.         if (osfd > maxfd) {
  485.             maxfd = osfd;
  486.         }
  487.         if (in_flags & PR_POLL_READ)  {
  488.             FD_SET(osfd, &rd);
  489.         }
  490.         if (in_flags & PR_POLL_WRITE) {
  491.             FD_SET(osfd, &wt);
  492.         }
  493.         if (in_flags & PR_POLL_EXCEPT) {
  494.             FD_SET(osfd, &ex);
  495.         }
  496.     }
  497.     if (timeout != PR_INTERVAL_NO_TIMEOUT) {
  498.         tv.tv_sec = PR_IntervalToSeconds(timeout);
  499.         tv.tv_usec = PR_IntervalToMicroseconds(timeout) % PR_USEC_PER_SEC;
  500.         tvp = &tv;
  501.     }
  502.     
  503.     n = select(maxfd + 1, &rd, &wt, &ex, tvp);
  504.     
  505.     if (n > 0) {
  506.         n = 0;
  507.         for (pd = pds, epd = pd + npds; pd < epd; pd++) {
  508.             PRInt32 osfd;
  509.             PRInt16 in_flags = pd->in_flags;
  510.             PRInt16 out_flags = 0;
  511.             PRFileDesc *bottom = pd->fd;
  512.  
  513.             if (NULL == bottom) {
  514.                 continue;
  515.             }
  516.             while (bottom->lower != NULL) {
  517.                 bottom = bottom->lower;
  518.             }
  519.             osfd = bottom->secret->md.osfd;
  520.  
  521.             if ((in_flags & PR_POLL_READ) && FD_ISSET(osfd, &rd))  {
  522.                 out_flags |= PR_POLL_READ;
  523.             }
  524.             if ((in_flags & PR_POLL_WRITE) && FD_ISSET(osfd, &wt)) {
  525.                 out_flags |= PR_POLL_WRITE;
  526.             }
  527.             if ((in_flags & PR_POLL_EXCEPT) && FD_ISSET(osfd, &ex)) {
  528.                 out_flags |= PR_POLL_EXCEPT;
  529.             }
  530.             pd->out_flags = out_flags;
  531.             if (out_flags) {
  532.                 n++;
  533.             }
  534.         }
  535.         /* 
  536.         Can't do this assert because MacSock returns write fds even if we did not
  537.         set it in the original write fd set.
  538.         */
  539.         /*PR_ASSERT(n > 0);*/
  540.     } else 
  541.         PR_ASSERT(n == 0);
  542.  
  543.     return n;
  544. }
  545.  
  546. int _MD_mac_get_nonblocking_connect_error(int osfd)
  547. {
  548.     int    err;
  549.  
  550.     err = macsock_getconnectstatus (osfd);
  551.     if (err == -1) {
  552.         macsock_map_error(errno);
  553.         return -1;
  554.      }
  555.           
  556.     return err;
  557. }
  558.  
  559.