-const char jbsockets_rcs[] = "$Id: jbsockets.c,v 1.22 2002/03/04 02:08:02 david__schmidt Exp $";
+const char jbsockets_rcs[] = "$Id: jbsockets.c,v 1.24 2002/03/07 03:51:36 oes Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jbsockets.c,v $
*
* Revisions :
* $Log: jbsockets.c,v $
+ * Revision 1.24 2002/03/07 03:51:36 oes
+ * - Improved handling of failed DNS lookups
+ * - Fixed compiler warnings etc
+ *
+ * Revision 1.23 2002/03/05 00:36:01 jongfoster
+ * Fixing bug 514988 - unable to restart JunkBuster
+ *
* Revision 1.22 2002/03/04 02:08:02 david__schmidt
* Enable web editing of actions file on OS/2 (it had been broken all this time!)
*
* 3 : csp = Current client state (buffers, headers, etc...)
* Not modified, only used for source IP and ACL.
*
- * Returns : -1 => failure, else it is the socket file descriptor.
+ * Returns : JB_INVALID_SOCKET => failure, else it is the socket
+ * file descriptor.
*
*********************************************************************/
-int connect_to(const char *host, int portnum, struct client_state *csp)
+jb_socket connect_to(const char *host, int portnum, struct client_state *csp)
{
struct sockaddr_in inaddr;
- int fd, addr;
+ jb_socket fd;
+ int addr;
fd_set wfds;
struct timeval tv[1];
#if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
memset((char *)&inaddr, 0, sizeof inaddr);
- if ((addr = resolve_hostname_to_ip(host)) == -1)
+ if ((addr = resolve_hostname_to_ip(host)) == INADDR_NONE)
{
csp->http->host_ip_addr_str = strdup("unknown");
- return(-1);
+ return(JB_INVALID_SOCKET);
}
#ifdef FEATURE_ACL
- dst->addr = ntohl(addr);
+ dst->addr = ntohl((unsigned long) addr);
dst->port = portnum;
if (block_acl(dst, csp))
#else
errno = EPERM;
#endif
- return(-1);
+ return(JB_INVALID_SOCKET);
}
#endif /* def FEATURE_ACL */
if (sizeof(inaddr.sin_port) == sizeof(short))
#endif /* ndef _WIN32 */
{
- inaddr.sin_port = htons((short)portnum);
+ inaddr.sin_port = htons((unsigned short) portnum);
}
#ifndef _WIN32
else
{
- inaddr.sin_port = htonl(portnum);
+ inaddr.sin_port = htonl((unsigned long)portnum);
}
#endif /* ndef _WIN32 */
+#ifdef _WIN32
+ if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) == JB_INVALID_SOCKET)
+#else
if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) < 0)
+#endif
{
- return(-1);
+ return(JB_INVALID_SOCKET);
}
#ifdef TCP_NODELAY
}
#endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
- while (connect(fd, (struct sockaddr *) & inaddr, sizeof inaddr) == -1)
+ while (connect(fd, (struct sockaddr *) & inaddr, sizeof inaddr) == JB_INVALID_SOCKET)
{
#ifdef _WIN32
if (errno == WSAEINPROGRESS)
#endif /* __OS2__ */
{
close_socket(fd);
- return(-1);
+ return(JB_INVALID_SOCKET);
}
}
tv->tv_sec = 30;
tv->tv_usec = 0;
- if (select(fd + 1, NULL, &wfds, NULL, tv) <= 0)
+ /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
+ if (select((int)fd + 1, NULL, &wfds, NULL, tv) <= 0)
{
close_socket(fd);
- return(-1);
+ return(JB_INVALID_SOCKET);
}
return(fd);
* 2 : buf = pointer to data to be written.
* 3 : len = length of data to be written to the socket "fd".
*
- * Returns : Win32 & Unix: If no error occurs, returns the total number of
- * bytes sent, which can be less than the number
- * indicated by len. Otherwise, returns (-1).
+ * Returns : 0 on success (entire buffer sent).
+ * nonzero on error.
*
*********************************************************************/
-int write_socket(int fd, const char *buf, int len)
+int write_socket(jb_socket fd, const char *buf, int len)
{
-#ifdef __OS2__
-#define SOCKET_SEND_MAX 65000
- int write_len = 0, send_len, send_rc = 0, i = 0;
-#endif /* __OS2__ */
- if (len <= 0)
+ if (len == 0)
{
- return(0);
+ return 0;
+ }
+
+ if (len < 0)
+ {
+ return 1;
}
log_error(LOG_LEVEL_LOG, "%N", len, buf);
#if defined(_WIN32) || defined(__BEOS__) || defined(AMIGA)
- return( send(fd, buf, len, 0));
+ return (send(fd, buf, len, 0) != len);
#elif defined(__OS2__)
/*
* Break the data up into SOCKET_SEND_MAX chunks for sending...
* OS/2 seemed to complain when the chunks were too large.
*/
- while ((i < len) && (send_rc != -1))
+#define SOCKET_SEND_MAX 65000
{
- if ((i + SOCKET_SEND_MAX) > len)
- send_len = len - i;
- else
- send_len = SOCKET_SEND_MAX;
- send_rc = send(fd,(char*)buf + i, send_len, 0);
- if (send_rc == -1)
- return(0);
- i = i + send_len;
+ int write_len = 0, send_len, send_rc = 0, i = 0;
+ while ((i < len) && (send_rc != -1))
+ {
+ if ((i + SOCKET_SEND_MAX) > len)
+ send_len = len - i;
+ else
+ send_len = SOCKET_SEND_MAX;
+ send_rc = send(fd,(char*)buf + i, send_len, 0);
+ if (send_rc == -1)
+ return 1;
+ i = i + send_len;
+ }
+ return 0;
}
- return len;
#else
- return( write(fd, buf, len));
+ return (write(fd, buf, len) != len);
#endif
}
* smaller than the number of bytes requested; this may hap-
* pen for example because fewer bytes are actually available
* right now (maybe because we were close to end-of-file, or
- * because we are reading from a pipe, or from a terminal),
- * or because read() was interrupted by a signal. On error,
+ * because we are reading from a pipe, or from a terminal,
+ * or because read() was interrupted by a signal). On error,
* -1 is returned, and errno is set appropriately. In this
* case it is left unspecified whether the file position (if
* any) changes.
*
*********************************************************************/
-int read_socket(int fd, char *buf, int len)
+int read_socket(jb_socket fd, char *buf, int len)
{
if (len <= 0)
{
}
#if defined(_WIN32) || defined(__BEOS__) || defined(AMIGA) || defined(__OS2__)
- return( recv(fd, buf, len, 0));
+ return(recv(fd, buf, len, 0));
#else
- return( read(fd, buf, len));
+ return(read(fd, buf, len));
#endif
}
* Returns : void
*
*********************************************************************/
-void close_socket(int fd)
+void close_socket(jb_socket fd)
{
#if defined(_WIN32) || defined(__BEOS__)
closesocket(fd);
* Parameters :
* 1 : hostnam = TCP/IP address to bind/listen to
* 2 : portnum = port to listen on
+ * 3 : pfd = pointer used to return file descriptor.
*
- * Returns : if success, return file descriptor
- * if failure, returns -2 if address is in use, otherwise -1
- *
+ * Returns : if success, returns 0 and sets *pfd.
+ * if failure, returns -3 if address is in use,
+ * -2 if address unresolvable,
+ * -1 otherwise
*********************************************************************/
-int bind_port(const char *hostnam, int portnum)
+int bind_port(const char *hostnam, int portnum, jb_socket *pfd)
{
struct sockaddr_in inaddr;
- int fd;
+ jb_socket fd;
#ifndef _WIN32
int one = 1;
#endif /* ndef _WIN32 */
+ *pfd = JB_INVALID_SOCKET;
+
memset((char *)&inaddr, '\0', sizeof inaddr);
inaddr.sin_family = AF_INET;
inaddr.sin_addr.s_addr = resolve_hostname_to_ip(hostnam);
+ if (inaddr.sin_addr.s_addr == INADDR_NONE)
+ {
+ return(-2);
+ }
+
#ifndef _WIN32
if (sizeof(inaddr.sin_port) == sizeof(short))
#endif /* ndef _WIN32 */
{
- inaddr.sin_port = htons((short)portnum);
+ inaddr.sin_port = htons((unsigned short) portnum);
}
#ifndef _WIN32
else
{
- inaddr.sin_port = htonl(portnum);
+ inaddr.sin_port = htonl((unsigned long) portnum);
}
#endif /* ndef _WIN32 */
fd = socket(AF_INET, SOCK_STREAM, 0);
+#ifdef _WIN32
+ if (fd == JB_INVALID_SOCKET)
+#else
if (fd < 0)
+#endif
{
return(-1);
}
* to start JunkBuster multiple times on the same IP.
* Without this, stopping and restarting JunkBuster
* from a script fails.
+ * Note: SO_REUSEADDR is meant to only take over
+ * sockets which are *not* in listen state in Linux,
+ * e.g. sockets in TIME_WAIT. YMMV.
*/
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
#endif /* ndef _WIN32 */
if (errno == EADDRINUSE)
#endif
{
- return(-2);
+ return(-3);
}
else
{
}
}
- return fd;
+ *pfd = fd;
+ return 0;
}
* On an error it returns 0 (FALSE).
*
*********************************************************************/
-int accept_connection(struct client_state * csp, int fd)
+int accept_connection(struct client_state * csp, jb_socket fd)
{
struct sockaddr_in client, server;
struct hostent *host = NULL;
- int afd, c_length, s_length;
+ jb_socket afd;
+ size_t c_length, s_length;
#if defined(HAVE_GETHOSTBYADDR_R_8_ARGS) || defined(HAVE_GETHOSTBYADDR_R_7_ARGS) || defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
struct hostent result;
#if defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
c_length = s_length = sizeof(client);
+#ifdef _WIN32
+ afd = accept (fd, (struct sockaddr *) &client, &c_length);
+ if (afd == JB_INVALID_SOCKET)
+ {
+ return 0;
+ }
+#else
do
{
afd = accept (fd, (struct sockaddr *) &client, &c_length);
} while (afd < 1 && errno == EINTR);
-
if (afd < 0)
{
return 0;
}
+#endif
/*
* Determine the IP-Adress that the client used to reach us
* Parameters :
* 1 : host = hostname to resolve
*
- * Returns : -1 => failure, INADDR_ANY or tcp/ip address if succesful.
+ * Returns : INADDR_NONE => failure, INADDR_ANY or tcp/ip address if succesful.
*
*********************************************************************/
-int resolve_hostname_to_ip(const char *host)
+unsigned long resolve_hostname_to_ip(const char *host)
{
struct sockaddr_in inaddr;
struct hostent *hostp;
if (hostp == NULL)
{
errno = EINVAL;
- return(-1);
+ log_error(LOG_LEVEL_ERROR, "could not resolve hostname %s", host);
+ return(INADDR_NONE);
}
if (hostp->h_addrtype != AF_INET)
{
#else
errno = EPROTOTYPE;
#endif
- return(-1);
+ log_error(LOG_LEVEL_ERROR, "hostname %s resolves to unknown address type.", host);
+ return(INADDR_NONE);
}
memcpy(
(char *) &inaddr.sin_addr,
projects / privoxy.git / blobdiff