lib/mr_connect.c

   1 /* $Id$
   2  *
   3  * This routine is part of the client library.  It handles
   4  * creating a connection to the moira server.
   5  *
   6  * Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
   7  * For copying and distribution information, please see the file
   8  * <mit-copyright.h>.
   9  */
  10
  11 #include <mit-copyright.h>
  12 #include <moira.h>
  13 #include <moira_site.h>
  14 #include "mr_private.h"
  15
  16 #include <sys/types.h>
  17
  18 #include <errno.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #ifdef HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25
  26 #ifndef _WIN32
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <netdb.h>
  30 #ifndef closesocket
  31 #define closesocket close
  32 #endif
  33 #ifndef SOCKET_ERROR
  34 #define SOCKET_ERROR -1
  35 #endif
  36 #endif
  37
  38 #ifdef HAVE_HESIOD
  39 #include <hesiod.h>
  40 #endif
  41
  42 RCSID("$Header$");
  43
  44 #define DEFAULT_SERV "moira_db"
  45 #define DEFAULT_PORT 775
  46
  47 int _mr_conn = 0;
  48 static char *mr_server_host = NULL;
  49
  50 /* mrgdb compatibility magic
  51
  52    The data looks like this:
  53
  54    client -> server
  55      00000036                           [length of rest of packet]
  56      00000004                           [number of fields]
  57      01 01 01 01                        [types of fields: 4 strings]
  58      "server_id\0parms\0host\0user\0"   [field names]
  59      00000001                           [length of null-terminated server_id]
  60      "\0"                               [server_id: ignored anyway]
  61      00000001                           [length of null-terminated parms]
  62      "\0"                               [parms: ignored anyway]
  63      00000001                           [length of null-terminated client host]
  64      "\0"                               [host: ignored anyway]
  65      00000001                           [length of null-terminated client name]
  66      "\0"                               [user: ignored anyway]
  67
  68    server -> client
  69      00000031                           [length of rest of packet]
  70      00000003                           [number of fields]
  71      00 01 01                           [types of fields: int and 2 strings]
  72      "disposition\0server_id\0parms\0"  [field names]
  73      00000001                           [GDB_ACCEPTED]
  74      00000001                           [length of null-terminated server_id]
  75      "\0"                               [server_id: ignored anyway]
  76      00000001                           [length of null-terminated parms]
  77      "\0"                               [parms: ignored anyway]
  78
  79 */
  80
  81 static char challenge[58] = "\0\0\0\066\0\0\0\004\001\001\001\001server_id\0parms\0host\0user\0\0\0\0\001\0\0\0\0\001\0\0\0\0\001\0\0\0\0\001\0";
  82 static char response[53] = "\0\0\0\061\0\0\0\003\0\001\001disposition\0server_id\0parms\0\0\0\0\001\0\0\0\001\0\0\0\0\001\0";
  83
  84 /*
  85  * Open a connection to the moira server.  Looks for the server name
  86  * 1) passed as an argument, 2) in environment variable, 3) by hesiod
  87  * 4) compiled in default
  88  */
  89
  90 int mr_connect(char *server)
  91 {
  92   char *port, **pp, *sbuf = NULL;
  93
  94   if (_mr_conn)
  95     return MR_ALREADY_CONNECTED;
  96   if (!mr_inited)
  97     mr_init();
  98
  99   if (!server || (strlen(server) == 0))
 100     server = getenv("MOIRASERVER");
 101
 102 #ifdef HAVE_HESIOD
 103   if (!server || (strlen(server) == 0))
 104     {
 105       pp = hes_resolve("moira", "sloc");
 106       if (pp)
 107         server = *pp;
 108     }
 109 #endif
 110
 111   if (!server || (strlen(server) == 0))
 112     server = MOIRA_SERVER;
 113
 114   if (strchr(server, ':'))
 115     {
 116       int len = strcspn(server, ":");
 117       sbuf = malloc(len + 1);
 118       strncpy(sbuf, server, len);
 119       sbuf[len] = '\0';
 120       port = strchr(server, ':') + 1;
 121       server = sbuf;
 122     }
 123   else
 124     port = strchr(MOIRA_SERVER, ':') + 1;
 125
 126   _mr_conn = mr_connect_internal(server, port);
 127   free(sbuf);
 128   if (!_mr_conn)
 129     return MR_CANT_CONNECT;
 130
 131   return MR_SUCCESS;
 132 }
 133
 134 int mr_connect_internal(char *server, char *port)
 135 {
 136   int size, more;
 137   struct sockaddr_in target;
 138   struct hostent *shost;
 139   char actualresponse[53];
 140   char *host = NULL;
 141   int fd = SOCKET_ERROR;
 142   int ok = 0;
 143
 144   shost = gethostbyname(server);
 145   if (!shost)
 146     goto cleanup;
 147
 148   /* Get the host info in case some library decides to clobber shost. */
 149   memcpy(&target.sin_addr, shost->h_addr, shost->h_length);
 150   target.sin_family = shost->h_addrtype;
 151   host = strdup(shost->h_name);
 152
 153   if (port[0] == '#')
 154     target.sin_port = htons((unsigned short)atoi(port + 1));
 155   else
 156     {
 157       struct servent *s;
 158       target.sin_port = 0;
 159       s = getservbyname(port, "tcp");
 160       if (s)
 161         target.sin_port = s->s_port;
 162 #ifdef HAVE_HESIOD
 163       if (!target.sin_port)
 164         {
 165           s = hes_getservbyname(port, "tcp");
 166           if (s)
 167             target.sin_port = s->s_port;
 168         }
 169 #endif
 170       if (!target.sin_port && !strcasecmp(port, DEFAULT_SERV))
 171         target.sin_port = htons(DEFAULT_PORT);
 172       if (!target.sin_port)
 173         goto cleanup;
 174     }
 175
 176   fd = socket(AF_INET, SOCK_STREAM, 0);
 177   if (fd < 0)
 178     goto cleanup;
 179
 180   if (connect(fd, (struct sockaddr *)&target, sizeof(target)) < 0)
 181     goto cleanup;
 182
 183   /* Do magic mrgdb initialization */
 184   size = send(fd, challenge, sizeof(challenge), 0);
 185   if (size != sizeof(challenge))
 186     goto cleanup;
 187   for (size = 0; size < sizeof(actualresponse); size += more)
 188     {
 189       more = recv(fd, actualresponse + size, sizeof(actualresponse) - size, 0);
 190       if (more <= 0)
 191         break;
 192     }
 193   if (size != sizeof(actualresponse))
 194     goto cleanup;
 195   if (memcmp(actualresponse, response, sizeof(actualresponse)))
 196     goto cleanup;
 197
 198   ok = 1;
 199   mr_server_host = host;
 200
 201  cleanup:
 202   if (!ok)
 203     {
 204       if (host)
 205         free(host);
 206       if (fd != SOCKET_ERROR)
 207         closesocket(fd);
 208       return 0;
 209     }
 210   /* You win */
 211   return fd;
 212 }
 213
 214 int mr_disconnect(void)
 215 {
 216   CHECK_CONNECTED;
 217   closesocket(_mr_conn);
 218   _mr_conn = 0;
 219   free(mr_server_host);
 220   mr_server_host = NULL;
 221   return MR_SUCCESS;
 222 }
 223
 224 int mr_host(char *host, int size)
 225 {
 226   CHECK_CONNECTED;
 227
 228   /* If we are connected, mr_server_host points to a valid string. */
 229   strncpy(host, mr_server_host, size);
 230   host[size - 1] = '\0';
 231   return MR_SUCCESS;
 232 }
 233
 234 int mr_noop(void)
 235 {
 236   int status;
 237   mr_params params, reply;
 238
 239   CHECK_CONNECTED;
 240   params.u.mr_procno = MR_NOOP;
 241   params.mr_argc = 0;
 242   params.mr_argl = NULL;
 243   params.mr_argv = NULL;
 244
 245   if ((status = mr_do_call(&params, &reply)) == MR_SUCCESS)
 246     status = reply.u.mr_status;
 247
 248   mr_destroy_reply(reply);
 249
 250   return status;
 251 }
 252
 253
 254 /* Server side */
 255
 256 int mr_listen(char *port)
 257 {
 258   struct sockaddr_in sin;
 259   int s, on = 1;
 260
 261   memset(&sin, 0, sizeof(sin));
 262   if (port[0] == '#')
 263     sin.sin_port = atoi(port + 1);
 264   else
 265     {
 266       struct servent *s;
 267       s = getservbyname(port, "tcp");
 268       if (s)
 269         sin.sin_port = s->s_port;
 270       else
 271         return -1;
 272     }
 273
 274   s = socket(AF_INET, SOCK_STREAM, 0);
 275   if (s < 0)
 276     return -1;
 277   if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(int)) < 0)
 278     {
 279       closesocket(s);
 280       return -1;
 281     }
 282   if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
 283     {
 284       closesocket(s);
 285       return -1;
 286     }
 287   if (listen(s, 5) < 0)
 288     {
 289       closesocket(s);
 290       return -1;
 291     }
 292
 293   return s;
 294 }
 295
 296 /* mr_accept returns -1 on accept() error, 0 on bad connection,
 297    or connection fd on success */
 298
 299 int mr_accept(int s, struct sockaddr_in *sin)
 300 {
 301   int conn = -1, addrlen = sizeof(struct sockaddr_in), nread, status;
 302   char *buf = NULL;
 303
 304   while (conn < 0)
 305     {
 306       conn = accept(s, (struct sockaddr *)sin, &addrlen);
 307       if (conn < 0 && errno != EINTR
 308 #ifdef ERESTART
 309           && errno != ERESTART
 310 #endif
 311           )
 312         return -1;
 313     }
 314
 315   do
 316     status = mr_cont_accept(conn, &buf, &nread);
 317   while (status == -1);
 318
 319   return status;
 320 }
 321
 322 /* mr_cont_accept returns 0 if it has failed, an fd if it has succeeded,
 323    or -1 if it is still making progress */
 324
 325 int mr_cont_accept(int conn, char **buf, int *nread)
 326 {
 327   long len, more;
 328
 329   if (!*buf)
 330     {
 331       char lbuf[4];
 332       if (recv(conn, lbuf, 4, 0) != 4)
 333         {
 334           closesocket(conn);
 335           return 0;
 336         }
 337       getlong(lbuf, len);
 338       len += 4;
 339
 340       *buf = malloc(len);
 341       if (!*buf || len < 58)
 342         {
 343           closesocket(conn);
 344           free(*buf);
 345           return 0;
 346         }
 347       putlong(*buf, len);
 348       *nread = 4;
 349       return -1;
 350     }
 351   else
 352     getlong(*buf, len);
 353
 354   more = recv(conn, *buf + *nread, len - *nread, 0);
 355
 356   if (more == -1 && errno != EINTR)
 357     {
 358       closesocket(conn);
 359       free(*buf);
 360       return 0;
 361     }
 362
 363   *nread += more;
 364
 365   if (*nread != len)
 366     return -1;
 367
 368   if (memcmp(*buf + 4, challenge + 4, 34))
 369     {
 370       closesocket(conn);
 371       free(*buf);
 372       return 0;
 373     }
 374
 375   /* good enough */
 376   free(*buf);
 377
 378   if (send(conn, response, sizeof(response), 0) != sizeof(response))
 379     {
 380       closesocket(conn);
 381       return 0;
 382     }
 383   return conn;
 384 }