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                                     NNN_TERM,
 236                                     &Err);
 237         if (rc < 0)
 238         {
 239                 lprintf(1, "Server connection broken: %s\n",
 240                         Err);
 241                 wc_backtrace();
 242                 WCC->serv_sock = (-1);
 243                 WCC->connected = 0;
 244                 WCC->logged_in = 0;
 245         }
 246         return rc;
 247 }
 248
 249 int StrBuf_ServGetBLOB(StrBuf *buf, long BlobSize)
 250 {
 251         wcsession *WCC = WC;
 252         const char *Err;
 253         int rc;
 254
 255         WCC->ReadPos = NULL;
 256         rc = StrBufReadBLOB(buf, &WCC->serv_sock, 1, BlobSize, &Err);
 257         if (rc < 0)
 258         {
 259                 lprintf(1, "Server connection broken: %s\n",
 260                         Err);
 261                 wc_backtrace();
 262                 WCC->serv_sock = (-1);
 263                 WCC->connected = 0;
 264                 WCC->logged_in = 0;
 265         }
 266         return rc;
 267 }
 268
 269 /*
 270  *  send binary to server
 271  *  buf the buffer to write to citadel server
 272  *  nbytes how many bytes to send to citadel server
 273  */
 274 void serv_write(const char *buf, int nbytes)
 275 {
 276         int bytes_written = 0;
 277         int retval;
 278         while (bytes_written < nbytes) {
 279                 retval = write(WC->serv_sock, &buf[bytes_written],
 280                                nbytes - bytes_written);
 281                 if (retval < 1) {
 282                         lprintf(1, "Server connection broken: %s\n",
 283                                 strerror(errno));
 284                         close(WC->serv_sock);
 285                         WC->serv_sock = (-1);
 286                         WC->connected = 0;
 287                         WC->logged_in = 0;
 288                         return;
 289                 }
 290                 bytes_written = bytes_written + retval;
 291         }
 292 }
 293
 294
 295 /*
 296  *  send line to server
 297  *  string the line to send to the citadel server
 298  */
 299 void serv_puts(const char *string)
 300 {
 301         wcsession *WCC = WC;
 302 #ifdef SERV_TRACE
 303         lprintf(9, "%3d<%s\n", WC->serv_sock, string);
 304 #endif
 305         FlushStrBuf(WCC->ReadBuf);
 306         WCC->ReadPos = NULL;
 307
 308         serv_write(string, strlen(string));
 309         serv_write("\n", 1);
 310 }
 311
 312 /*
 313  *  send line to server
 314  *  string the line to send to the citadel server
 315  */
 316 void serv_putbuf(const StrBuf *string)
 317 {
 318         wcsession *WCC = WC;
 319 #ifdef SERV_TRACE
 320         lprintf(9, "%3d<%s\n", WC->serv_sock, ChrPtr(string));
 321 #endif
 322         FlushStrBuf(WCC->ReadBuf);
 323         WCC->ReadPos = NULL;
 324
 325         serv_write(ChrPtr(string), StrLength(string));
 326         serv_write("\n", 1);
 327 }
 328
 329
 330 /*
 331  *  convenience function to send stuff to the server
 332  *  format the formatstring
 333  *  ... the entities to insert into format
 334  */
 335 void serv_printf(const char *format,...)
 336 {
 337         wcsession *WCC = WC;
 338         va_list arg_ptr;
 339         char buf[SIZ];
 340         size_t len;
 341
 342         FlushStrBuf(WCC->ReadBuf);
 343         WCC->ReadPos = NULL;
 344
 345         va_start(arg_ptr, format);
 346         vsnprintf(buf, sizeof buf, format, arg_ptr);
 347         va_end(arg_ptr);
 348
 349         len = strlen(buf);
 350         buf[len++] = '\n';
 351         buf[len] = '\0';
 352         serv_write(buf, len);
 353 #ifdef SERV_TRACE
 354         lprintf(9, "<%s", buf);
 355 #endif
 356 }
 357