webcit/tcp_sockets.c

   1 /*
   2  * tcp_sockets.c
   3  *
   4  * TCP socket module for WebCit
   5  *
   6  * $Id$
   7  */
   8
   9 /*
  10  * Uncomment this to log all communications with the Citadel server
  11 #define SERV_TRACE 1
  12  */
  13
  14 #include <ctype.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <stdio.h>
  18 #include <fcntl.h>
  19 #include <signal.h>
  20 #include <sys/types.h>
  21 #include <sys/wait.h>
  22 #include <sys/socket.h>
  23 #include <sys/time.h>
  24 #include <limits.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <sys/un.h>
  28 #include <netdb.h>
  29 #include <string.h>
  30 #include <pwd.h>
  31 #include <errno.h>
  32 #include <stdarg.h>
  33 #include <pthread.h>
  34 #include <signal.h>
  35 #include "webcit.h"
  36 #include "webserver.h"
  37
  38
  39 #ifndef INADDR_NONE
  40 #define INADDR_NONE 0xffffffff
  41 #endif
  42
  43 RETSIGTYPE timeout(int signum)
  44 {
  45         lprintf(1, "Connection timed out.\n");
  46         exit(3);
  47 }
  48
  49
  50
  51 /*
  52  * Connect a unix domain socket
  53  */
  54 int uds_connectsock(char *sockpath)
  55 {
  56         struct sockaddr_un addr;
  57         int s;
  58
  59         memset(&addr, 0, sizeof(addr));
  60         addr.sun_family = AF_UNIX;
  61         strncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
  62
  63         s = socket(AF_UNIX, SOCK_STREAM, 0);
  64         if (s < 0) {
  65                 lprintf(1, "Can't create socket: %s\n",
  66                         strerror(errno));
  67                 return(-1);
  68         }
  69
  70         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
  71                 lprintf(1, "Can't connect: %s\n",
  72                         strerror(errno));
  73                 close(s);
  74                 return(-1);
  75         }
  76
  77         return s;
  78 }
  79
  80
  81 /*
  82  * Connect a TCP/IP socket
  83  */
  84 int tcp_connectsock(char *host, char *service)
  85 {
  86         struct hostent *phe;
  87         struct servent *pse;
  88         struct protoent *ppe;
  89         struct sockaddr_in sin;
  90         int s;
  91
  92         memset(&sin, 0, sizeof(sin));
  93         sin.sin_family = AF_INET;
  94
  95         pse = getservbyname(service, "tcp");
  96         if (pse) {
  97                 sin.sin_port = pse->s_port;
  98         } else if ((sin.sin_port = htons((u_short) atoi(service))) == 0) {
  99                 lprintf(1, "Can't get %s service entry\n", service);
 100                 return (-1);
 101         }
 102         phe = gethostbyname(host);
 103         if (phe) {
 104                 memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
 105         } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
 106                 lprintf(1, "Can't get %s host entry: %s\n",
 107                         host, strerror(errno));
 108                 return (-1);
 109         }
 110         if ((ppe = getprotobyname("tcp")) == 0) {
 111                 lprintf(1, "Can't get TCP protocol entry: %s\n",
 112                         strerror(errno));
 113                 return (-1);
 114         }
 115
 116         s = socket(PF_INET, SOCK_STREAM, ppe->p_proto);
 117         if (s < 0) {
 118                 lprintf(1, "Can't create socket: %s\n", strerror(errno));
 119                 return (-1);
 120         }
 121         signal(SIGALRM, timeout);
 122         alarm(30);
 123
 124         if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 125                 lprintf(1, "Can't connect to %s.%s: %s\n",
 126                         host, service, strerror(errno));
 127                 close(s);
 128                 return (-1);
 129         }
 130         alarm(0);
 131         signal(SIGALRM, SIG_IGN);
 132
 133         return (s);
 134 }
 135
 136
 137
 138
 139 /*
 140  * Input binary data from socket
 141  */
 142 void serv_read(char *buf, int bytes)
 143 {
 144         int len, rlen;
 145
 146         len = 0;
 147         while (len < bytes) {
 148                 rlen = read(WC->serv_sock, &buf[len], bytes - len);
 149                 if (rlen < 1) {
 150                         lprintf(1, "Server connection broken: %s\n",
 151                                 strerror(errno));
 152                         close(WC->serv_sock);
 153                         WC->serv_sock = (-1);
 154                         WC->connected = 0;
 155                         WC->logged_in = 0;
 156                         memset(buf, 0, bytes);
 157                         return;
 158                 }
 159                 len = len + rlen;
 160         }
 161 }
 162
 163
 164 /*
 165  * input string from pipe
 166  */
 167 void serv_gets(char *strbuf)
 168 {
 169         int ch, len;
 170         char buf[2];
 171
 172         len = 0;
 173         strcpy(strbuf, "");
 174         do {
 175                 serv_read(&buf[0], 1);
 176                 ch = buf[0];
 177                 strbuf[len++] = ch;
 178         } while ((ch != 10) && (ch != 0) && (len < (SIZ-1)));
 179         if (strbuf[len-1] == 10) strbuf[--len] = 0;
 180         if (strbuf[len-1] == 13) strbuf[--len] = 0;
 181 #ifdef SERV_TRACE
 182         lprintf(9, ">%s\n", strbuf);
 183 #endif
 184 }
 185
 186
 187
 188 /*
 189  * send binary to server
 190  */
 191 void serv_write(char *buf, int nbytes)
 192 {
 193         int bytes_written = 0;
 194         int retval;
 195         while (bytes_written < nbytes) {
 196                 retval = write(WC->serv_sock, &buf[bytes_written],
 197                                nbytes - bytes_written);
 198                 if (retval < 1) {
 199                         lprintf(1, "Server connection broken: %s\n",
 200                                 strerror(errno));
 201                         close(WC->serv_sock);
 202                         WC->serv_sock = (-1);
 203                         WC->connected = 0;
 204                         WC->logged_in = 0;
 205                         return;
 206                 }
 207                 bytes_written = bytes_written + retval;
 208         }
 209 }
 210
 211
 212 /*
 213  * send line to server
 214  */
 215 void serv_puts(char *string)
 216 {
 217         char buf[SIZ];
 218
 219 #ifdef SERV_TRACE
 220         lprintf(9, "<%s\n", string);
 221 #endif
 222         sprintf(buf, "%s\n", string);
 223         serv_write(buf, strlen(buf));
 224 }
 225
 226
 227 /*
 228  * convenience function to send stuff to the server
 229  */
 230 void serv_printf(const char *format,...)
 231 {
 232         va_list arg_ptr;
 233         char buf[SIZ];
 234
 235         va_start(arg_ptr, format);
 236         vsnprintf(buf, sizeof buf, format, arg_ptr);
 237         va_end(arg_ptr);
 238
 239         strcat(buf, "\n");
 240         serv_write(buf, strlen(buf));
 241 #ifdef SERV_TRACE
 242         lprintf(9, "<%s", buf);
 243 #endif
 244 }