Diane Delgado's changes for a fixed table-locking order

[moira.git] / lib / mr_connect.c

diff --git a/lib/mr_connect.c b/lib/mr_connect.c
index 25ba36eac12fbe1cf11788df9234e0199b46156e..39ebcd45ffc1c3808e8f06005a55af03341bb15c 100644 (file)
--- a/lib/mr_connect.c
+++ b/lib/mr_connect.c
@@ -3,100 +3,124 @@
  *     $Author$
  *     $Header$
  *
- *     Copyright (C) 1987 by the Massachusetts Institute of Technology
+ *     Copyright (C) 1987, 1990 by the Massachusetts Institute of Technology
+ *     For copying and distribution information, please see the file
+ *     <mit-copyright.h>.
  *     
  *     This routine is part of the client library.  It handles
- * creating a connection to the sms server.
+ *     creating a connection to the mr server.
  */
 
 #ifndef lint
 static char *rcsid_sms_connect_c = "$Header$";
 #endif lint
 
-#include "sms_private.h"
+#include <mit-copyright.h>
+#include "mr_private.h"
+#include <moira_site.h>
+#include <string.h>
+
+static char *mr_server_host = 0;
 
 /*
- * Open a connection to the sms server.
+ * Open a connection to the mr server.  Looks for the server name
+ * 1) passed as an argument, 2) in environment variable, 3) by hesiod
+ * 4) compiled in default (from sms_app.h).
  */
 
-int sms_connect()
+int mr_connect(server)
+char *server;
 {
-       extern int errno;
-       
-       if (!sms_inited) sms_init();
+    extern int errno;
+    char *p, **pp, sbuf[256];
+    extern char *getenv(), **hes_resolve();
        
-       /* 
-        * should do a hesiod call to find the sms machine name & service
-        * number/name.
-        */
-       /* XXX gdb doesn't give real return codes. Can we trust errno?*/
-       errno = 0;
-       _sms_conn = start_server_connection(SMS_GDB_SERV, ""); 
-       if (_sms_conn == NULL) {
-               return errno;
-       }
-       return 0;
+    if (!mr_inited) mr_init();
+    if (_mr_conn) return MR_ALREADY_CONNECTED;
+               
+    if (!server || (strlen(server) == 0)) {
+       server = getenv("MOIRASERVER");
+    }
+
+#ifdef HESIOD
+    if (!server || (strlen(server) == 0)) {
+       pp = hes_resolve("moira", "sloc");
+       if (pp) server = *pp;
+    }
+#endif HESIOD
+
+    if (!server || (strlen(server) == 0)) {
+       server = MOIRA_SERVER;
+    }
+
+    if (!strchr(server, ':')) {
+       p = strchr(MOIRA_SERVER, ':');
+       p++;
+       sprintf(sbuf, "%s:%s", server, p);
+       server = sbuf;
+    }
+
+    errno = 0;
+    _mr_conn = start_server_connection(server, ""); 
+    if (_mr_conn == NULL)
+       return errno;
+    if (connection_status(_mr_conn) == CON_STOPPED) {
+       register status = connection_errno(_mr_conn);
+       if (!status) status = MR_CANT_CONNECT;
+       mr_disconnect();
+       return status;
+    }
+
+    /*
+     * stash hostname for later use
+     */
+
+    mr_server_host = strsave(server);
+    if (p = strchr(mr_server_host, ':'))
+       *p = 0;
+    mr_server_host = canonicalize_hostname(mr_server_host);
+    return 0;
 }
        
-int sms_disconnect()
+int mr_disconnect()
 {
-       if (!_sms_conn) {
-               return SMS_NOT_CONNECTED;
-       }
-       /* Is this guaranteed NOT to fail?? I don't believe it, but.. */
-       _sms_conn = sever_connection(_sms_conn);
-       return 0;
+    CHECK_CONNECTED;
+    _mr_conn = sever_connection(_mr_conn);
+    free(mr_server_host);
+    mr_server_host = 0;
+    return 0;
 }
 
-int sms_noop()
+int mr_host(host, size)
+  char *host;
+  int size;
 {
-       int status;
-       struct sms_params *parms = NULL;
-       struct sms_params *reply = NULL;
-       
-
-       parms = (struct sms_params *) malloc(sizeof(*parms));
-       
-       parms->sms_procno = SMS_NOOP;
-       parms->sms_argc = 0;
+    CHECK_CONNECTED;
 
-       if ((status = sms_do_call(parms, &reply)) || (status = reply->sms_status))
-               goto punt;
-       
-       
-punt:
-       sms_destroy_reply(reply);
-ok:
-       free(parms);
-       return status;
+    /* If we are connected, mr_server_host points to a valid string. */
+    strncpy(host, mr_server_host, size);
+    return(0);
 }
 
-int sms_shutdown(why)
-       char *why;
+int mr_noop()
 {
-       int status;
-       sms_params *parms=NULL;
-       sms_params *reply=NULL;
+    int status;
+    mr_params param_st;
+    struct mr_params *params = NULL;
+    struct mr_params *reply = NULL;
 
-       parms = (sms_params *) malloc(sizeof(*parms));
-       
-       parms->sms_procno = SMS_SHUTDOWN;
-       parms->sms_argc = 1;
-       parms->sms_argv = (char **)malloc(sizeof(char *) * 2);
-       parms->sms_argv[0] = why;
-       parms->sms_argv[1] = NULL;
-
-       if ((status = sms_do_call(parms, &reply)) || (status = reply->sms_status))
-               goto punt;
+    CHECK_CONNECTED;
+    params = &param_st;
+    params->mr_version_no = sending_version_no;
+    params->mr_procno = MR_NOOP;
+    params->mr_argc = 0;
+    params->mr_argl = NULL;
+    params->mr_argv = NULL;
        
+    if ((status = mr_do_call(params, &reply)) == 0)
+       status = reply->mr_status;
        
-punt:
-       sms_destroy_reply(reply);
-ok:
-       if(parms) {
-               if(parms->sms_argv)
-                       free(parms->sms_argv);
-               free(parms);
-       }
-       return status;
+    mr_destroy_reply(reply);
+
+    return status;
 }