



		    install.pl1                     08/05/86  1603.2rew 08/05/86  1535.9       83250



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        *                                                         *
        * Copyright (c) 1972 by Massachusetts Institute of        *
        * Technology and Honeywell Information Systems, Inc.      *
        *                                                         *
        *********************************************************** */



/* INSTALL - program to copy new tables into >system_control_1>update
   and signal the answering service to install them.

   Written by THVV
   Modified 750114 by PG to add command options for authorizations, etc.
   Modified 750614 by T. Casey to enable install of MGT
   Modified 760804 by THVV to eliminate response handler
   Modified 062377 by Robert Coren to add TTT to list of legal tables
   Modified 03/16/78 by C. D. Tavares to add RTDT
   Modified 12/26/81 by E. N. Kittlitz to use whotab instead of proj_admin_seg to send wakeup.
   Modified 1/2/82 by Benson I. Margulies for ttt installations through gate.
   Modified April 1982 by E. N. Kittlitz to not write original table.
   Modified July 1982 by E. N. Kittlitz to not use sc_stat_ (TOOLS), because this is an SSS program.
*/


/****^  HISTORY COMMENTS:
  1) change(86-05-02,Kissel), approve(86-07-23,MCR7460), audit(86-07-28,Ex),
     install(86-08-05,MR12.0-1115):
     Changed to accept the "nit" suffix for the DSA NIT.  It is handled just
     like the "ttt" suffix, but dsa_install_nit_ is called rather than
     installation_gate_$install_ttt
                                                   END HISTORY COMMENTS */


/* format: style4 */
install: proc;

/* entries */

dcl  com_err_ entry options (variable);
dcl  cu_$arg_count entry returns (fixed bin);
dcl  cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
dcl  dsa_install_nit_ entry (ptr, uns fixed bin (18), char (*), fixed bin (35));
dcl  expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35));
dcl  get_group_id_ entry returns (char (32));
dcl  get_process_id_ entry returns (bit (36));
dcl  get_wdir_ entry returns (char (168));		/* return working dir */
dcl  hcs_$delentry_seg entry (ptr, fixed bin (35));
dcl  hcs_$make_seg entry (char (*), char (*), char (*),
	fixed bin (5), ptr, fixed bin (35));
dcl  hcs_$wakeup entry (bit (*), fixed bin (71), fixed bin (71), fixed bin (35));
dcl  hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35));
dcl  initiate_file_ entry (char (*), char (*), bit (*), ptr, fixed bin (24), fixed bin (35));
dcl  installation_gate_$install_ttt entry (ptr, fixed bin (18) uns, char (*), fixed bin (35));
dcl  ioa_ entry options (variable);
dcl  pathname_ entry (char (*), char (*)) returns (char (168));
dcl  unique_chars_ entry (bit (*)) returns (char (15));
dcl  terminate_file_ entry (ptr, fixed bin (24), bit (*), fixed bin (35));

/* builtins */

dcl  (dim, divide, index, length, null, reverse, rtrim, substr) builtin;

/* external static */

dcl  error_table_$bad_arg fixed bin (35) ext static;
dcl  error_table_$badopt fixed bin (35) ext static;
dcl  error_table_$not_seg_type ext fixed bin (35) static;

/* static */

dcl  LEGAL_TYPES (7) char (4) aligned static options (constant) initial
	("sat", "pdt", "mgt", "cdt", "ttt", "rtdt", "nit");
dcl  sysdir char (64) int static init (">system_control_1");


/* automatic */

dcl  (idir char (80), copyname char (15));
dcl  (dir char (168), ename char (32));

dcl  (argno, i) fixed bin;
dcl  code fixed bin (35);
dcl  arg_length fixed bin (21);
dcl  lng fixed bin (21);
dcl  arg_ptr ptr;
dcl  bitcount fixed bin (24);
dcl  (segp, copyp) ptr;				/* ... */
dcl  suffix char (4) varying;				/* pdt, etc */
dcl  whoptr pointer;
dcl  answer character (256);
dcl  update_attributes_sw bit (1) aligned;
dcl  update_authorization_sw bit (1) aligned;

/* based */

dcl  arg_string char (arg_length) based (arg_ptr);

dcl  1 t based (segp) aligned,			/* dummy structure for seg. header */
       2 author like author_dcl.author;

dcl  1 segmnt based aligned,				/* structure to move_ stuff */
       2 words (lng) fixed bin;

/* ext static */

declare  whotab_$ ext bit (36) aligned;

/* include files */

%include access_mode_values;
%include author_dcl;
%include whotab;
%include terminate_file;
/* condition */

declare  cleanup condition;
declare  linkage_error condition;


/* - - - - - - - - - - - - - - - -- - - - - */


	update_attributes_sw, update_authorization_sw = ""b;

	on linkage_error begin;
	     call hcs_$initiate (sysdir, "whotab", "whotab_", 0, 0,
		whoptr, code);
	     if whoptr = null
	     then do;
		call com_err_ (code, "install", "cannot initiate ^a.", pathname_ (sysdir, "whotab"));
		go to RETURN;
	     end;
	end;

	whoptr = addr (whotab_$);
	revert linkage_error;

	call cu_$arg_ptr (1, arg_ptr, arg_length, code);	/* get name of segment */
	if code ^= 0 then do;
	     call com_err_ (code, "install", "Usage: install pathname -all(-a), -attributes(-attr), -authorization(-auth)");
	     return;
	end;

	call expand_pathname_ (arg_string, dir, ename, code);
	if code ^= 0 then do;
	     call com_err_ (code, "install", arg_string);
	     return;
	end;

	if index (ename, ".") = 0 then goto not_known_type;

	i = length (rtrim (ename));

	suffix = reverse (before (reverse (ename), "."));

	do i = 1 to dim (LEGAL_TYPES, 1) while (LEGAL_TYPES (i) ^= suffix);
	end;

	if i > dim (LEGAL_TYPES, 1) then do;
not_known_type:
	     call com_err_ (error_table_$not_seg_type, "install",
		"Table is not ^v(^a, ^)or ^a.  Installation refused.",
		dim (LEGAL_TYPES, 1) - 1, LEGAL_TYPES (*));
	     return;
	end;

	copyp, segp = null;
	on cleanup call clean_up;

	call initiate_file_ (dir, ename, R_ACCESS, segp, bitcount, code);
	if code ^= 0 then do;
	     call com_err_ (code, "install", "^a", pathname_ (dir, ename));
	     go to RETURN;				/* segp may be nonnull */
	end;

	if bitcount < 2304 then do;			/* check length of segment */
	     call ioa_ ("install: ^a less than 64 words long.", pathname_ (dir, ename));
	     go to RETURN;
	end;

/* read the arguments */

	do argno = 2 to cu_$arg_count ();
	     call cu_$arg_ptr (argno, arg_ptr, arg_length, code);
	     if code ^= 0 then go to no_more_args;

	     if arg_string = "-all" | arg_string = "-a" then
		update_attributes_sw, update_authorization_sw = "1"b;
	     else if arg_string = "-attributes" | arg_string = "-attr" then
		update_attributes_sw = "1"b;
	     else if arg_string = "-authorization" | arg_string = "-auth" then
		update_authorization_sw = "1"b;
	     else do;
		call com_err_ (error_table_$badopt, "install", "^a", arg_string);
		return;
	     end;
	end;

no_more_args:
	if argno = 2 then				/* if no options were given, use default */
	     update_attributes_sw = "1"b;		/* dft is -attr */

	lng = divide (bitcount + 35, 36, 17, 0);	/* get wordcount */

	if t.table = "TTT"
	then do;					/* The first of the easy variety */
						/* Note we ignore control arguments */
	     call installation_gate_$install_ttt (segp, (lng), answer, code);
	     if code ^= 0
	     then call com_err_ (code, "install", "^a installing ^a.",
		     answer, pathname_ (dir, ename));
	     else call ioa_ ("install: Installed ^a as system ttt.",
		     pathname_ (dir, ename));
	     go to RETURN;
	end;

	if t.table = "NIT"
	then do;					/* The next of the easy variety */
						/* Note we ignore control arguments */
	     /*** Get ready for problems. */

	     on linkage_error
		begin;
		code = error_table_$bad_arg;
		answer = "DSA is not enabled on this system.  ";
		goto NIT_ERROR;
	     end;

	     call dsa_install_nit_ (segp, (lng), answer, code);

	     revert linkage_error;

NIT_ERROR:
	     if code ^= 0
	     then call com_err_ (code, "install", "^a installing ^a.",
		     answer, pathname_ (dir, ename));
	     else call ioa_ ("install: Installed ^a as DSA system nit.",
		     pathname_ (dir, ename));
	     go to RETURN;
	end;

	idir = pathname_ (sysdir, "update");
	copyname = unique_chars_ (""b);		/* make up a name */

	call hcs_$make_seg (idir, copyname, "", 01010b, copyp, code);
	if copyp = null then do;			/* make null segment */
	     call com_err_ (code, "install", "can't create ^a>^a", idir, copyname);
	     go to RETURN;
	end;
	copyp -> segmnt = segp -> segmnt;		/* copy seg into update dir */
	copyp -> t.author.w_dir = get_wdir_ ();		/* set working dir into head of table */
	copyp -> t.author.proc_group_id = get_group_id_ (); /* Get name of this user (with tag) */
	copyp -> t.update_authorization = update_authorization_sw; /* now the controls */
	copyp -> t.update_attributes = update_attributes_sw; /* ... */

	call terminate_file_ (copyp, bitcount, TERM_FILE_TRUNC_BC_TERM, (0));
	copyp = null;

	call hcs_$wakeup ((whotab.installation_request_pid), whotab.installation_request_channel, 0, code);

RETURN:
	call clean_up;
	return;					/* done */

clean_up:
     procedure;
	if copyp ^= null
	then call hcs_$delentry_seg (copyp, (0));
	copyp = null;
	if segp ^= null
	then call terminate_file_ (segp, (0), TERM_FILE_TERM, (0));
	segp = null;
     end clean_up;

     end install;




		    install_ttt_.pl1                03/15/89  0844.4r w 03/15/89  0800.6      126495



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1987                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        *                                                         *
        * Copyright (c) 1972 by Massachusetts Institute of        *
        * Technology and Honeywell Information Systems, Inc.      *
        *                                                         *
        *********************************************************** */




/****^  HISTORY COMMENTS:
  1) change(85-07-15,EJSharpe), approve(86-02-20,MCR7303),
     audit(85-11-07,Coren), install(86-04-23,MR12.0-1045):
     add security auditing
  2) change(87-03-17,LJAdams), approve(87-04-03,MCR7646),
     audit(87-05-05,Gilcrease), install(87-05-14,MR12.1-1030):
     Added check for current TTT_version_3.
  3) change(88-01-26,Brunelle), approve(88-01-26,MCR7813),
     audit(88-10-05,Blair), install(88-10-17,MR12.2-1171):
     Upgrade to TTT_version_4 which encompassed c_chars expansion.
                                                   END HISTORY COMMENTS */


/* format: style2 */
install_ttt_:
     procedure (TTT_pointer, Wordcount, Complaint, Code);

/* install_ttt_ installs a ttt in ring 1 for an administrator.

   taken from up_ttt_ of december 1981

   This program checks a candidate TTT for acceptability and installs it.
   Written 6/27/77 by Robert Coren
   Bug fix August 1977 by T. Casey
   Bug fix July 1978 by T. Casey
   Fix to check offset of function key table in each tte 5/29/81 by Suzanne Krupp
   Modified November 1981, E. N. Kittlitz.  user_table_entry conversion.
   Modified December 1981, Benson I. Margulies. Renamed to install_ttt_
            and changed to install to ring 1 and stop cross-checking with cdt
   Modified December 1984, Keith Loepere, for new version create_branch_info.
*/

/* This program is called through install_gate_ */


	declare TTT_pointer		 pointer;		/* Supplied segment */
	declare Wordcount		 fixed bin (18) unsigned;
	declare Complaint		 character (*);	/* explanation of rejection */
	declare Code		 fixed bin (35);	/* status code */

/* ENTRIES */

	dcl     access_audit_r1_$log_general
				 entry options (variable);
	dcl     admin_gate_$syserr_error_code
				 entry options (variable);
	dcl     initiate_file_	 entry (char (*), char (*), bit (*), ptr, fixed bin (24), fixed bin (35));
	dcl     get_wdir_		 entry () returns (char (168));
	dcl     get_group_id_	 entry returns (char (32));
	dcl     get_group_id_$tag_star entry () returns (char (32));
	dcl     hcs_$set_safety_sw_seg entry (ptr, bit (1), fixed bin (35));
	dcl     hcs_$set_damaged_sw_seg
				 entry (ptr, bit (1), fixed bin (35));
	dcl     hcs_$replace_acl	 entry (char (*), char (*), ptr, fixed bin, bit (1), fixed bin (35));
	dcl     hcs_$create_branch_	 entry (char (*), char (*), ptr, fixed bin (35));
	dcl     hcs_$truncate_seg	 entry (ptr, fixed bin (19), fixed bin (35));
	dcl     cu_$level_get	 entry returns (fixed bin (3));
	dcl     cu_$level_set	 entry (fixed bin (3));
	dcl     get_ring_		 entry () returns (fixed bin (3));
	dcl     pathname_		 entry (char (*), char (*)) returns (char (168));
	dcl     set_lock_$lock	 entry (bit (36) aligned, fixed bin, fixed bin (35));
	dcl     set_lock_$unlock	 entry (bit (36) aligned, fixed bin (35));
	dcl     terminate_file_	 entry (ptr, fixed bin (24), bit (*), fixed bin (35));
						/* cauise a segfault at least in this process */
	dcl     (get_temp_segment_, release_temp_segment_)
				 entry (character (*), pointer, fixed bin (35));

	declare access_operations_$install_table
				 bit (36) aligned ext static;

	declare error_table_$locked_by_this_process
				 fixed bin (35) ext static;
	declare error_table_$invalid_lock_reset
				 fixed bin (35) ext static;
	declare error_table_$smallarg	 fixed bin (35) ext static;
	declare error_table_$invalid_ascii
				 fixed bin (35) ext static;
	declare error_table_$unimplemented_version
				 fixed bin (35) ext static;
	declare error_table_$zero_length_seg
				 fixed bin (35) ext static;
	declare error_table_$noentry	 fixed bin (35) ext static;
	declare error_table_$improper_data_format
				 fixed bin (35) ext static;

/* AUTOMATIC */

	dcl     1 auto_event_flags	 aligned like audit_event_flags;
	dcl     code		 fixed bin (35);
	dcl     complaint		 character (128);
	dcl     highest		 fixed bin;
	dcl     i			 fixed bin;
	dcl     j			 fixed bin;
	dcl     tabp		 ptr;
	dcl     locked		 bit (1) aligned;
          dcl     path		 char (168) varying;
	dcl     saved_level		 fixed bin (3);
	dcl     saved_proc_group_id	 character (32) aligned;
	dcl     system_tttp		 pointer;
          dcl     wdir                   char (168);
	dcl     wordcount		 fixed bin (18) unsigned;

/* INTERNAL STATIC */

	dcl     TTT_dir		 character (168) init (">system_control_1") internal static;
	dcl     TTT_entryname	 character (32) init ("ttt") internal static;

	dcl     ME		 character (32) init ("install_ttt_") options (constant) internal static;
	dcl     LEGAL_CHARS		 char (37) int static options (constant)
				 init ("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");

/* BASED */

	dcl     rp		 (7) fixed bin (18) based;

	declare ttt_seg_copy_var	 (wordcount) bit (36) aligned based;
	declare 1 system_ttt	 aligned like ttt based (system_tttp);
						/* BUILTIN */

/* CONDITIONS */

	declare cleanup		 condition;
	declare seg_fault_error	 condition;

	dcl     (addr, bin, clock, hbound, length, null, rel, rtrim, string, substr, verify)
				 builtin;

	saved_level = -1;
	tttp, system_tttp = null;
	locked = "0"b;
	on cleanup call clean_up;

	saved_level = cu_$level_get ();

	wordcount = Wordcount;
	code = 0;
	complaint = "";
	path = "";

	if wordcount < 64
	then do;
		complaint = "Supplied TTT less than 64 words long.";
		code = error_table_$smallarg;
		go to ERROR_RETURN;
	     end;

/* First copy supplied TTT to keep it from being modified */
/* after being approved */

	call get_temp_segment_ (ME, tttp, code);
	if code ^= 0
	then do;
		complaint = "Could not get temp segment.";
		call admin_gate_$syserr_error_code (SYSERR_LOG_OR_DISCARD, code, "install_ttt_: ^a", complaint);
		go to ERROR_RETURN;
	     end;

	tttp -> ttt_seg_copy_var = TTT_pointer -> ttt_seg_copy_var;
						/* WHUMP */

/* From now on look only at the copy */

	if ttt.version ^= TTT_version_4
	then do;					/* Check right overlay dcl */
		complaint = "incorrect table version";
		code = error_table_$unimplemented_version;
		go to ERROR_RETURN;
	     end;

	ttt.author.proc_group_id = get_group_id_ ();	/* no fibbing */
	ttt.author.lock = ""b;			/* it will be unlocked when we install */
	ttt.last_install_time = 0;			/* set for real below */
	ttt.author.table = "ttt";
          wdir = get_wdir_ ();			/* Validation level not yet set down, so its callers wdir */
	ttt.author.w_dir = substr (wdir, 1, length(ttt.author.w_dir));

/* Now initiate system ttt in real ring, and check access */

	call cu_$level_set (get_ring_ ());

	call initiate_file_ (TTT_dir, TTT_entryname, RW_ACCESS, system_tttp, (0), code);
	if code = error_table_$zero_length_seg
	then code = 0;				/* we may be replacing a busted segment */

	if code = error_table_$noentry
	then call try_to_create_ttt (code);
	if code ^= 0
	then do;
		path = pathname_ (TTT_dir, TTT_entryname);
		complaint = "Incorrect access to " || path;
		string (auto_event_flags) = ""b;
		auto_event_flags.admin_op = "1"b;
		call access_audit_r1_$log_general (ME, (saved_level), string (auto_event_flags),
		     access_operations_$install_table, "system terminal type table (TTT)", code, null (), (0));
		go to ERROR_RETURN;
	     end;
	else do;
		string (auto_event_flags) = ""b;
		auto_event_flags.grant = "1"b;
		auto_event_flags.admin_op = "1"b;
		call access_audit_r1_$log_general (ME, (saved_level), string (auto_event_flags),
		     access_operations_$install_table, "system terminal type table (TTT)", code, null (), (0));
	     end;

	on seg_fault_error /* Damaged ttt? */
	     begin;				/* we turn it off and truncate seg. If this installation
	        fails the next try will work no worse for it. */

		call hcs_$set_damaged_sw_seg (system_tttp, "0"b, (0));
		call hcs_$truncate_seg (system_tttp, 0, (0));
	     end;

	highest = system_ttt.highest_coded_type;

	revert seg_fault_error;			/* it was broken or it was not */

	call set_lock_$lock (system_tttp -> ttt.author.lock, (0), code);
	if code = error_table_$invalid_lock_reset | code = error_table_$locked_by_this_process
						/* force */
	then code = 0;
	if code ^= 0
	then do;
		complaint = "TTT lock for installation by " || system_tttp -> ttt.author.proc_group_id;
		go to ERROR_RETURN;
	     end;

	locked = "1"b;

/* Whether or not the new ttt gets installed, leave our group id */
/* there for an informative message to someone else locked out */
/* if the installation fails, the old one will get put back */

	saved_proc_group_id = system_tttp -> ttt.author.proc_group_id;
	system_tttp -> ttt.author.proc_group_id = ttt.author.proc_group_id;

	do i = 1 to ttt.n_tt_entries;			/* do a quick check on each terminal type entry */
	     ttep = addr (ttt.tt_entries (i));
	     if verify (rtrim (tte.name), LEGAL_CHARS) ^= 0
						/* cv_ttf wouldn't have done this */
	     then do;
		     complaint = rtrim (tte.name) || " not a valid terminal type name";
		     code = error_table_$invalid_ascii;
		     go to ERROR_RETURN;
		end;

	     call check_offset (tte.initial_string.offset);
						/* make sure all offsets are at least within TTT */
	     call check_offset (tte.additional_info.offset);
	     tabp = addr (tte.tables);
	     do j = 1 to 7;
		call check_offset (tabp -> rp (j));
	     end;

/* find old entry for same type (if any) */

	     do j = 1 to system_ttt.n_tt_entries while (system_ttt.tt_entries (j).name ^= tte.name);
	     end;

	     if j > system_ttt.n_tt_entries		/* there wasn't any */
	     then highest, tte.coded_type = highest + 1;
	     else tte.coded_type = system_ttt.tt_entries (j).coded_type;
	end;

	ttt.highest_coded_type = highest;		/* whether it changed or not */

/* we are ready to install it now */

	wordcount = ttt.total_ttt_size;		/* We should validate this! */

	ttt.last_install_time = clock ();		/* for ttt_info_ */

	system_tttp -> ttt_seg_copy_var = tttp -> ttt_seg_copy_var;
	call set_lock_$unlock (system_tttp -> ttt.author.lock, (0));
	locked = "0"b;

	call terminate_file_ (system_tttp, wordcount * 36, TERM_FILE_TRUNC_BC, code);
	if code ^= 0
	then call admin_gate_$syserr_error_code (SYSERR_LOG_OR_DISCARD, code,
		"install_ttt_: could not set bitcount and terminate ttt.");

	call release_temp_segment_ (ME, tttp, (0));

	Code = 0;
	return;

ERROR_RETURN:
	call clean_up;
	Complaint = complaint;
	Code = code;
	return;

check_offset:
     proc (offset);

/* an internal procedure that makes sure offset is within TTT */

	dcl     offset		 fixed bin (18);

	if offset ^= 0				/* 0 is OK, of course */
	then if offset > ttt.total_ttt_size | offset < bin (rel (addr (ttt.tables)))
						/* can't have it pointing into type entries */
	     then do;
		     complaint = "Invalid offset in entry for type " || tte.name;
		     code = error_table_$improper_data_format;
		     go to ERROR_RETURN;
		end;

	return;
     end check_offset;

clean_up:
     procedure;
	if tttp ^= null
	then call release_temp_segment_ (ME, tttp, (0));
	tttp = null;
	if system_tttp ^= null
	then do;
		if locked
		then do;
			call set_lock_$unlock (system_tttp -> ttt.author.lock, (0));
			system_tttp -> ttt.author.proc_group_id = saved_proc_group_id;
		     end;
		call terminate_file_ (system_tttp, (0), TERM_FILE_TERM, (0));
		locked = "0"b;
		system_tttp = null;
	     end;
	if saved_level > 0
	then call cu_$level_set (saved_level);
	saved_level = -1;
     end clean_up;

try_to_create_ttt:
     procedure (code);

	declare code		 fixed bin (35);
	declare 1 cbi		 aligned like create_branch_info;
	declare 1 segment_acl	 (3) aligned,
		2 access_name	 character (32),
		2 modes		 bit (36) aligned,
		2 xmodes		 bit (36) aligned,
		2 status_code	 fixed bin (35);

	cbi.version = create_branch_version_2;
	string (cbi.switches) = ""b;
	cbi.parent_ac_sw = "1"b;			/* inherit system low from >sc1 */
	cbi.mode = RW_ACCESS;
	cbi.mbz2 = ""b;
	cbi.rings (1) = get_ring_ ();
	cbi.rings (2) = 5;
	cbi.rings (3) = 5;
	cbi.userid = get_group_id_ ();		/* Us, others to be added */
	cbi.bitcnt = 0;				/* more later */
	cbi.quota, cbi.dir_quota = 0;
	cbi.access_class = ""b;

	code = 0;

	call hcs_$create_branch_ (TTT_dir, TTT_entryname, addr (cbi), code);
	if code ^= 0
	then return;				/* No such luck */
	call initiate_file_ (TTT_dir, TTT_entryname, RW_ACCESS, system_tttp, (0), code);
	if code = error_table_$zero_length_seg
	then code = 0;
	call hcs_$set_safety_sw_seg (system_tttp, "1"b, (0));
						/* not absolutely neccessary */

	segment_acl (*).xmodes = ""b;
	segment_acl (*).status_code = 0;

	segment_acl (1).access_name = get_group_id_$tag_star ();
	segment_acl (1).modes = RW_ACCESS;
	segment_acl (2).access_name = "*.SysDaemon.*";	/* even if default goes away */
	segment_acl (2).modes = RW_ACCESS;
	segment_acl (3).access_name = "*.*.*";
	segment_acl (3).modes = R_ACCESS;

	call hcs_$replace_acl (TTT_dir, TTT_entryname, addr (segment_acl), hbound (segment_acl, 1), "0"b, code);
	if code ^= 0
	then call admin_gate_$syserr_error_code (SYSERR_LOG_OR_DISCARD, code, "install_ttt_: could not set acl of ttt.")
		;
	code = 0;					/* this is still enough to go ahead with installation */
     end try_to_create_ttt;

%page;
%include access_mode_values;
%page;
%include author_dcl;
%page;
%include create_branch_info;
%page;
%include terminate_file;
%page;
%include ttt;
%page;
%include access_audit_eventflags;
%page;
%include syserr_constants;

debug:
     entry (d, e);
	dcl     (d, e)		 char (*);

	TTT_dir = d;
	TTT_entryname = e;
	return;
     end install_ttt_;




		    bull_copyright_notice.txt       08/30/05  1008.4r   08/30/05  1007.3    00020025

                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull
and Bull HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato.Users consider that Multics provided the best software architecture for 
managing computer hardware properly and for executing programs. Many subsequent operating systems
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by Bull HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved
