X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fclientsocket.c;h=a4b521864087357dff41622fd57e027be94bae25;hb=ef347e598ab670b87e178af7fc6b00795494303a;hp=0c6d401c2f70e60166b9947d7bd9e7744dce397b;hpb=41afc5e2c243f7b2f83664f9a5a6fb8ff53e21fc;p=citadel.git diff --git a/citadel/clientsocket.c b/citadel/clientsocket.c index 0c6d401c2..a4b521864 100644 --- a/citadel/clientsocket.c +++ b/citadel/clientsocket.c @@ -1,17 +1,26 @@ /* - * $Id$ - * * This module handles client-side sockets opened by the Citadel server (for * the client side of Internet protocols, etc.) It does _not_ handle client * sockets for the Citadel client; for that you must look in ipc_c_tcp.c * (which, uncoincidentally, bears a striking similarity to this file). * + * Copyright (c) 1987-2011 by the citadel.org team + * + * This program is open source software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#ifdef DLL_EXPORT -#define IN_LIBCIT -#endif - #include "sysdep.h" #include #include @@ -27,118 +36,160 @@ #include #include #include +#include +#include #include "citadel.h" #include "server.h" -#include "dynloader.h" #ifndef HAVE_SNPRINTF #include "snprintf.h" #endif #include "sysdep_decls.h" -#include - -#ifndef INADDR_NONE -#define INADDR_NONE 0xffffffff -#endif +#include "config.h" +#include "clientsocket.h" +#include "ctdl_module.h" -int sock_connect(char *host, char *service, char *protocol) +int sock_connect(char *host, char *service) { - struct hostent *phe; - struct servent *pse; - struct protoent *ppe; - struct sockaddr_in sin; - int s, type; - - memset(&sin, 0, sizeof(sin)); - sin.sin_family = AF_INET; - - pse = getservbyname(service, protocol); - if (pse) { - sin.sin_port = pse->s_port; - } else if ((sin.sin_port = htons((u_short) atoi(service))) == 0) { - lprintf(3, "Can't get %s service entry: %s\n", - service, strerror(errno)); - return(-1); - } - phe = gethostbyname(host); - if (phe) { - memcpy(&sin.sin_addr, phe->h_addr, phe->h_length); - } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) { - lprintf(3, "Can't get %s host entry: %s\n", - host, strerror(errno)); - return(-1); - } - if ((ppe = getprotobyname(protocol)) == 0) { - lprintf(3, "Can't get %s protocol entry: %s\n", - protocol, strerror(errno)); - return(-1); - } - if (!strcmp(protocol, "udp")) { - type = SOCK_DGRAM; + struct in6_addr serveraddr; + struct addrinfo hints; + struct addrinfo *res = NULL; + struct addrinfo *ai = NULL; + int rc = (-1); + int sock = (-1); + + if ((host == NULL) || IsEmptyStr(host)) + return (-1); + if ((service == NULL) || IsEmptyStr(service)) + return (-1); + + memset(&hints, 0x00, sizeof(hints)); + hints.ai_flags = AI_NUMERICSERV; + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + /* + * Handle numeric IPv4 and IPv6 addresses + */ + rc = inet_pton(AF_INET, host, &serveraddr); + if (rc == 1) { /* dotted quad */ + hints.ai_family = AF_INET; + hints.ai_flags |= AI_NUMERICHOST; } else { - type = SOCK_STREAM; + rc = inet_pton(AF_INET6, host, &serveraddr); + if (rc == 1) { /* IPv6 address */ + hints.ai_family = AF_INET6; + hints.ai_flags |= AI_NUMERICHOST; + } } - s = socket(PF_INET, type, ppe->p_proto); - if (s < 0) { - lprintf(3, "Can't create socket: %s\n", strerror(errno)); - return(-1); - } + /* Begin the connection process */ - if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) { - lprintf(3, "can't connect to %s:%s: %s\n", - host, service, strerror(errno)); + rc = getaddrinfo(host, service, &hints, &res); + if (rc != 0) { + syslog(LOG_ERR, "%s: %s", host, gai_strerror(rc)); return(-1); } - return (s); + /* + * Try all available addresses until we connect to one or until we run out. + */ + for (ai = res; ai != NULL; ai = ai->ai_next) { + sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if (sock < 0) { + syslog(LOG_ERR, "socket() failed: %s", strerror(errno)); + freeaddrinfo(res); + return(-1); + } + rc = connect(sock, ai->ai_addr, ai->ai_addrlen); + if (rc >= 0) { + freeaddrinfo(res); + return(sock); + } + else { + syslog(LOG_ERR, "connect() failed: %s", strerror(errno)); + close(sock); + } + } + freeaddrinfo(res); + return(-1); } /* - * sock_read_to() - input binary data from socket, with a settable timeout. - * Returns the number of bytes read, or -1 for error. + * Read data from the client socket. + * + * sock socket fd to read from + * buf buffer to read into + * bytes number of bytes to read + * timeout Number of seconds to wait before timing out + * + * Possible return values: + * 1 Requested number of bytes has been read. + * 0 Request timed out. + * -1 Connection is broken, or other error. */ -int sock_read_to(int sock, char *buf, int bytes, int timeout) +int socket_read_blob(int *Socket, StrBuf * Target, int bytes, int timeout) { - int len,rlen; - fd_set rfds; - struct timeval tv; - int retval; - - len = 0; - while(lenSBuf.Buf, + &CCC->SBuf.ReadWritePointer, + Socket, 1, bytes, O_TERM, &Error); + + if (retval < 0) { + syslog(LOG_CRIT, "socket_read_blob() failed: %s", Error); + } + return retval; +} - if (FD_ISSET(sock, &rfds) == 0) { /* timed out */ - lprintf(9, "sock_read() timed out.\n"); - return(-1); - } - rlen = read(sock, &buf[len], bytes-len); - if (rlen<1) { - lprintf(2, "sock_read() failed: %s\n", - strerror(errno)); - return(-1); - } - len = len + rlen; - } - return(bytes); +int CtdlSockGetLine(int *sock, StrBuf * Target, int nSec) +{ + CitContext *CCC = MyContext(); + const char *Error; + int rc; + + FlushStrBuf(Target); + rc = StrBufTCP_read_buffered_line_fast(Target, + CCC->SBuf.Buf, + &CCC->SBuf.ReadWritePointer, + sock, nSec, 1, &Error); + if ((rc < 0) && (Error != NULL)) + syslog(LOG_CRIT, "CtdlSockGetLine() failed: %s", Error); + return rc; } /* - * sock_read() - input binary data from socket. - * Returns the number of bytes read, or -1 for error. + * client_getln() ... Get a LF-terminated line of text from the client. + * (This is implemented in terms of client_read() and could be + * justifiably moved out of sysdep.c) */ -inline int sock_read(int sock, char *buf, int bytes) +int sock_getln(int *sock, char *buf, int bufsize) { - return sock_read_to(sock, buf, bytes, CLIENT_TIMEOUT); + int i, retval; + CitContext *CCC = MyContext(); + const char *pCh; + + FlushStrBuf(CCC->sMigrateBuf); + retval = CtdlSockGetLine(sock, CCC->sMigrateBuf, 5); + + i = StrLength(CCC->sMigrateBuf); + pCh = ChrPtr(CCC->sMigrateBuf); + + memcpy(buf, pCh, i + 1); + + FlushStrBuf(CCC->sMigrateBuf); + if (retval < 0) { + safestrncpy(&buf[i], "000", bufsize - i); + i += 3; + } + return i; } @@ -146,17 +197,64 @@ inline int sock_read(int sock, char *buf, int bytes) * sock_write() - send binary to server. * Returns the number of bytes written, or -1 for error. */ -int sock_write(int sock, char *buf, int nbytes) +int sock_write(int *sock, const char *buf, int nbytes) +{ return sock_write_timeout(sock, buf, nbytes, 50); } +int sock_write_timeout(int *sock, const char *buf, int nbytes, int timeout) { + int nSuccessLess = 0; int bytes_written = 0; int retval; - while (bytes_written < nbytes) { - retval = write(sock, &buf[bytes_written], + fd_set rfds; + int fdflags; + int IsNonBlock; + struct timeval tv; + int selectresolution = 100; + + fdflags = fcntl(*sock, F_GETFL); + IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK; + + while ((nSuccessLess < timeout) && + (*sock != -1) && + (bytes_written < nbytes)) + { + if (IsNonBlock){ + tv.tv_sec = selectresolution; + tv.tv_usec = 0; + + FD_ZERO(&rfds); + FD_SET(*sock, &rfds); + if (select(*sock + 1, NULL, &rfds, NULL, &tv) == -1) { +/// *Error = strerror(errno); + close (*sock); + *sock = -1; + return -1; + } + } + if (IsNonBlock && ! FD_ISSET(*sock, &rfds)) { + nSuccessLess ++; + continue; + } + retval = write(*sock, &buf[bytes_written], nbytes - bytes_written); if (retval < 1) { + sock_close(*sock); + *sock = -1; return (-1); } bytes_written = bytes_written + retval; + if (IsNonBlock && (bytes_written == nbytes)){ + tv.tv_sec = selectresolution; + tv.tv_usec = 0; + + FD_ZERO(&rfds); + FD_SET(*sock, &rfds); + if (select(*sock + 1, NULL, &rfds, NULL, &tv) == -1) { +/// *Error = strerror(errno); + close (*sock); + *sock = -1; + return -1; + } + } } return (bytes_written); } @@ -164,36 +262,30 @@ int sock_write(int sock, char *buf, int nbytes) /* - * Input string from socket - implemented in terms of sock_read() - * + * client_getln() ... Get a LF-terminated line of text from the client. + * (This is implemented in terms of client_read() and could be + * justifiably moved out of sysdep.c) */ -int sock_gets(int sock, char *buf) +int sock_getln_err(int *sock, char *buf, int bufsize, int *rc, int nSec) { - int i; + int i, retval; + CitContext *CCC = MyContext(); + const char *pCh; - /* Read one character at a time. - */ - for (i = 0;; i++) { - if (sock_read(sock, &buf[i], 1) < 0) return(-1); - if (buf[i] == '\n' || i == (SIZ-1)) - break; - } + FlushStrBuf(CCC->sMigrateBuf); + *rc = retval = CtdlSockGetLine(sock, CCC->sMigrateBuf, nSec); - /* If we got a long line, discard characters until the newline. - */ - if (i == (SIZ-1)) - while (buf[i] != '\n') - if (sock_read(sock, &buf[i], 1) < 0) return(-1); + i = StrLength(CCC->sMigrateBuf); + pCh = ChrPtr(CCC->sMigrateBuf); - /* Strip any trailing CR and LF characters. - */ - buf[i] = 0; - while ( (strlen(buf)>0) - && ((buf[strlen(buf)-1]==13) - || (buf[strlen(buf)-1]==10)) ) { - buf[strlen(buf)-1] = 0; + memcpy(buf, pCh, i + 1); + + FlushStrBuf(CCC->sMigrateBuf); + if (retval < 0) { + safestrncpy(&buf[i], "000", bufsize - i); + i += 3; } - return(strlen(buf)); + return i; } /* @@ -201,20 +293,29 @@ int sock_gets(int sock, char *buf) * client side protocol implementations. It only returns the first line of * a multiline response, discarding the rest. */ -int ml_sock_gets(int sock, char *buf) { +int ml_sock_gets(int *sock, char *buf, int nSec) +{ + int rc = 0; char bigbuf[1024]; int g; - g = sock_gets(sock, buf); - if (g < 4) return(g); - if (buf[3] != '-') return(g); + g = sock_getln_err(sock, buf, SIZ, &rc, nSec); + if (rc < 0) + return rc; + if (g < 4) + return (g); + if (buf[3] != '-') + return (g); do { - g = sock_gets(sock, bigbuf); - if (g < 0) return(g); - } while ( (g >= 4) && (bigbuf[3] == '-') ); - - return(strlen(buf)); + g = sock_getln_err(sock, bigbuf, SIZ, &rc, nSec); + if (rc < 0) + return rc; + if (g < 0) + return (g); + } while ((g >= 4) && (bigbuf[3] == '-')); + + return (strlen(buf)); } @@ -222,13 +323,15 @@ int ml_sock_gets(int sock, char *buf) { * sock_puts() - send line to server - implemented in terms of serv_write() * Returns the number of bytes written, or -1 for error. */ -int sock_puts(int sock, char *buf) +int sock_puts(int *sock, char *buf) { int i, j; i = sock_write(sock, buf, strlen(buf)); - if (i<0) return(i); + if (i < 0) + return (i); j = sock_write(sock, "\n", 1); - if (j<0) return(j); - return(i+j); + if (j < 0) + return (j); + return (i + j); }