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]: %s\n",
  42                         sockpath,
  43                         strerror(errno));
  44                 return(-1);
  45         }
  46
  47         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
  48                 lprintf(1, "Can't connect [%s]: %s\n",
  49                         sockpath,
  50                         strerror(errno));
  51                 close(s);
  52                 return(-1);
  53         }
  54
  55         return s;
  56 }
  57
  58
  59 /*
  60  *  Connect a TCP/IP socket
  61  *  host the host to connect to
  62  *  service the service on the host to call
  63  */
  64 int tcp_connectsock(char *host, char *service)
  65 {
  66         struct hostent *phe;
  67         struct servent *pse;
  68         struct protoent *ppe;
  69         struct sockaddr_in sin;
  70         int s;
  71
  72         memset(&sin, 0, sizeof(sin));
  73         sin.sin_family = AF_INET;
  74
  75         pse = getservbyname(service, "tcp");
  76         if (pse) {
  77                 sin.sin_port = pse->s_port;
  78         } else if ((sin.sin_port = htons((u_short) atoi(service))) == 0) {
  79                 lprintf(1, "Can't get %s service entry\n", service);
  80                 return (-1);
  81         }
  82         phe = gethostbyname(host);
  83         if (phe) {
  84                 memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
  85         } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
  86                 lprintf(1, "Can't get %s host entry: %s\n",
  87                         host, strerror(errno));
  88                 return (-1);
  89         }
  90         if ((ppe = getprotobyname("tcp")) == 0) {
  91                 lprintf(1, "Can't get TCP protocol entry: %s\n",
  92                         strerror(errno));
  93                 return (-1);
  94         }
  95
  96         s = socket(PF_INET, SOCK_STREAM, ppe->p_proto);
  97         if (s < 0) {
  98                 lprintf(1, "Can't create socket: %s\n", strerror(errno));
  99                 return (-1);
 100         }
 101         signal(SIGALRM, timeout);
 102         alarm(30);
 103
 104         if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 105                 lprintf(1, "Can't connect to %s.%s: %s\n",
 106                         host, service, strerror(errno));
 107                 close(s);
 108                 return (-1);
 109         }
 110         alarm(0);
 111         signal(SIGALRM, SIG_IGN);
 112
 113         return (s);
 114 }
 115
 116
 117
 118 int StrBuf_ServGetln(StrBuf *buf)
 119 {
 120         wcsession *WCC = WC;
 121         const char *ErrStr;
 122         int rc;
 123
 124         WCC->ReadPos = NULL;
 125         rc = StrBufTCP_read_line(buf, &WCC->serv_sock, 0, &ErrStr);
 126         if (rc < 0)
 127         {
 128                 lprintf(1, "Server connection broken: %s\n",
 129                         ErrStr);
 130                 wc_backtrace();
 131                 WCC->serv_sock = (-1);
 132                 WCC->connected = 0;
 133                 WCC->logged_in = 0;
 134         }
 135         return rc;
 136 }
 137
 138 /*
 139  *  input string from pipe
 140  */
 141 int serv_getln(char *strbuf, int bufsize)
 142 {
 143         wcsession *WCC = WC;
 144         int len;
 145
 146         WCC->ReadPos = NULL;
 147
 148         StrBuf_ServGetln(WCC->MigrateReadLineBuf);
 149         len = StrLength(WCC->MigrateReadLineBuf);
 150         if (len > bufsize)
 151                 len = bufsize - 1;
 152         memcpy(strbuf, ChrPtr(WCC->MigrateReadLineBuf), len);
 153         strbuf[len] = 0;
 154 #ifdef SERV_TRACE
 155         lprintf(9, "%3d>%s\n", WC->serv_sock, strbuf);
 156 #endif
 157         return len;
 158 }
 159
 160
 161 int StrBuf_ServGetlnBuffered(StrBuf *buf)
 162 {
 163         wcsession *WCC = WC;
 164         const char *ErrStr;
 165         int rc;
 166
 167         rc = StrBufTCP_read_buffered_line_fast(buf,
 168                                                WCC->ReadBuf,
 169                                                &WCC->ReadPos,
 170                                                &WCC->serv_sock,
 171                                                5, 1,
 172                                                &ErrStr);
 173         if (rc < 0)
 174         {
 175                 lprintf(1, "Server connection broken: %s\n",
 176                         ErrStr);
 177                 wc_backtrace();
 178                 WCC->serv_sock = (-1);
 179                 WCC->connected = 0;
 180                 WCC->logged_in = 0;
 181         }
 182         return rc;
 183 }
 184
 185 int StrBuf_ServGetBLOBBuffered(StrBuf *buf, long BlobSize)
 186 {
 187         wcsession *WCC = WC;
 188         const char *Err;
 189         int rc;
 190
 191         rc = StrBufReadBLOBBuffered(buf,
 192                                     WCC->ReadBuf,
 193                                     &WCC->ReadPos,
 194                                     &WCC->serv_sock,
 195                                     1,
 196                                     BlobSize,
 197                                     NNN_TERM,
 198                                     &Err);
 199         if (rc < 0)
 200         {
 201                 lprintf(1, "Server connection broken: %s\n",
 202                         Err);
 203                 wc_backtrace();
 204                 WCC->serv_sock = (-1);
 205                 WCC->connected = 0;
 206                 WCC->logged_in = 0;
 207         }
 208         return rc;
 209 }
 210
 211 int StrBuf_ServGetBLOB(StrBuf *buf, long BlobSize)
 212 {
 213         wcsession *WCC = WC;
 214         const char *Err;
 215         int rc;
 216
 217         WCC->ReadPos = NULL;
 218         rc = StrBufReadBLOB(buf, &WCC->serv_sock, 1, BlobSize, &Err);
 219         if (rc < 0)
 220         {
 221                 lprintf(1, "Server connection broken: %s\n",
 222                         Err);
 223                 wc_backtrace();
 224                 WCC->serv_sock = (-1);
 225                 WCC->connected = 0;
 226                 WCC->logged_in = 0;
 227         }
 228         return rc;
 229 }
 230
 231 /*
 232  *  send binary to server
 233  *  buf the buffer to write to citadel server
 234  *  nbytes how many bytes to send to citadel server
 235  */
 236 void serv_write(const char *buf, int nbytes)
 237 {
 238         int bytes_written = 0;
 239         int retval;
 240         while (bytes_written < nbytes) {
 241                 retval = write(WC->serv_sock, &buf[bytes_written],
 242                                nbytes - bytes_written);
 243                 if (retval < 1) {
 244                         lprintf(1, "Server connection broken: %s\n",
 245                                 strerror(errno));
 246                         close(WC->serv_sock);
 247                         WC->serv_sock = (-1);
 248                         WC->connected = 0;
 249                         WC->logged_in = 0;
 250                         return;
 251                 }
 252                 bytes_written = bytes_written + retval;
 253         }
 254 }
 255
 256
 257 /*
 258  *  send line to server
 259  *  string the line to send to the citadel server
 260  */
 261 void serv_puts(const char *string)
 262 {
 263         wcsession *WCC = WC;
 264 #ifdef SERV_TRACE
 265         lprintf(9, "%3d<%s\n", WC->serv_sock, string);
 266 #endif
 267         FlushStrBuf(WCC->ReadBuf);
 268         WCC->ReadPos = NULL;
 269
 270         serv_write(string, strlen(string));
 271         serv_write("\n", 1);
 272 }
 273
 274 /*
 275  *  send line to server
 276  *  string the line to send to the citadel server
 277  */
 278 void serv_putbuf(const StrBuf *string)
 279 {
 280         wcsession *WCC = WC;
 281 #ifdef SERV_TRACE
 282         lprintf(9, "%3d<%s\n", WC->serv_sock, ChrPtr(string));
 283 #endif
 284         FlushStrBuf(WCC->ReadBuf);
 285         WCC->ReadPos = NULL;
 286
 287         serv_write(ChrPtr(string), StrLength(string));
 288         serv_write("\n", 1);
 289 }
 290
 291
 292 /*
 293  *  convenience function to send stuff to the server
 294  *  format the formatstring
 295  *  ... the entities to insert into format
 296  */
 297 void serv_printf(const char *format,...)
 298 {
 299         wcsession *WCC = WC;
 300         va_list arg_ptr;
 301         char buf[SIZ];
 302         size_t len;
 303
 304         FlushStrBuf(WCC->ReadBuf);
 305         WCC->ReadPos = NULL;
 306
 307         va_start(arg_ptr, format);
 308         vsnprintf(buf, sizeof buf, format, arg_ptr);
 309         va_end(arg_ptr);
 310
 311         len = strlen(buf);
 312         buf[len++] = '\n';
 313         buf[len] = '\0';
 314         serv_write(buf, len);
 315 #ifdef SERV_TRACE
 316         lprintf(9, "<%s", buf);
 317 #endif
 318 }
 319