hunt/huntd/ctl_transact.c

   1 /*      $NetBSD: ctl_transact.c,v 1.5 2002/09/20 20:54:16 mycroft Exp $ */
   2 /*
   3  * Copyright (c) 1983 Regents of the University of California.
   4  * All rights reserved.  The Berkeley software License Agreement
   5  * specifies the terms and conditions for redistribution.
   6  */
   7
   8 #include "bsd.h"
   9
  10 #if     defined(TALK_43) || defined(TALK_42)
  11
  12 #include <sys/cdefs.h>
  13 #ifndef lint
  14 #if 0
  15 static char sccsid[] = "@(#)ctl_transact.c      5.2 (Berkeley) 3/13/86";
  16 #else
  17 __RCSID("$NetBSD: ctl_transact.c,v 1.5 2002/09/20 20:54:16 mycroft Exp $");
  18 #endif
  19 #endif /* not lint */
  20
  21 #include <sys/time.h>
  22 #include <unistd.h>
  23 #include "hunt.h"
  24 #include "talk_ctl.h"
  25
  26 #define CTL_WAIT 2      /* time to wait for a response, in seconds */
  27 #define MAX_RETRY 5
  28
  29 /*
  30  * SOCKDGRAM is unreliable, so we must repeat messages if we have
  31  * not received an acknowledgement within a reasonable amount
  32  * of time
  33  */
  34 void
  35 ctl_transact(target, msg, type, rp)
  36         struct in_addr target;
  37         CTL_MSG msg;
  38         int type;
  39         CTL_RESPONSE *rp;
  40 {
  41         struct pollfd set[1];
  42         int nready, cc, retries;
  43
  44         nready = 0;
  45         msg.type = type;
  46         daemon_addr.sin_addr = target;
  47         daemon_addr.sin_port = daemon_port;
  48         set[0].fd = ctl_sockt;
  49         set[0].events = POLLIN;
  50
  51         /*
  52          * Keep sending the message until a response of
  53          * the proper type is obtained.
  54          */
  55         do {
  56                 /* resend message until a response is obtained */
  57                 for (retries = MAX_RETRY; retries > 0; retries -= 1) {
  58                         cc = sendto(ctl_sockt, (char *)&msg, sizeof (msg), 0,
  59                             (struct sockaddr *)&daemon_addr, sizeof (daemon_addr));
  60                         if (cc != sizeof (msg)) {
  61                                 if (errno == EINTR)
  62                                         continue;
  63                                 p_error("Error on write to talk daemon");
  64                         }
  65                         nready = poll(set, 1, CTL_WAIT * 1000);
  66                         if (nready < 0) {
  67                                 if (errno == EINTR)
  68                                         continue;
  69                                 p_error("Error waiting for daemon response");
  70                         }
  71                         if (nready != 0)
  72                                 break;
  73                 }
  74                 if (retries <= 0)
  75                         break;
  76                 /*
  77                  * Keep reading while there are queued messages
  78                  * (this is not necessary, it just saves extra
  79                  * request/acknowledgements being sent)
  80                  */
  81                 do {
  82                         cc = recv(ctl_sockt, (char *)rp, sizeof (*rp), 0);
  83                         if (cc < 0) {
  84                                 if (errno == EINTR)
  85                                         continue;
  86                                 p_error("Error on read from talk daemon");
  87                         }
  88                         /* an immediate poll */
  89                         nready = poll(set, 1, 0);
  90                 } while (nready > 0 && (
  91 #ifdef  TALK_43
  92                     rp->vers != TALK_VERSION ||
  93 #endif
  94                     rp->type != type));
  95         } while (
  96 #ifdef  TALK_43
  97             rp->vers != TALK_VERSION ||
  98 #endif
  99             rp->type != type);
 100         rp->id_num = ntohl(rp->id_num);
 101 #ifdef  TALK_43
 102         rp->addr.sa_family = ntohs(rp->addr.sa_family);
 103 # else
 104         rp->addr.sin_family = ntohs(rp->addr.sin_family);
 105 # endif
 106 }
 107 #endif