webcit/tcp_sockets.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6  * Uncomment this to log all communications with the Citadel server
   7 #define SERV_TRACE 1
   8  */
   9
  10
  11 #include "webcit.h"
  12 #include "webserver.h"
  13
  14 /*
  15  *  register the timeout
  16  *  signum signalhandler number
  17  * \return signals
  18  */
  19 RETSIGTYPE timeout(int signum)
  20 {
  21         lprintf(1, "Connection timed out; unable to reach citserver\n");
  22         /* no exit here, since we need to server the connection unreachable thing. exit(3); */
  23 }
  24
  25
  26 /*
  27  *  Connect a unix domain socket
  28  *  sockpath where to open a unix domain socket
  29  */
  30 int uds_connectsock(char *sockpath)
  31 {
  32         struct sockaddr_un addr;
  33         int s;
  34
  35         memset(&addr, 0, sizeof(addr));
  36         addr.sun_family = AF_UNIX;
  37         strncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
  38
  39         s = socket(AF_UNIX, SOCK_STREAM, 0);
  40         if (s < 0) {
  41                 lprintf(1, "Can't create socket: %s\n",
  42                         strerror(errno));
  43                 return(-1);
  44         }
  45
  46         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
  47                 lprintf(1, "Can't connect: %s\n",
  48                         strerror(errno));
  49                 close(s);
  50                 return(-1);
  51         }
  52
  53         return s;
  54 }
  55
  56
  57 /*
  58  *  Connect a TCP/IP socket
  59  *  host the host to connect to
  60  *  service the service on the host to call
  61  */
  62 int tcp_connectsock(char *host, char *service)
  63 {
  64         struct hostent *phe;
  65         struct servent *pse;
  66         struct protoent *ppe;
  67         struct sockaddr_in sin;
  68         int s;
  69
  70         memset(&sin, 0, sizeof(sin));
  71         sin.sin_family = AF_INET;
  72
  73         pse = getservbyname(service, "tcp");
  74         if (pse) {
  75                 sin.sin_port = pse->s_port;
  76         } else if ((sin.sin_port = htons((u_short) atoi(service))) == 0) {
  77                 lprintf(1, "Can't get %s service entry\n", service);
  78                 return (-1);
  79         }
  80         phe = gethostbyname(host);
  81         if (phe) {
  82                 memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
  83         } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
  84                 lprintf(1, "Can't get %s host entry: %s\n",
  85                         host, strerror(errno));
  86                 return (-1);
  87         }
  88         if ((ppe = getprotobyname("tcp")) == 0) {
  89                 lprintf(1, "Can't get TCP protocol entry: %s\n",
  90                         strerror(errno));
  91                 return (-1);
  92         }
  93
  94         s = socket(PF_INET, SOCK_STREAM, ppe->p_proto);
  95         if (s < 0) {
  96                 lprintf(1, "Can't create socket: %s\n", strerror(errno));
  97                 return (-1);
  98         }
  99         signal(SIGALRM, timeout);
 100         alarm(30);
 101
 102         if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 103                 lprintf(1, "Can't connect to %s.%s: %s\n",
 104                         host, service, strerror(errno));
 105                 close(s);
 106                 return (-1);
 107         }
 108         alarm(0);
 109         signal(SIGALRM, SIG_IGN);
 110
 111         return (s);
 112 }
 113
 114
 115
 116
 117 /*
 118  *  Input binary data from socket
 119  *  buf the buffer to get the input to
 120  *  bytes the maximal number of bytes to read
 121  */
 122 inline void _serv_read(char *buf, int bytes, wcsession *WCC)
 123 {
 124         int len, rlen;
 125
 126         len = 0;
 127         while ((len < bytes) && (WCC->serv_sock != -1)){
 128                 rlen = read(WCC->serv_sock, &buf[len], bytes - len);
 129                 if (rlen < 1) {
 130                         lprintf(1, "Server connection broken: %s\n",
 131                                 strerror(errno));
 132                         wc_backtrace();
 133                         close(WCC->serv_sock);
 134                         WCC->serv_sock = (-1);
 135                         WCC->connected = 0;
 136                         WCC->logged_in = 0;
 137                         memset(buf, 0, bytes);
 138                         return;
 139                 }
 140                 len = len + rlen;
 141         }
 142 }
 143
 144 void serv_read(char *buf, int bytes)
 145 {
 146         wcsession *WCC = WC;
 147
 148         WCC->ReadPos = NULL;
 149
 150         _serv_read(buf, bytes, WCC);
 151 }
 152
 153 /*
 154  *  input string from pipe
 155  */
 156 int serv_getln(char *strbuf, int bufsize)
 157 {
 158         wcsession *WCC = WC;
 159         int ch, len;
 160         char buf[2];
 161
 162         WCC->ReadPos = NULL;
 163         len = 0;
 164         strbuf[0] = 0;
 165         do {
 166                 _serv_read(&buf[0], 1, WCC);
 167                 ch = buf[0];
 168                 if ((ch != 13) && (ch != 10)) {
 169                         strbuf[len++] = ch;
 170                 }
 171         } while ((ch != 10) && (ch != 0) && (len < (bufsize-1)) && (WCC->serv_sock != -1));
 172         strbuf[len] = 0;
 173 #ifdef SERV_TRACE
 174         lprintf(9, "%3d>%s\n", WC->serv_sock, strbuf);
 175 #endif
 176         return len;
 177 }
 178
 179 int StrBuf_ServGetln(StrBuf *buf)
 180 {
 181         wcsession *WCC = WC;
 182         const char *ErrStr;
 183         int rc;
 184
 185         WCC->ReadPos = NULL;
 186         rc = StrBufTCP_read_line(buf, &WCC->serv_sock, 0, &ErrStr);
 187         if (rc < 0)
 188         {
 189                 lprintf(1, "Server connection broken: %s\n",
 190                         ErrStr);
 191                 wc_backtrace();
 192                 WCC->serv_sock = (-1);
 193                 WCC->connected = 0;
 194                 WCC->logged_in = 0;
 195         }
 196         return rc;
 197 }
 198
 199 int StrBuf_ServGetlnBuffered(StrBuf *buf)
 200 {
 201         wcsession *WCC = WC;
 202         const char *ErrStr;
 203         int rc;
 204
 205         rc = StrBufTCP_read_buffered_line_fast(buf,
 206                                                WCC->ReadBuf,
 207                                                &WCC->ReadPos,
 208                                                &WCC->serv_sock,
 209                                                5, 1,
 210                                                &ErrStr);
 211         if (rc < 0)
 212         {
 213                 lprintf(1, "Server connection broken: %s\n",
 214                         ErrStr);
 215                 wc_backtrace();
 216                 WCC->serv_sock = (-1);
 217                 WCC->connected = 0;
 218                 WCC->logged_in = 0;
 219         }
 220         return rc;
 221 }
 222
 223 int StrBuf_ServGetBLOBBuffered(StrBuf *buf, long BlobSize)
 224 {
 225         wcsession *WCC = WC;
 226         const char *Err;
 227         int rc;
 228
 229         rc = StrBufReadBLOBBuffered(buf,
 230                                     WCC->ReadBuf,
 231                                     &WCC->ReadPos,
 232                                     &WCC->serv_sock,
 233                                     1,
 234                                     BlobSize,
 235                                     &Err);
 236         if (rc < 0)
 237         {
 238                 lprintf(1, "Server connection broken: %s\n",
 239                         Err);
 240                 wc_backtrace();
 241                 WCC->serv_sock = (-1);
 242                 WCC->connected = 0;
 243                 WCC->logged_in = 0;
 244         }
 245         return rc;
 246 }
 247
 248 int StrBuf_ServGetBLOB(StrBuf *buf, long BlobSize)
 249 {
 250         wcsession *WCC = WC;
 251         const char *Err;
 252         int rc;
 253
 254         WCC->ReadPos = NULL;
 255         rc = StrBufReadBLOB(buf, &WCC->serv_sock, 1, BlobSize, &Err);
 256         if (rc < 0)
 257         {
 258                 lprintf(1, "Server connection broken: %s\n",
 259                         Err);
 260                 wc_backtrace();
 261                 WCC->serv_sock = (-1);
 262                 WCC->connected = 0;
 263                 WCC->logged_in = 0;
 264         }
 265         return rc;
 266 }
 267
 268 /*
 269  *  send binary to server
 270  *  buf the buffer to write to citadel server
 271  *  nbytes how many bytes to send to citadel server
 272  */
 273 void serv_write(const char *buf, int nbytes)
 274 {
 275         int bytes_written = 0;
 276         int retval;
 277         while (bytes_written < nbytes) {
 278                 retval = write(WC->serv_sock, &buf[bytes_written],
 279                                nbytes - bytes_written);
 280                 if (retval < 1) {
 281                         lprintf(1, "Server connection broken: %s\n",
 282                                 strerror(errno));
 283                         close(WC->serv_sock);
 284                         WC->serv_sock = (-1);
 285                         WC->connected = 0;
 286                         WC->logged_in = 0;
 287                         return;
 288                 }
 289                 bytes_written = bytes_written + retval;
 290         }
 291 }
 292
 293
 294 /*
 295  *  send line to server
 296  *  string the line to send to the citadel server
 297  */
 298 void serv_puts(const char *string)
 299 {
 300         wcsession *WCC = WC;
 301 #ifdef SERV_TRACE
 302         lprintf(9, "%3d<%s\n", WC->serv_sock, string);
 303 #endif
 304         FlushStrBuf(WCC->ReadBuf);
 305         WCC->ReadPos = NULL;
 306
 307         serv_write(string, strlen(string));
 308         serv_write("\n", 1);
 309 }
 310
 311 /*
 312  *  send line to server
 313  *  string the line to send to the citadel server
 314  */
 315 void serv_putbuf(const StrBuf *string)
 316 {
 317         wcsession *WCC = WC;
 318 #ifdef SERV_TRACE
 319         lprintf(9, "%3d<%s\n", WC->serv_sock, ChrPtr(string));
 320 #endif
 321         FlushStrBuf(WCC->ReadBuf);
 322         WCC->ReadPos = NULL;
 323
 324         serv_write(ChrPtr(string), StrLength(string));
 325         serv_write("\n", 1);
 326 }
 327
 328
 329 /*
 330  *  convenience function to send stuff to the server
 331  *  format the formatstring
 332  *  ... the entities to insert into format
 333  */
 334 void serv_printf(const char *format,...)
 335 {
 336         wcsession *WCC = WC;
 337         va_list arg_ptr;
 338         char buf[SIZ];
 339         size_t len;
 340
 341         FlushStrBuf(WCC->ReadBuf);
 342         WCC->ReadPos = NULL;
 343
 344         va_start(arg_ptr, format);
 345         vsnprintf(buf, sizeof buf, format, arg_ptr);
 346         va_end(arg_ptr);
 347
 348         len = strlen(buf);
 349         buf[len++] = '\n';
 350         buf[len] = '\0';
 351         serv_write(buf, len);
 352 #ifdef SERV_TRACE
 353         lprintf(9, "<%s", buf);
 354 #endif
 355 }
 356