lib/mr_ops.c

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Header$
   5  *
   6  *      Copyright (C) 1987, 1989, 1990 by the Massachusetts Institute of
   7  *      Technology
   8  *      For copying and distribution information, please see the file
   9  *      <mit-copyright.h>.
  10  *
  11  *      This routine is part of the client library.  It handles
  12  *      the protocol operations: invoking an update and getting the
  13  *      MR message of the day.
  14  */
  15
  16 #ifndef lint
  17 static char *rcsid_sms_do_update_c = "$Header$";
  18 #endif lint
  19
  20 #include <mit-copyright.h>
  21 #include "mr_private.h"
  22
  23
  24 /* Invoke a DCM update. */
  25
  26 int mr_do_update()
  27 {
  28     int status;
  29     mr_params param_st;
  30     struct mr_params *params = NULL;
  31     struct mr_params *reply = NULL;
  32
  33     CHECK_CONNECTED;
  34     params = &param_st;
  35     params->mr_version_no = sending_version_no;
  36     params->mr_procno = MR_DO_UPDATE;
  37     params->mr_argc = 0;
  38     params->mr_argl = NULL;
  39     params->mr_argv = NULL;
  40
  41     if ((status = mr_do_call(params, &reply)) == 0)
  42         status = reply->mr_status;
  43
  44     mr_destroy_reply(reply);
  45
  46     return status;
  47 }
  48
  49
  50 /* Get the MR motd.  This returns an MR status, and motd will either
  51  * point to NULL or the motd in a static buffer.
  52  */
  53
  54 int mr_motd(motd)
  55 char **motd;
  56 {
  57     int status;
  58     mr_params param_st;
  59     struct mr_params *params = NULL;
  60     struct mr_params *reply = NULL;
  61     static char buffer[1024];
  62
  63     *motd = NULL;
  64     CHECK_CONNECTED;
  65     params = &param_st;
  66     params->mr_version_no = sending_version_no;
  67     params->mr_procno = MR_MOTD;
  68     params->mr_argc = 0;
  69     params->mr_argl = NULL;
  70     params->mr_argv = NULL;
  71
  72     if ((status = mr_do_call(params, &reply)))
  73       goto punt;
  74
  75     while ((status = reply->mr_status) == MR_MORE_DATA) {
  76         if (reply->mr_argc > 0) {
  77             strncpy(buffer, reply->mr_argv[0], sizeof(buffer));
  78             *motd = buffer;
  79         }
  80         mr_destroy_reply(reply);
  81         reply = NULL;
  82
  83         initialize_operation(_mr_recv_op, mr_start_recv, &reply,
  84                              (int (*)())NULL);
  85         queue_operation(_mr_conn, CON_INPUT, _mr_recv_op);
  86
  87         mr_complete_operation(_mr_recv_op);
  88         if (OP_STATUS(_mr_recv_op) != OP_COMPLETE) {
  89             mr_disconnect();
  90             status = MR_ABORTED;
  91             return(status);
  92         }
  93     }
  94  punt:
  95     mr_destroy_reply(reply);
  96     /* for backwards compatability */
  97     if (status == MR_UNKNOWN_PROC)
  98       return(0);
  99     else
 100       return(status);
 101 }
 102
 103
 104 /* Tell the library to take care of another input source while it is
 105  * processing a query.  For instance, an X toolkit application would
 106  * do something like
 107  *    mr_set_alternate_input(ConnectionNumber(XtDisplay(widget)), doxinput);
 108  * where doxinput is defined as:
 109  *    doxinput() {
 110  *      extern Widget toplevel;
 111  *      XEvent event;
 112  *      while (XPending(XtDisplay(toplevel))) {
 113  *          XNextEvent(XtDisplay(toplevel), &event);
 114  *          XtDispatchEvent(&event);
 115  *      }
 116  *      XFlush(XtDisplay(toplevel));
 117  *    }
 118  */
 119
 120 static int mr_alternate_input = 0;
 121 static int (*mr_alternate_handler)();
 122
 123 int mr_set_alternate_input(fd, proc)
 124 int fd;
 125 int (*proc)();
 126 {
 127     if (mr_alternate_input != 0)
 128       return(MR_ALREADY_CONNECTED);
 129     mr_alternate_input = fd;
 130     mr_alternate_handler = proc;
 131     return(MR_SUCCESS);
 132 }
 133
 134
 135 /* This is used by the parts of the library that must wait for GDB.  It
 136  * handles alternate input streams (such as X) as well.
 137  */
 138
 139 mr_complete_operation(op)
 140 OPERATION op;
 141 {
 142     long infd, outfd, exfd;
 143     int rc;
 144
 145     gdb_progress();             /* try for an immediate completion */
 146
 147     if (mr_alternate_input == 0)
 148       return(complete_operation(op));
 149
 150     infd = (1<<mr_alternate_input);
 151     outfd = exfd = 0;
 152
 153     while(op->status != OP_COMPLETE && op->status != OP_CANCELLED) {
 154         rc = con_select(mr_alternate_input, (fd_set *)&infd, (fd_set *)&outfd,
 155                           (fd_set *)&exfd, (struct timeval *)NULL);
 156         if (rc > 0 && mr_alternate_handler) {
 157             (*mr_alternate_handler)();
 158         }
 159     }
 160     return(op->status);
 161 }
 162