xemacs-beta: src/process-unix.c comparison

comparison src/process-unix.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	727739f917cb
children	ca9a9ec9c1c1

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 struct hostent *host_info_ptr = NULL;
 #ifdef TRY_AGAIN
 int count = 0;
 #endif
-memset (address, 0, sizeof (*address));
+xzero (*address);
 while (1)
 {
 #ifdef TRY_AGAIN
 if (count++ > 10) break;
 #ifndef BROKEN_CYGWIN
 h_errno = 0;
 #endif
 #endif
 /* Some systems can't handle SIGIO/SIGALARM in gethostbyname. */
 slow_down_interrupts ();
 host_info_ptr = gethostbyname ((char *) XSTRING_DATA (host));
 /**********************************************************************/
 /*              Process implementation methods                        */
 /**********************************************************************/
 /*
 * Allocate and initialize Lisp_Process->process_data
 */
 static void
 unix_alloc_process_data (struct Lisp_Process *p)
 }
 /*
 * Fork off a subprocess. P is a pointer to newly created subprocess
 * object. If this function signals, the caller is responsible for
 * deleting (and finalizing) the process object.
 *
 * The method must return PID of the new proces, a (positive??? ####) number
 * which fits into Lisp_Int. No return value indicates an error, the method
 * must signal an error instead.
 */
 EMACS_UNBLOCK_SIGNAL (signum);
 LONGJMP (send_process_frame, 1);
 }
 static void
-unix_send_process (volatile Lisp_Object proc, struct lstream* lstream)
+unix_send_process (Lisp_Object proc, struct lstream* lstream)
 {
 /* Use volatile to protect variables from being clobbered by longjmp.  */
 SIGTYPE (*volatile old_sigpipe) (int) = 0;
-volatile struct Lisp_Process *p = XPROCESS (proc);
+volatile Lisp_Object vol_proc = proc;
+struct Lisp_Process *volatile p = XPROCESS (proc);
 if (!SETJMP (send_process_frame))
 {
 /* use a reasonable-sized buffer (somewhere around the size of the
 	 stream buffer) so as to avoid inundating the stream with blocked
 	 data. */
 	  signal (SIGPIPE, old_sigpipe);
 	  if (writeret < 0)
 	    /* This is a real error.  Blocking errors are handled
 	       specially inside of the filedesc stream. */
 	    report_file_error ("writing to process",
-			       list1 (proc));
+			       list1 (vol_proc));
 	  while (Lstream_was_blocked_p (XLSTREAM (p->pipe_outstream)))
 	    {
 	      /* Buffer is full.  Wait, accepting input;
 		 that may allow the program
 		 to finish doing output and read more.  */
 p->status_symbol = Qexit;
 p->exit_code = 256; /* #### SIGPIPE ??? */
 p->core_dumped = 0;
 p->tick++;
 process_tick++;
-deactivate_process (proc);
+deactivate_process (vol_proc);
 error ("SIGPIPE raised on process %s; closed it",
 	     XSTRING_DATA (p->name));
 }
 old_sigpipe = (SIGTYPE (*) (int)) signal (SIGPIPE, send_process_trap);
 Lstream_flush (XLSTREAM (DATA_OUTSTREAM(p)));
 signal (SIGPIPE, old_sigpipe);
 }
 /* closing the outstream could result in SIGPIPE, so ignore it. */
 old_sigpipe = (SIGTYPE (*) (int)) signal (SIGPIPE, SIG_IGN);
 usid = event_stream_delete_stream_pair (p->pipe_instream, p->pipe_outstream);
 signal (SIGPIPE, old_sigpipe);
 UNIX_DATA(p)->infd  = -1;
 return usid;
 }
 kill_retval = kill (XINT (p->pid), signo) ? errno : 0;
 }
 else
 {
 /* gid may be a pid, or minus a pgrp's number */
-#ifdef TIOCSIGSEND
+#if defined (TIOCSIGNAL) || defined (TIOCSIGSEND)
 if (current_group)
-	kill_retval = ioctl (UNIX_DATA(p)->infd, TIOCSIGSEND, signo);
+	{
+#ifdef (TIOCSIGNAL)
+	  kill_retval = ioctl (UNIX_DATA(p)->infd, TIOCSIGNAL, signo);
+#else /* ! defined (TIOCSIGNAL) */
+	  kill_retval = ioctl (UNIX_DATA(p)->infd, TIOCSIGSEND, signo);
+#endif /* ! defined (TIOCSIGNAL) */
+	}
 else
 	kill_retval = kill (- XINT (p->pid), signo) ? errno : 0;
-#else /* ! defined (TIOCSIGSEND) */
+#else /* ! (defined (TIOCSIGNAL) || defined (TIOCSIGSEND)) */
 kill_retval = EMACS_KILLPG (-gid, signo) ? errno : 0;
-#endif /* ! defined (TIOCSIGSEND) */
+#endif /* ! (defined (TIOCSIGNAL) || defined (TIOCSIGSEND)) */
 }
 if (kill_retval < 0 && errno == EINVAL)
-error ("Signal number %d is invalid for this system", make_int (signo));
+error ("Signal number %d is invalid for this system", signo);
 }
 /*
 * Kill any process in the system given its PID.
 *
 * Returns zero if a signal successfully sent, or
 if (address.sin_family == AF_INET)
 return build_string (inet_ntoa (address.sin_addr));
 else
 /* #### any clue what to do here? */
 return host;
 }
 /* open a TCP network connection to a given HOST/SERVICE.  Treated
 exactly like a normal process when reading and writing.  Only
 differences are in status display and process deletion.  A network
 connection has no PID; you cannot signal it.  All you can do is
 struct sockaddr_in address;
 int s, inch, outch;
 volatile int port;
 volatile int retry = 0;
 int retval;
 CHECK_STRING (host);
 if (!EQ (family, Qtcpip))
 error ("Unsupported protocol family \"%s\"",
 	   string_data (symbol_name (XSYMBOL (family))));
 set_socket_nonblocking_maybe (inch, port, "tcp");
 *vinfd = (void*)inch;
 *voutfd = (void*)outch;
 }
 #ifdef HAVE_MULTICAST
 /* Didier Verna <verna@inf.enst.fr> Nov. 28 1997.
 int one = 1; /* For REUSEADDR */
 int ret;
 volatile int retry = 0;
 CHECK_STRING (dest);
 CHECK_NATNUM (port);
 theport = htons ((unsigned short) XINT (port));
 CHECK_NATNUM (ttl);
 thettl = (unsigned char) XINT (ttl);
 if ((udp = getprotobyname ("udp")) == NULL)
 error ("No info available for UDP protocol");
 /* Init the sockets. Yes, I need 2 sockets. I couldn't duplicate one. */
 if ((rs = socket (PF_INET, SOCK_DGRAM, udp->p_proto)) < 0)
 report_file_error ("error creating socket", list1(name));
 if ((ws = socket (PF_INET, SOCK_DGRAM, udp->p_proto)) < 0)
 {
 close (rs);
 report_file_error ("error creating socket", list1(name));
 }
 /* This will be used for both sockets */
 bzero(&sa, sizeof(sa));
 sa.sin_family = AF_INET;
 sa.sin_port = theport;
 sa.sin_addr.s_addr = htonl (inet_addr ((char *) XSTRING_DATA (dest)));
 /* Socket configuration for reading ------------------------ */
 /* Multiple connections from the same machine. This must be done before
 bind. If it fails, it shouldn't be fatal. The only consequence is that
 people won't be able to connect twice from the same machine. */
 if (setsockopt (rs, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))
 < 0)
 warn_when_safe (Qmulticast, Qwarning, "Cannot reuse socket address");
 /* bind socket name */
 if (bind (rs, (struct sockaddr *)&sa, sizeof(sa)))
 {
 close (rs);
 close (ws);
 report_file_error ("error binding socket", list2(name, port));
 }
 /* join multicast group */
 imr.imr_multiaddr.s_addr = htonl (inet_addr ((char *) XSTRING_DATA (dest)));
 imr.imr_interface.s_addr = htonl (INADDR_ANY);
 if (setsockopt (rs, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 		 (char *) &imr, sizeof (struct ip_mreq)) < 0)
 {
 close (ws);
 close (rs);
 report_file_error ("error adding membership", list2(name, dest));
 }
 /* Socket configuration for writing ----------------------- */
 /* Normaly, there's no 'connect' in multicast, since we use preferentialy
 'sendto' and 'recvfrom'. However, in order to handle this connection in
 the process-like way it is done for TCP, we must be able to use 'write'
 instead of 'sendto'. Consequently, we 'connect' this socket. */
 /* See open-network-stream-internal for comments on this part of the code */
 slow_down_interrupts ();
 loop:
 /* A system call interrupted with a SIGALRM or SIGIO comes back
 here, with can_break_system_calls reset to 0. */
 SETJMP (break_system_call_jump);
 if (QUITP)
 {
 speed_up_interrupts ();
 REALLY_QUIT;
 /* In case something really weird happens ... */
 slow_down_interrupts ();
 }
 /* Break out of connect with a signal (it isn't otherwise possible).
 Thus you don't get screwed with a hung network. */
 can_break_system_calls = 1;
 ret = connect (ws, (struct sockaddr *) &sa, sizeof (sa));
 can_break_system_calls = 0;
 if (ret == -1 && errno != EISCONN)
 {
 int xerrno = errno;
 if (errno == EINTR)
 	goto loop;
 if (errno == EADDRINUSE && retry < 20)
 	{
 	  /* A delay here is needed on some FreeBSD systems,
 	     and it is harmless, since this retrying takes time anyway
 	     and should be infrequent.
 	     `sleep-for' allowed for quitting this loop with interrupts
 	     slowed down so it can't be used here.  Async timers should
 	     already be disabled at this point so we can use `sleep'. */
 	  sleep (1);
 	  retry++;
 	  goto loop;
 	}
 close (rs);
 close (ws);
 speed_up_interrupts ();
 errno = xerrno;
 report_file_error ("error connecting socket", list2(name, port));
 }
 speed_up_interrupts ();
 /* scope */
 if (setsockopt (ws, IPPROTO_IP, IP_MULTICAST_TTL,
 		  (char *) &thettl, sizeof (thettl)) < 0)
 {
 close (rs);
 close (ws);
 report_file_error ("error setting ttl", list2(name, ttl));
 }
 set_socket_nonblocking_maybe (rs, theport, "udp");
 *vinfd = (void*)rs;
 *voutfd = (void*)ws;
 }

Mercurial > hg > xemacs-beta

comparison src/process-unix.c @ 272:c5d627a313b1 r21-0b34