386BSD 0.1 development

[unix-history] / usr / src / usr.bin / talk / ctl_transact.c

diff --git a/usr/src/usr.bin/talk/ctl_transact.c b/usr/src/usr.bin/talk/ctl_transact.c
index 39ab384..b5c1975 100644 (file)
--- a/usr/src/usr.bin/talk/ctl_transact.c
+++ b/usr/src/usr.bin/talk/ctl_transact.c
@@ -1,9 +1,47 @@
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+

 #ifndef lint
 #ifndef lint

-static char sccsid[] = "@(#)ctl_transact.c     1.3 (Berkeley) %G%";
-#endif
+static char sccsid[] = "@(#)ctl_transact.c     5.8 (Berkeley) 3/1/91";
+#endif /* not lint */

 
 

-#include "talk_ctl.h"
+#include <sys/types.h>
+#include <sys/socket.h>

 #include <sys/time.h>
 #include <sys/time.h>

+#include <netinet/in.h>
+#include <protocols/talkd.h>
+#include <errno.h>
+#include "talk_ctl.h"

 
 #define CTL_WAIT 2     /* time to wait for a response, in seconds */
 
 
 #define CTL_WAIT 2     /* time to wait for a response, in seconds */
 


@@ -12,18 +50,13 @@ static char sccsid[] = "@(#)ctl_transact.c  1.3 (Berkeley) %G%";
  * not recieved an acknowledgement within a reasonable amount
  * of time
  */
  * not recieved an acknowledgement within a reasonable amount
  * of time
  */

-ctl_transact(target, msg, type, response)
+ctl_transact(target, msg, type, rp)

        struct in_addr target;
        CTL_MSG msg;
        int type;
        struct in_addr target;
        CTL_MSG msg;
        int type;

-       CTL_RESPONSE *response;
+       CTL_RESPONSE *rp;

 {
 {

-       struct sockaddr junk;
-       int read_mask;
-       int ctl_mask;
-       int nready;
-       int cc;
-       int junk_size;
+       int read_mask, ctl_mask, nready, cc;

        struct timeval wait;
 
        msg.type = type;
        struct timeval wait;
 
        msg.type = type;


@@ -32,37 +65,37 @@ ctl_transact(target, msg, type, response)
        ctl_mask = 1 << ctl_sockt;
 
        /*
        ctl_mask = 1 << ctl_sockt;
 
        /*

-        * keep sending the message until a response of the right
-        * type is obtained
+        * Keep sending the message until a response of
+        * the proper type is obtained.

         */
        do {
                wait.tv_sec = CTL_WAIT;
                wait.tv_usec = 0;
         */
        do {
                wait.tv_sec = CTL_WAIT;
                wait.tv_usec = 0;

-
-               /* keep sending the message until a response is obtained */
+               /* resend message until a response is obtained */

                do {
                do {

-                       cc = sendto(ctl_sockt, (char *)&msg, sizeof(CTL_MSG), 0,
-                               &daemon_addr, sizeof(daemon_addr));
-                       if (cc != sizeof(CTL_MSG)) {
+                       cc = sendto(ctl_sockt, (char *)&msg, sizeof (msg), 0,
+                           (struct sockaddr *)&daemon_addr,
+                           sizeof (daemon_addr));
+                       if (cc != sizeof (msg)) {

                                if (errno == EINTR)
                                        continue;
                                p_error("Error on write to talk daemon");
                        }
                        read_mask = ctl_mask;
                                if (errno == EINTR)
                                        continue;
                                p_error("Error on write to talk daemon");
                        }
                        read_mask = ctl_mask;

-                       if ((nready = select(32, &read_mask, 0, 0, &wait)) < 0) {
+                       nready = select(32, &read_mask, 0, 0, &wait);
+                       if (nready < 0) {

                                if (errno == EINTR)
                                        continue;
                                p_error("Error waiting for daemon response");
                        }
                } while (nready == 0);
                                if (errno == EINTR)
                                        continue;
                                p_error("Error waiting for daemon response");
                        }
                } while (nready == 0);

-               /* keep reading while there are queued messages 
-                  (this is not necessary, it just saves extra
-                  request/acknowledgements being sent)
+               /*
+                * Keep reading while there are queued messages 
+                * (this is not necessary, it just saves extra
+                * request/acknowledgements being sent)

                 */
                do {
                 */
                do {

-                       junk_size = sizeof(junk);
-                       cc = recvfrom(ctl_sockt, (char *)response,
-                           sizeof (CTL_RESPONSE), 0, &junk, &junk_size);
+                       cc = recv(ctl_sockt, (char *)rp, sizeof (*rp), 0);

                        if (cc < 0) {
                                if (errno == EINTR)
                                        continue;
                        if (cc < 0) {
                                if (errno == EINTR)
                                        continue;


@@ -72,6 +105,9 @@ ctl_transact(target, msg, type, response)
                        /* an immediate poll */
                        timerclear(&wait);
                        nready = select(32, &read_mask, 0, 0, &wait);
                        /* an immediate poll */
                        timerclear(&wait);
                        nready = select(32, &read_mask, 0, 0, &wait);

-               } while (nready > 0 && response->type != type);
-       } while (response->type != type);
+               } while (nready > 0 && (rp->vers != TALK_VERSION ||
+                   rp->type != type));
+       } while (rp->vers != TALK_VERSION || rp->type != type);
+       rp->id_num = ntohl(rp->id_num);
+       rp->addr.sa_family = ntohs(rp->addr.sa_family);

 }
 }