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