Initial import of the CDE 2.1.30 sources from the Open Group.

cde/lib/tt/slib/mp_self_procid.C

@@ -0,0 +1,229 @@
+//%%  (c) Copyright 1993, 1994 Hewlett-Packard Company			
+//%%  (c) Copyright 1993, 1994 International Business Machines Corp.	
+//%%  (c) Copyright 1993, 1994 Sun Microsystems, Inc.			
+//%%  (c) Copyright 1993, 1994 Novell, Inc. 				
+//%%  $XConsortium: mp_self_procid.C /main/3 1995/10/23 12:00:55 rswiston $ 			 				
+/*
+ * @(#)mp_self_procid.cc	1.3 93/07/25
+ * 
+ * Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
+ */
+#include <unistd.h>
+#include <errno.h>
+#include "mp_self_procid.h"
+#include "mp_s_mp.h"
+#include "mp/mp_session.h"
+#include "mp/mp_message.h"
+#include "mp/mp_arg.h"
+#include "mp_s_pattern.h"
+#include "util/tt_global_env.h"
+#include "util/tt_host.h"
+#include "util/tt_port.h"
+#include "util/tt_trace.h"
+
+_Tt_self_procid::_Tt_self_procid()
+{
+}
+
+_Tt_self_procid::~_Tt_self_procid()
+{
+}
+
+Tt_status
+_Tt_self_procid::init()
+{
+	_id = _tt_s_mp->alloc_procid_key();
+	_id = _id.cat(" ").cat(_tt_s_mp->initial_session->address_string());
+	_pid = getpid();
+	// XXX Probably could just set _version and return at this point
+	
+	// _Tt_s_procid::init() expects _proc_host_ipaddr to be initialized
+	if (! _tt_global->get_local_host(_proc_host)) {
+		return(TT_ERR_NOMP);
+	}
+	_proc_host_ipaddr = _proc_host->addr();
+	return _Tt_s_procid::init();
+}
+
+//
+// We just go ahead and process the messages when we signal ourself
+// that we have new messages.
+//
+Tt_status
+_Tt_self_procid::signal_new_message()
+{
+	// XXX do we need to muck with _TT_PROC_SIGNALLED?  I think not.
+	_Tt_next_message_args args;
+	Tt_status status = next_message( args );
+	_Tt_message_list_cursor msgC( args.msgs );
+
+	while (status == TT_OK) {
+		//
+		// In theory, we should at this point do the things
+		// that _Tt_c_procid::next_message() and tt_message_receive()
+		// do: check the queue for file-scoped messages,
+		// and run pattern callbacks.  But ttsession declares
+		// no ptypes, and we lack the client-side machinery
+		// for callbacks.  So we use our own.
+		//
+		msgC.reset();
+		while (msgC.next()) {
+			_process_msg( *msgC );
+		}
+		status = next_message( args );
+	}
+	if (status == TT_WRN_NOTFOUND) {
+		return TT_OK;
+	}
+	return status;
+}
+
+Tt_callback_action
+_Tt_self_procid::handle_Session_Trace(
+	const _Tt_message_ptr &msg,
+	void		      *proc
+)
+{
+	return ((_Tt_self_procid *)proc)->_handle_Session_Trace( msg );
+}
+
+Tt_callback_action
+_Tt_self_procid::observe_Saved(
+	const _Tt_message_ptr &msg,
+	void		      *proc
+)
+{
+	return ((_Tt_self_procid *)proc)->_observe_Saved( msg );
+}
+
+_Tt_s_pattern *
+_Tt_self_procid::s_pattern_create()
+{
+	_Tt_s_pattern *pat = new _Tt_s_pattern();
+	pat->set_id(_tt_s_mp->initial_session->address_string());
+	return pat;
+}
+
+//
+// This is a very simple callback server-side pattern callback scheme.
+// It does not do everything that client-side callbacks do.
+//
+Tt_status
+_Tt_self_procid::_process_msg(
+	const _Tt_message_ptr &msg
+)
+{
+	_Tt_string pat_id = msg->pattern_id();
+	if (pat_id.len() == 0) {
+		return TT_OK;
+	}
+	_Tt_pattern_list_cursor patC( _patterns );
+	while (patC.next()) {
+		if (patC->id() == pat_id) {
+			if (patC->server_callback != 0) {
+				if (    (*(patC->server_callback))( msg, this )
+				     == TT_CALLBACK_PROCESSED)
+				{
+					break;
+				}
+			}
+		}
+	}
+	return TT_OK;
+}
+
+Tt_status
+_Tt_self_procid::_reply(
+	const _Tt_message_ptr &msg
+)
+{
+	return update_message( msg, TT_HANDLED );
+}
+
+Tt_status
+_Tt_self_procid::_fail(
+	const _Tt_message_ptr &msg,
+	int return_status
+)
+{
+	Tt_status status = msg->set_status( return_status );
+	if (status != TT_OK) {
+		return status;
+	}
+	return update_message( msg, TT_FAILED );
+}
+
+Tt_status
+_Tt_self_procid::update_message(
+	const _Tt_message_ptr &msg,
+	Tt_state	       new_state
+)
+{
+	//
+	// This is the sort of checking done by
+	// _Tt_c_procid::update_message().
+	//
+	if (msg->message_class() != TT_REQUEST) {
+		return TT_ERR_CLASS;
+	}
+	if (msg->handler().is_null()) {
+		return TT_ERR_NOTHANDLER;
+	}
+	_Tt_procid_ptr me = (_Tt_procid *)this;
+	if (! me->is_equal( msg->handler() )) {
+		return TT_ERR_NOTHANDLER;
+	}
+	switch (msg->state()) {
+	      case TT_FAILED:
+	      case TT_HANDLED:
+		return(TT_ERR_INVALID);
+	      default:
+		break;
+	}
+	return _Tt_s_procid::update_message( msg, new_state );
+}
+
+Tt_callback_action
+_Tt_self_procid::_handle_Session_Trace(
+	const _Tt_message_ptr &msg
+)
+{
+	_Tt_arg_list_ptr args = new _Tt_arg_list( *msg->args() );
+	_Tt_arg_list_cursor argC( args );
+	if (! argC.next()) {
+		_fail( msg, TT_DESKTOP_EPROTO );
+		return TT_CALLBACK_PROCESSED;
+	}
+	_Tt_string script;
+	Tt_status status = (*argC)->data_string( script );
+	if (status != TT_OK) {
+		_fail( msg, (int)status );
+		return TT_CALLBACK_PROCESSED;
+	}
+	if ((script.len() == 0) && (msg->file().len() > 0)) {
+		script = _tt_network_path_to_local_path(msg->file());
+	}
+	if (argC.next()) {
+		_fail( msg, TT_DESKTOP_ENOTSUP );
+		return TT_CALLBACK_PROCESSED;
+	}
+	if (_tt_putenv( TRACE_SCRIPT, script ) == 0) {
+		_fail( msg, TT_DESKTOP_ENOMEM );
+		return TT_CALLBACK_PROCESSED;
+	}
+	tt_trace_control( 0 );
+	tt_trace_control( 1 );
+	_reply( msg );
+	return TT_CALLBACK_PROCESSED;
+}
+
+Tt_callback_action
+_Tt_self_procid::_observe_Saved(
+	const _Tt_message_ptr &
+)
+{
+	if (kill( getpid(), SIGTYPES ) < 0) {
+		_tt_syslog(0, LOG_ERR, "kill(): %m");
+	}
+	return TT_CALLBACK_PROCESSED;
+}