COMPILATION LISTING OF SEGMENT mail_table_mgr_ Compiled by: Multics PL/I Compiler, Release 32e, of September 22, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 10/02/89 0819.5 mst Mon Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 11 /****^ HISTORY COMMENTS: 12* 1) change(88-09-13,Blair), approve(88-09-13,MCR7990), audit(88-09-21,Dupuis), 13* install(88-09-26,MR12.2-1121): 14* Change mail_table_priv_$salvage to unlock the original mail-table before 15* it is closed and to base the like header for the new table on its ptr. 16* Mail error_list #510. 17* 2) change(88-12-14,Parisek), approve(89-01-11,MCR8044), 18* audit(89-01-16,Farley), install(89-01-19,MR12.3-1006): 19* Added the get_name_by_index non privileged entry for returning the 20* mail-table name based on an index into the mail-table. Useful for 21* scanning the mail-table while matching starnames (ie, dsmla ). 22* 3) change(89-08-02,Lee), approve(89-08-22,MCR8128), 23* audit(89-09-25,LZimmerman), install(89-10-02,MR12.3-1079): 24* phx20967 (Mail 445) - added entry delete_alias_case_ins to allow the 25* update_mail_table_entry command to delete alias entries 26* case-insensitively; phx17774, phx21076 (Mail 445) - modified 27* mail_table_mgr_$put to search for entries case-insensitively. 28* END HISTORY COMMENTS */ 29 30 31 /* format: style2,ifthenstmt,ifthendo,ifthen,^indnoniterdo,indcomtxt,^inditerdo,idind22 */ 32 33 /* mail_table_mgr_: this program manipulates the system Mail 34* Table, which is used to find out the electronic mail address of 35* users when you don't know the project, or for non-user objects 36* that you wish to address mail to as if they were users (i.e. not 37* by pathname). Users may update their own mailing addresses, 38* privileged users may update any mail table entry, and ACS may be 39* set up by privileged users to control who may update particular 40* addresses. */ 41 42 /* Written: June/July 1983 by B. Margolin */ 43 /* Modified: 15 August 1984 by E. Swenson for V3 MSTBs */ 44 /* Modified: 17 December 1984 by E. Swenson and Gary M. Palter to properly 45* ignore error_table_$checksum_error, to properly update entries, and to 46* rechain aliases correctly when deleting an alias */ 47 48 mail_table_mgr_: 49 proc (); 50 51 /*** Parameters ***/ 52 53 dcl P_acs_path char (*) parameter; /* ACS pathname */ 54 dcl P_address_ptr ptr parameter; /* -> Mail system address */ 55 dcl P_alias char (*) varying parameter; 56 /* Alias */ 57 dcl P_area_ptr ptr parameter; /* -> area */ 58 dcl P_code fixed bin (35) parameter; 59 dcl P_count fixed bin parameter;/* Number of entries */ 60 dcl P_dft_proj char (*) parameter; /* Default project */ 61 dcl P_id char (*) varying parameter; 62 /* Name or alias */ 63 dcl P_index fixed bin parameter;/* Index into mail table */ 64 dcl P_message char (*) parameter; /* More detailed error message for salvage */ 65 dcl P_mta_ptr ptr parameter; /* -> mail_table_aliases */ 66 dcl P_mte_ptr ptr parameter; /* -> mail_table_entry */ 67 dcl P_mtre_ptr ptr parameter; /* -> mail_table_raw_entry */ 68 dcl P_pnt bit (1) parameter; /* Manipulate entries which correspond to PNT entries */ 69 dcl P_return_id char (*) varying parameter; 70 /* Name or alias returned by get_name_by_index */ 71 dcl P_test_dir char (*) parameter; /* Directory containing mil table for testing */ 72 dcl P_version char (*) parameter; /* Version string */ 73 74 /*** Automatic ***/ 75 76 dcl address char (256) varying; /* Formatted address */ 77 dcl alias char (32) varying; 78 dcl already_in_fatal_error 79 bit (1); 80 dcl anon fixed bin; /* For all you Shakespeare lovers */ 81 dcl by_name_number bit (1); /* For name_by_index entrypoint */ 82 dcl by_number bit (1); /* Which get_raw entrypoint? */ 83 dcl case_insensitive_sw bit (1); /* Perform case-insensitive search */ 84 dcl cur_mtep ptr; /* -> mail table entry */ 85 dcl day fixed bin; 86 dcl (disp_day, disp_hour, disp_minute, disp_month) 87 pic "99"; 88 dcl entry_num fixed bin (35); 89 dcl hour fixed bin; 90 dcl i fixed bin; 91 dcl ignore_code fixed bin (35); 92 dcl ignore_rs fixed bin (35); 93 dcl index fixed bin; 94 dcl initial_ring fixed bin; 95 dcl key char (32); 96 dcl mail_table_locked bit (1); 97 dcl minute fixed bin; 98 dcl month fixed bin; 99 dcl 1 msti aligned like ms_table_info; 100 dcl my_area area based (my_area_ptr); 101 dcl my_area_ptr ptr; /* -> my_area */ 102 dcl new bit (1); /* New entry or updating? */ 103 dcl new_mtep ptr; /* -> New mail table entry */ 104 dcl new_name char (32); 105 dcl new_new_name char (32); 106 dcl next_name char (32) varying; 107 dcl original_time fixed bin (71); /* Used by reader locking */ 108 dcl original_write_count fixed bin; /* ditto */ 109 dcl person_id char (32) varying; /* Name of entry */ 110 dcl pnt bit (1); /* Does entry correspond to PNT entry? */ 111 dcl real_mtep ptr; /* -> real_mte */ 112 dcl theres_more bit (1); 113 114 /*** Based ***/ 115 116 dcl 1 mail_table_header aligned based (mthp), 117 2 write_lock bit (36), 118 2 write_count fixed bin, 119 2 entry_count fixed bin; /* Count of mail table entries */ 120 dcl 1 real_mte /** In case we ever want non-external data (like locks) **/ 121 aligned based (real_mtep), 122 2 raw_entry aligned like mail_table_raw_entry; 123 124 /*** Entries ***/ 125 126 dcl ( 127 cu_$level_get, 128 cu_$level_set 129 ) entry (fixed bin); 130 dcl decode_clock_value_$date_time 131 entry (fixed bin (71), fixed bin, fixed bin, fixed bin (35), fixed bin, fixed bin, 132 fixed bin (35), fixed bin (35), fixed bin (35), char (3), fixed bin (35)); 133 dcl get_ring_ entry () returns (fixed bin (3)); 134 dcl hcs_$chname_file entry (char (*), char (*), char (*), char (*), fixed bin (35)); 135 dcl ms_table_mgr_$close entry (ptr, fixed bin (35)); 136 dcl ms_table_mgr_$abs_entry 137 entry (ptr, fixed bin (35), char (*), bit (1) aligned, ptr, fixed bin (35), 138 fixed bin (35)); 139 dcl ms_table_mgr_$create entry (char (*), char (*), ptr, fixed bin (35)); 140 dcl ms_table_mgr_$delete_entry 141 entry (ptr, char (*), fixed bin (35)); 142 dcl ms_table_mgr_$find_entry 143 entry (ptr, char (*), ptr, bit (1) aligned, fixed bin (35), fixed bin (35)); 144 dcl ms_table_mgr_$find_entry_case_ins 145 entry (ptr, char (*), ptr, bit (1) aligned, fixed bin (35), fixed bin (35)); 146 dcl ms_table_mgr_$new_entry 147 entry (ptr, char (*), ptr, fixed bin (35)); 148 dcl ms_table_mgr_$open entry (char (*), char (*), char (*) aligned, ptr, ptr, fixed bin (35)); 149 dcl ms_table_mgr_$update_entry 150 entry (ptr, ptr, fixed bin (35)); 151 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 152 dcl probe entry options (variable); 153 dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); 154 dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); 155 dcl timer_manager_$sleep entry (fixed bin (71), bit (2)); 156 dcl unique_chars_ entry (bit (*)) returns (char (15)); 157 dcl user_info_$login_data entry (char (*), char (*), char (*), fixed bin); 158 159 /*** Constants and Static ***/ 160 161 dcl already_inited bit (1) int static init ("0"b); 162 dcl anonymous_user bit (1) int static; /* This is an anonymous process */ 163 dcl BIG_NUMBER fixed bin (17) int static options (constant) init (32767); 164 dcl DEBUGGING bit (1) int static options (constant) init ("0"b); 165 dcl ( 166 error_table_$action_not_performed, 167 error_table_$argerr, 168 error_table_$bad_index, 169 error_table_$bad_subr_arg, 170 error_table_$bigarg, 171 error_table_$checksum_failure, 172 error_table_$id_already_exists, 173 error_table_$id_not_found, 174 error_table_$insufficient_access, 175 error_table_$invalid_lock_reset, 176 error_table_$lock_wait_time_exceeded, 177 error_table_$locked_by_other_process, 178 error_table_$no_record, 179 error_table_$null_info_ptr, 180 error_table_$request_id_ambiguous, 181 error_table_$smallarg, 182 error_table_$unexpected_condition, 183 error_table_$unimplemented_version, 184 mlsys_et_$ambiguous_address, 185 mlsys_et_$bad_mail_table 186 ) fixed bin (35) ext static; 187 dcl LOCK_WAIT_TIME fixed bin int static options (constant) init (30); 188 dcl MAIL_TABLE_DIR char (168) int static init (""); 189 /* Not constant */ 190 dcl MAIL_TABLE_NAME char (32) int static options (constant) init ("MAIL_TABLE"); 191 dcl MAIL_TABLE_TYPE_STRING 192 char (32) aligned int static options (constant) init ("mail_table"); 193 dcl mlsys_data_$system_directory 194 char (168) ext static; 195 dcl mt_ptr ptr int static init (null ()); 196 /* -> Mail table structure */ 197 dcl mthp ptr int static init (null ()); 198 /* -> mail_table_header */ 199 dcl my_person_id char (32) internal static; 200 dcl NO_WRITE bit (1) aligned internal static options (constant) initial ("0"b); 201 dcl sys_info$max_seg_size fixed bin (19) external static; 202 203 /*** Builtins and Conditions ***/ 204 205 dcl (addr, bool, character, clock, length, maxlength, null, rtrim, size, string, substr) 206 builtin; 207 dcl (any_other, cleanup) condition; 208 1 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 209 210 2 1 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 2 2 /* format: style3,indcomtxt,idind30 */ 2 3 2 4 declare acl_ptr pointer; 2 5 declare acl_count fixed bin; 2 6 2 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 2 8 2 version char (8) aligned, 2 9 2 count fixed bin, 2 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 2 11 2 12 declare 1 general_acl_entry based, 2 13 2 access_name character (32) unaligned, 2 14 2 mode bit (36) aligned, 2 15 2 status_code fixed bin (35); 2 16 2 17 2 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 2 19 2 version char (8) aligned, 2 20 2 count fixed bin, 2 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 2 22 2 23 declare 1 general_extended_acl_entry aligned based, 2 24 2 access_name character (32) unaligned, 2 25 2 mode bit (36) aligned, 2 26 2 extended_mode bit (36) aligned, 2 27 2 status_code fixed bin (35); 2 28 2 29 2 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 2 31 2 version char (8) aligned, 2 32 2 count fixed bin, 2 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 2 34 2 35 declare 1 general_delete_acl_entry aligned based, 2 36 2 access_name character (32) unaligned, 2 37 2 status_code fixed bin (35); 2 38 2 39 2 40 declare 1 segment_acl aligned based (acl_ptr), 2 41 2 version fixed bin, 2 42 2 count fixed bin, 2 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 2 44 2 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 2 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 2 47 2 48 2 49 declare 1 directory_acl aligned based (acl_ptr), 2 50 2 version fixed bin, 2 51 2 count fixed bin, 2 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 2 53 2 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 2 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 2 56 2 57 2 58 declare 1 delete_acl based (acl_ptr) aligned, 2 59 2 version fixed bin, 2 60 2 count fixed bin, 2 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 2 62 2 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 2 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 2 65 2 66 2 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 2 68 DIR_ACL_VERSION_1 init ("dra1"), 2 69 DELETE_ACL_VERSION_1 init ("dla1")) 2 70 char (4) int static options (constant); 2 71 2 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 2 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 2 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 2 75 char (8) internal static options (constant); 2 76 2 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 2 78 2 79 /* End include file acl_structures.incl.pl1 */ 211 212 3 1 /* START OF: mail_table_entry.incl.pl1 * * * * * * * * * * * * * * * * */ 3 2 3 3 /* Written by B. Margolin - 7/4/83 */ 3 4 3 5 /* format: style2,ifthendo,ifthen,^indnoniterdo,indcomtxt,^inditerdo,idind22 */ 3 6 declare 1 mail_table_entry aligned based (mail_table_entry_ptr), 3 7 2 version char (8), 3 8 2 name char (32) varying, /* Person_id or entry name */ 3 9 2 acs_path, 3 10 3 dir char (168), 3 11 3 entry char (32), 3 12 2 default_project char (12) varying, 3 13 2 mailing_address char (256) varying; 3 14 3 15 declare mail_table_entry_ptr ptr; 3 16 declare MAIL_TABLE_ENTRY_VERSION_1 3 17 char (8) int static options (constant) init ("mte_0001"); 3 18 3 19 declare 1 mail_table_raw_entry 3 20 aligned based (mail_table_raw_entry_ptr), 3 21 2 version char (8), 3 22 2 name char (32) varying, 3 23 2 primary_name char (32) varying, /* for alias entries */ 3 24 2 flags, 3 25 3 alias_entry bit (1) unaligned, 3 26 3 registered_user bit (1) unaligned, /* In the PNT */ 3 27 3 mbz bit (34) unaligned, 3 28 2 n_names fixed bin, /* # names, including primary */ 3 29 2 next_name char (32) varying, /* Make a */ 3 30 2 prev_name char (32) varying, /* linked list */ 3 31 2 acs_path, 3 32 3 dir char (168), 3 33 3 entry char (32), 3 34 2 default_project char (12) varying, 3 35 2 mailing_address char (256) varying; 3 36 3 37 declare mail_table_raw_entry_ptr 3 38 ptr; 3 39 declare MAIL_TABLE_RAW_ENTRY_VERSION_1 3 40 char (8) int static options (constant) init ("mtre_001"); 3 41 3 42 declare 1 mail_table_aliases aligned based (mail_table_aliases_ptr), 3 43 2 version char (8), 3 44 2 n_names fixed bin, 3 45 2 names (mail_table_aliases_extent refer (mail_table_aliases.n_names)) char (32) varying; 3 46 3 47 declare mail_table_aliases_ptr 3 48 ptr; 3 49 declare mail_table_aliases_extent 3 50 fixed bin; 3 51 declare MAIL_TABLE_ALIASES_VERSION_1 3 52 int static options (constant) char (8) init ("mta_0001"); 3 53 3 54 /* END OF: mail_table_entry.incl.pl1 * * * * * * * * * * * * * * * * */ 213 214 4 1 /* Begin include file ms_table_info.incl.pl1 */ 4 2 /* Written by C. Hornig, June 1979 */ 4 3 /* Modified by B. Margolin, July 1983, for version 2 */ 4 4 /* Modified 1984-07-24 BIM for V3, improved hash, checksums */ 4 5 4 6 /* This information is passed to ms_table_mgr_$create when a multi-segment 4 7* table is created. */ 4 8 4 9 /* format: style3 */ 4 10 4 11 declare MS_TABLE_INFO_VERSION_3 4 12 fixed init (3) internal static options (constant); 4 13 4 14 declare 1 ms_table_info aligned based, 4 15 2 version fixed, /* Should be 3 */ 4 16 2 type character (32), /* what table is this? */ 4 17 2 ( 4 18 header_size, /* length of table header in words */ 4 19 entry_size 4 20 ) unsigned fixed (18), /* same for table entries */ 4 21 2 max_entries unsigned fixed bin (18), /* how many entries */ 4 22 2 max_size fixed bin (19), /* max segment length */ 4 23 2 keep_meters bit (1) aligned; /* table is writable to readers */ 4 24 4 25 /* End include file ms_table_info.incl.pl1 */ 215 216 217 /**** Get the user-accessible information from a mail table entry. 218* This is the target of the gate mail_table_$get 219*****/ 220 221 mail_table_mgr_$get: 222 entry (P_id, P_address_ptr, P_acs_path, P_code); 223 224 on cleanup call cleanup_proc (); 225 on any_other call any_other_proc (); 226 call setup (); 227 if length (P_id) = 0 then 228 person_id = my_person_id; 229 else person_id = P_id; 230 GET_TRY_AGAIN: 231 call get_write_count (); 232 call retrieve_real_mte (person_id, "1"b, "1"b, real_mtep); 233 call get_address (real_mte, P_address_ptr); 234 if real_mte.acs_path.dir = "" then 235 P_acs_path = ""; 236 else P_acs_path = pathname_ ((real_mte.acs_path.dir), (real_mte.acs_path.entry)); 237 if mt_modified () then go to GET_TRY_AGAIN; 238 call exit_proc (); 239 240 /**** This entrypoint is used by normal users to change their mail 241* table information. This is the target of the gate mail_table_$set. 242*****/ 243 244 mail_table_mgr_$put: 245 entry (P_id, P_address_ptr, P_code); 246 247 on cleanup call cleanup_proc (); 248 on any_other call any_other_proc (); 249 call setup (); 250 if P_id = "" then /* Null-string means self */ 251 if anonymous_user then 252 call fatal_error (error_table_$action_not_performed); 253 /* Anonymous users have no mail table entries */ 254 else person_id = my_person_id; 255 else person_id = P_id; 256 if length (P_id) > maxlength (mail_table_entry.name) then call fatal_error (error_table_$bigarg); 257 if P_address_ptr = null () then 258 address = ""; /* Revert to default project */ 259 else call format_address (P_address_ptr, address); 260 call lock_mail_table (); 261 call retrieve_real_mte (person_id, "1"b, "1"b, real_mtep); 262 /* phx17774, phx21076 RL: get it case-insensitively */ 263 if real_mte.name ^= my_person_id then call check_acs_access (real_mte.acs_path); 264 if ^real_mte.registered_user & P_address_ptr = null () then call fatal_error (error_table_$bad_subr_arg); 265 /* Non-users have no default project */ 266 real_mte.mailing_address = address; 267 call update_new_entry (real_mtep); 268 call unlock_mail_table (); 269 call exit_proc (); 270 271 /**** This entrypoint just sets the default project in a mail table 272* entry. It is the target of mail_table_initializer_$set_dft_proj. 273*****/ 274 275 mail_table_mgr_$set_dft_proj: 276 entry (P_id, P_dft_proj, P_code); 277 278 person_id = P_id; 279 on cleanup call cleanup_proc (); 280 on any_other call any_other_proc (); 281 call setup (); 282 call lock_mail_table (); 283 call retrieve_real_mte (person_id, "0"b, "0"b, real_mtep); 284 real_mte.default_project = P_dft_proj; 285 call update_new_entry (real_mtep); 286 call unlock_mail_table (); 287 call exit_proc (); 288 289 /**** This entrypoint adds a new entry to the mail table. It is the 290* target of mail_table_priv_$add. 291*****/ 292 293 mail_table_mgr_$add: 294 entry (P_mte_ptr, P_pnt, P_code); 295 296 new = "1"b; 297 go to ADD_UPDATE_COMMON; 298 299 /**** This entrypoint updates an existing entry in the mail table. It is the 300* target of mail_table_priv_$update. 301*****/ 302 303 mail_table_mgr_$update: 304 entry (P_mte_ptr, P_pnt, P_code); 305 306 new = "0"b; 307 308 ADD_UPDATE_COMMON: 309 pnt = P_pnt; 310 on cleanup call cleanup_proc (); 311 on any_other call any_other_proc (); 312 call setup (); 313 call check_mtep (P_mte_ptr); 314 mail_table_entry_ptr = P_mte_ptr; 315 /*** Check for inconsistency ***/ 316 if 317 /*** (pnt & mail_table_entry.default_project = "") | 318* Taken out because there are PNT entries with blank 319* default projects, damn - barmar 9/2/83 ***/ 320 (new & ^pnt & mail_table_entry.default_project ^= "") then 321 call fatal_error (error_table_$bad_subr_arg); 322 real_mtep = null (); 323 call lock_mail_table (); 324 if new then do; 325 call make_new_entry (mail_table_entry.name, real_mtep); 326 string (real_mte.flags) = ""b; 327 real_mte.version = MAIL_TABLE_RAW_ENTRY_VERSION_1; 328 real_mte.name, real_mte.primary_name = mail_table_entry.name; 329 real_mte.registered_user = pnt; 330 real_mte.n_names = 1; 331 real_mte.next_name, real_mte.prev_name = ""; 332 end; 333 else do; 334 call retrieve_real_mte (mail_table_entry.name, "1"b, "0"b, real_mtep); 335 if (^pnt & mail_table_entry.default_project ^= real_mte.default_project) 336 | (pnt & ^real_mte.registered_user) then 337 call fatal_error (error_table_$bad_subr_arg); 338 end; 339 real_mte.acs_path = mail_table_entry.acs_path; 340 real_mte.default_project = mail_table_entry.default_project; 341 real_mte.mailing_address = mail_table_entry.mailing_address; 342 call update_new_entry (real_mtep); 343 call unlock_mail_table (); 344 call exit_proc (); 345 346 /**** This entrypoint deletes a mail table entry. It is the target of 347* mail_table_priv_$delete. 348*****/ 349 350 mail_table_mgr_$delete: 351 entry (P_id, P_pnt, P_code); 352 353 pnt = P_pnt; 354 person_id = P_id; 355 on cleanup call cleanup_proc (); 356 on any_other call any_other_proc (); 357 call setup (); 358 call lock_mail_table (); 359 call retrieve_real_mte (person_id, "1"b, "0"b, real_mtep); 360 if pnt ^= real_mte.registered_user then call fatal_error (error_table_$bad_subr_arg); 361 do while (real_mte.next_name ^= ""); 362 next_name = real_mte.next_name; 363 call delete_real_mte (real_mte); 364 call retrieve_real_mte (next_name, "0"b, "1"b, real_mtep); 365 end; 366 call delete_real_mte (real_mte); 367 call unlock_mail_table (); 368 call exit_proc (); 369 370 /**** This entrypoint gets most of the information from a mail table entry, 371* in the same structure that is acceptible to mail_table_mgr_$update. 372* It is the target of the gate mail_table_priv_$get. 373*****/ 374 375 mail_table_mgr_$priv_get: 376 entry (P_id, P_mte_ptr, P_code); 377 378 person_id = P_id; 379 on cleanup call cleanup_proc (); 380 on any_other call any_other_proc (); 381 call setup (); 382 call check_mtep (P_mte_ptr); 383 mail_table_entry_ptr = P_mte_ptr; 384 TRY_PRIV_GET_AGAIN: 385 call get_write_count (); 386 call retrieve_real_mte (person_id, "1"b, "1"b, real_mtep); 387 mail_table_entry.name = real_mte.name; 388 mail_table_entry.mailing_address = real_mte.mailing_address; 389 mail_table_entry.default_project = real_mte.default_project; 390 mail_table_entry.acs_path = real_mte.acs_path; 391 if mt_modified () then go to TRY_PRIV_GET_AGAIN; 392 call exit_proc (); 393 394 /**** This entrypoint returns a copy of the actual structure stored in the 395* mail table, after chasing alias links. It is the target of the gate 396* mail_table_priv_$get_raw_by_name. 397*****/ 398 399 mail_table_mgr_$get_raw_by_name: 400 entry (P_id, P_mtre_ptr, P_code); 401 402 by_number = "0"b; 403 by_name_number = "0"b; 404 person_id = P_id; 405 go to GET_RAW_COMMON; 406 407 /**** This is the same as get_raw_by_name, except that it takes an 408* index into the mail table array and it does not chase links. 409* It is the target of the gate mail_table_priv_$get_raw_by_index. 410*****/ 411 412 mail_table_mgr_$get_raw_by_index: 413 entry (P_index, P_mtre_ptr, P_code); 414 415 by_number = "1"b; 416 by_name_number = "0"b; 417 index = P_index; 418 go to GET_RAW_COMMON; 419 420 421 /**** This is the same as get_raw_by_index, except that it returns 422* only the mail table name without chasing links. It is the 423* target of the gate mail_table_$get_name_by_index. 424*****/ 425 426 mail_table_mgr_$get_name_by_index: 427 entry (P_index, P_version, P_return_id, P_code); 428 429 by_number = "0"b; 430 by_name_number = "1"b; 431 index = P_index; 432 433 GET_RAW_COMMON: 434 on cleanup call cleanup_proc (); 435 on any_other call any_other_proc (); 436 call setup (); 437 if by_name_number then do; 438 if P_version ^= MAIL_TABLE_RAW_ENTRY_VERSION_1 then call fatal_error (error_table_$unimplemented_version); 439 end; 440 else do; 441 call check_mtrep (P_mtre_ptr); 442 mail_table_raw_entry_ptr = P_mtre_ptr; 443 end; 444 TRY_GET_RAW_AGAIN: 445 call get_write_count (); 446 if by_number | by_name_number then do; 447 call retrieve_real_mte_n (index, real_mtep); 448 if by_name_number then P_return_id = real_mtep -> real_mte.name; 449 end; 450 else call retrieve_real_mte (person_id, "1"b, "0"b, real_mtep); 451 if ^by_name_number then mail_table_raw_entry = real_mte.raw_entry; 452 if mt_modified () then go to TRY_GET_RAW_AGAIN; 453 call exit_proc (); 454 455 /**** This entrypoint adds an alias to an existing entry. 456* This is the target of the gate mail_table_priv_$add_alias. 457*****/ 458 459 mail_table_mgr_$add_alias: 460 entry (P_id, P_alias, P_pnt, P_code); 461 462 pnt = P_pnt; 463 person_id = P_id; 464 alias = P_alias; 465 on cleanup call cleanup_proc (); 466 on any_other call any_other_proc (); 467 call setup (); 468 if alias = "" then call fatal_error (error_table_$bad_subr_arg); 469 if length (alias) > maxlength (mail_table_entry.name) then call fatal_error (error_table_$bigarg); 470 on cleanup call cleanup_proc (); 471 call setup (); 472 real_mtep, new_mtep = null (); 473 call lock_mail_table (); 474 call retrieve_real_mte (person_id, "1"b, "1"b, real_mtep); 475 if pnt & ^real_mte.registered_user then call fatal_error (error_table_$bad_subr_arg); 476 cur_mtep = real_mtep; 477 if pnt then 478 do next_name = real_mte.next_name /* If setting the login alias */ 479 repeat cur_mtep -> real_mte.next_name while (cur_mtep -> real_mte.next_name ^= ""); 480 call retrieve_real_mte (next_name, "0"b, "0"b, cur_mtep); 481 if cur_mtep -> real_mte.registered_user then do; 482 cur_mtep -> real_mte.registered_user = "0"b; 483 /* then turn off the old one */ 484 go to ADD_THE_ALIAS; 485 end; 486 end; 487 cur_mtep = null (); /* Didn't find one */ 488 489 ADD_THE_ALIAS: 490 begin; /* for on unit */ 491 on cleanup 492 begin; 493 if new_mtep ^= null () then do; 494 call delete_real_mte (new_mtep -> real_mte); 495 if pnt & cur_mtep ^= null () /* Fix the old login alias */ then 496 cur_mtep -> real_mte.registered_user = "1"b; 497 end; 498 end; 499 call make_new_entry (alias, new_mtep); 500 new_mtep -> real_mte.version = MAIL_TABLE_RAW_ENTRY_VERSION_1; 501 new_mtep -> real_mte.name = alias; 502 new_mtep -> real_mte.primary_name = real_mte.name; 503 string (new_mtep -> real_mte.flags) = "0"b; 504 new_mtep -> real_mte.registered_user = pnt; 505 new_mtep -> real_mte.alias_entry = "1"b; 506 new_mtep -> real_mte.prev_name = ""; 507 new_mtep -> real_mte.next_name = real_mte.next_name; 508 /*** Null out the unused components ***/ 509 new_mtep -> real_mte.acs_path.dir, new_mtep -> real_mte.acs_path.entry, 510 new_mtep -> real_mte.default_project, new_mtep -> real_mte.mailing_address = ""; 511 call update_new_entry (new_mtep); 512 end; 513 if cur_mtep ^= null then call update_new_entry (cur_mtep); 514 real_mte.n_names = real_mte.n_names + 1; 515 real_mte.next_name = alias; 516 call update_new_entry (real_mtep); 517 call unlock_mail_table (); 518 call exit_proc (); 519 520 /**** This entrypoint deletes a specified alias entry. It is the target 521* of the gate mail_table_priv_$delete_alias. 522*****/ 523 524 mail_table_mgr_$delete_alias: 525 entry (P_alias, P_pnt, P_code); 526 527 pnt = P_pnt; 528 alias = P_alias; 529 case_insensitive_sw = "0"b; 530 go to DELETE_ALIAS_COMMON; 531 532 /**** This entrypoint deletes a specified alias entry case-insensitively. 533* It is the target of the gate mail_table_priv_$delete_alias_case_ins. 534*****/ 535 536 mail_table_mgr_$delete_alias_case_ins: 537 entry (P_alias, P_pnt, P_code); 538 539 pnt = P_pnt; 540 alias = P_alias; 541 case_insensitive_sw = "1"b; 542 543 DELETE_ALIAS_COMMON: 544 on cleanup call cleanup_proc (); 545 on any_other call any_other_proc (); 546 call setup (); 547 call lock_mail_table (); 548 call retrieve_real_mte (alias, "0"b, case_insensitive_sw, real_mtep); 549 if ^real_mte.alias_entry /* it's not an alias */ | pnt ^= real_mte.registered_user /* wrong entrypoint */ then 550 call fatal_error (error_table_$bad_subr_arg); 551 /*** Remove this alias from the chain: only the "forward" chain is maintained */ 552 call retrieve_real_mte (real_mte.primary_name, "0"b, "0"b, cur_mtep); 553 do while (cur_mtep ^= null ()); 554 if cur_mtep -> real_mte.next_name = real_mtep -> real_mte.name then do; 555 cur_mtep -> real_mte.next_name = real_mtep -> real_mte.next_name; 556 call update_new_entry (cur_mtep); 557 cur_mtep = null (); /* rechaining complete */ 558 end; 559 else if cur_mtep -> real_mte.next_name = "" then cur_mtep = null (); 560 /* chain was broken by an earlier bug */ 561 else call retrieve_real_mte (cur_mtep -> real_mte.next_name, "0"b, "0"b, cur_mtep); 562 end; 563 /*** Now delete the alias' entry */ 564 person_id = real_mte.primary_name; 565 call delete_real_mte (real_mte); 566 call retrieve_real_mte (person_id, "0"b, "0"b, real_mtep); 567 real_mte.n_names = real_mte.n_names - 1; 568 call update_new_entry (real_mtep); 569 call unlock_mail_table (); 570 call exit_proc (); 571 572 /**** This entrypoint lists the aliases for a specified entry. 573* It is the target of the gate mail_table_$get_aliases. 574*****/ 575 576 mail_table_mgr_$get_aliases: 577 entry (P_id, P_version, P_area_ptr, P_mta_ptr, P_code); 578 579 on cleanup call cleanup_proc (); 580 on any_other call any_other_proc (); 581 call setup (); 582 if P_version ^= MAIL_TABLE_ALIASES_VERSION_1 then call fatal_error (error_table_$unimplemented_version); 583 person_id = P_id; 584 if P_area_ptr = null () then call fatal_error (error_table_$null_info_ptr); 585 TRY_GET_ALIASES_AGAIN: 586 call get_write_count (); 587 my_area_ptr = P_area_ptr; 588 call retrieve_real_mte (person_id, "1"b, "1"b, real_mtep); 589 mail_table_aliases_extent = real_mte.n_names; 590 call raise_validation (); /* In case area extends */ 591 allocate mail_table_aliases in (my_area); 592 call lower_validation (); 593 mail_table_aliases.version = MAIL_TABLE_ALIASES_VERSION_1; 594 do i = 1 to mail_table_aliases.n_names; 595 mail_table_aliases.names (i) = real_mte.name; 596 if real_mte.next_name ^= "" then call retrieve_real_mte (real_mte.next_name, "0"b, "0"b, real_mtep); 597 end; 598 if mt_modified () then do; 599 free mail_table_aliases in (my_area); 600 go to TRY_GET_ALIASES_AGAIN; 601 end; 602 P_mta_ptr = mail_table_aliases_ptr; 603 call exit_proc (); 604 605 /**** This entrypoint just returns the number of mail table entries, 606* both primary names and aliases. It is the target of 607* mail_table_priv_$count_entries. 608*****/ 609 610 mail_table_mgr_$count_entries: 611 entry (P_count, P_code); 612 613 on cleanup call cleanup_proc (); 614 on any_other call any_other_proc (); 615 call setup (); 616 P_count = mail_table_header.entry_count; 617 call exit_proc (); 618 619 /**** This entrypoint creates a mail table of the specified size. 620* It is the target of the gate mail_table_priv_$create. 621*****/ 622 623 mail_table_mgr_$create_table: 624 entry (P_count, P_code); 625 626 dcl code fixed bin (35); 627 628 P_code = 0; 629 code = 0; 630 msti.version = MS_TABLE_INFO_VERSION_3; 631 msti.type = MAIL_TABLE_TYPE_STRING; 632 msti.header_size = size (mail_table_header); 633 msti.entry_size = size (real_mte); 634 msti.max_entries = P_count; 635 msti.max_size = sys_info$max_seg_size; 636 msti.keep_meters = "0"b; /* Do not keep meters */ 637 mt_ptr = null (); 638 call cu_$level_get (initial_ring); 639 on cleanup 640 begin; 641 call close_mail_table (); 642 call raise_validation (); 643 end; 644 on any_other call fatal_create_error (error_table_$unexpected_condition); 645 call lower_validation (); 646 if MAIL_TABLE_DIR = "" then MAIL_TABLE_DIR = mlsys_data_$system_directory; 647 call ms_table_mgr_$create (MAIL_TABLE_DIR, MAIL_TABLE_NAME, addr (msti), code); 648 if code ^= 0 then call fatal_create_error (code); 649 call open_mail_table (); 650 mail_table_header.entry_count = 0; 651 mail_table_header.write_lock = ""b; 652 mail_table_header.write_count = 0; 653 call close_mail_table (); 654 call set_mail_table_acl (); 655 call raise_validation (); 656 revert cleanup; 657 go to JUST_EXIT; 658 659 /**** This entrypoint sets the directory in which the mail table will be 660* found, for use in testing. 661* It is the target of the gate mail_table_priv_$test. 662*****/ 663 664 mail_table_mgr_$test: 665 entry (P_test_dir); 666 667 call close_mail_table (); 668 MAIL_TABLE_DIR = P_test_dir; 669 return; 670 671 /**** This entrypoint copies the mail table, thus freeing up the 672* wasted space left from deleted entries. The code is mostly ripped 673* off from the salvage_mstb command. This is the target of the 674* gate mail_table_priv_$salvage. 675*****/ 676 677 mail_table_mgr_$salvage: 678 entry (P_count, P_message, P_code); 679 680 P_message = ""; 681 on cleanup call cleanup_proc (); 682 on any_other call any_other_proc (); 683 call setup (); 684 if P_count < mail_table_header.entry_count then do; 685 P_message = "The specified Mail Table size is smaller than the existing number of entries."; 686 call fatal_error (error_table_$smallarg); 687 end; 688 msti.version = MS_TABLE_INFO_VERSION_3; 689 msti.type = MAIL_TABLE_TYPE_STRING; 690 msti.header_size = size (mail_table_header); 691 msti.entry_size = size (real_mte); 692 msti.max_entries = P_count; 693 msti.max_size = sys_info$max_seg_size; 694 msti.keep_meters = "0"b; /* Don't keep meters */ 695 new_name = rtrim (MAIL_TABLE_NAME) || "." || unique_chars_ (""b); 696 call ms_table_mgr_$create (MAIL_TABLE_DIR, new_name, addr (msti), code); 697 if code ^= 0 then do; 698 P_message = "Creating the new MSTB: " || pathname_ (MAIL_TABLE_DIR, new_name); 699 call fatal_error (code); 700 end; 701 begin; /* For on unit */ 702 dcl nmt_ptr ptr; 703 dcl nmth_ptr ptr; 704 dcl 1 nmth aligned like mail_table_header based (nmth_ptr); 705 706 nmt_ptr = null (); 707 on cleanup 708 begin; 709 if nmt_ptr ^= null () then call ms_table_mgr_$close (nmt_ptr, ignore_code); 710 end; 711 call ms_table_mgr_$open (MAIL_TABLE_DIR, new_name, MAIL_TABLE_TYPE_STRING, nmt_ptr, nmth_ptr, code); 712 if code ^= 0 then do; 713 P_message = "Opening the new Mail Table: " || pathname_ (MAIL_TABLE_DIR, new_name); 714 call fatal_error (code); 715 end; 716 nmth.entry_count = 0; 717 nmth.write_lock = "0"b; 718 nmth.write_count = 0; 719 P_message = "Locking the old Mail Table."; /* In case the next call gets an error. */ 720 call lock_mail_table (); 721 theres_more = "1"b; 722 do entry_num = 1 by 1 while (theres_more); 723 call ms_table_mgr_$abs_entry (mt_ptr, entry_num, key, NO_WRITE, real_mtep, ignore_rs, code); 724 if code = 0 then do; 725 call ms_table_mgr_$new_entry (nmt_ptr, key, new_mtep, code); 726 if code = 0 then do; 727 new_mtep -> real_mte = real_mte; 728 nmth.entry_count = nmth.entry_count + 1; 729 call ms_table_mgr_$update_entry (nmt_ptr, new_mtep, code); 730 if code ^= 0 then goto CREATE_ERROR; 731 end; 732 else if code = error_table_$id_already_exists /* Ignore this */ then code = 0; 733 else do; 734 CREATE_ERROR: 735 P_message = "Creating new entry for the name """ || rtrim (key) || """."; 736 call fatal_error (code); 737 end; 738 end; 739 else if code = error_table_$no_record then code = 0; 740 /* Skip unused or deleted entries */ 741 else if code = error_table_$bad_index then do; 742 theres_more = "0"b; 743 code = 0; 744 end; 745 else do; 746 P_message = "Reading entry #" || character (entry_num); 747 call fatal_error (code); 748 end; 749 end; 750 call ms_table_mgr_$close (nmt_ptr, ignore_code); 751 end; /* of begin block */ 752 /*** Rename the old and new tables ***/ 753 call decode_clock_value_$date_time (clock (), month, day, ignore_rs, hour, minute, ignore_rs, ignore_rs, 754 ignore_rs, (""), ignore_code); 755 disp_month = month; /* These are pic(99) vars */ 756 disp_day = day; 757 disp_hour = hour; 758 disp_minute = minute; 759 new_new_name = 760 /* MAIL_TABLE.MMDDYY.HHMM */ rtrim (MAIL_TABLE_NAME) || "." || disp_month || "/" || disp_day || "." 761 || disp_hour || disp_minute; 762 call hcs_$chname_file (MAIL_TABLE_DIR, MAIL_TABLE_NAME, "", new_new_name, code); 763 if code ^= 0 then do; 764 P_message = 765 "Adding the name " || rtrim (new_new_name) || " to " || pathname_ (MAIL_TABLE_DIR, MAIL_TABLE_NAME); 766 call fatal_error (code); 767 end; 768 call hcs_$chname_file (MAIL_TABLE_DIR, MAIL_TABLE_NAME, MAIL_TABLE_NAME, "", code); 769 /* Get rid of old name */ 770 if code ^= 0 then do; 771 P_message = "Removing the name " || pathname_ (MAIL_TABLE_DIR, MAIL_TABLE_NAME); 772 call fatal_error (code); 773 end; 774 call unlock_mail_table (); 775 call close_mail_table (); /* Close the old one */ 776 call hcs_$chname_file (MAIL_TABLE_DIR, new_name, new_name, MAIL_TABLE_NAME, code); 777 /* and put it on new table */ 778 if code ^= 0 then do; 779 P_message = "Renaming " || pathname_ (MAIL_TABLE_DIR, new_name) || " to " || MAIL_TABLE_NAME; 780 call fatal_error (code); 781 end; 782 call set_mail_table_acl (); 783 call exit_proc (); 784 785 786 /**** Come to this page when exiting (either through exit_proc or fatal_error) 787*****/ 788 789 GLOBAL_EXIT: 790 call cleanup_proc (); 791 JUST_EXIT: /* For when we die during error handling */ 792 return; 793 794 /*** INTERNAL SUBROUTINES ***/ 795 796 raise_validation: 797 proc (); 798 799 call cu_$level_set (initial_ring); 800 return; 801 802 end raise_validation; 803 804 lower_validation: 805 proc (); 806 807 call cu_$level_get (initial_ring); 808 call cu_$level_set ((get_ring_ ())); 809 return; 810 811 end lower_validation; 812 813 setup: 814 proc (); 815 816 mail_table_locked = "0"b; 817 already_in_fatal_error = "0"b; 818 call lower_validation (); 819 if ^already_inited then do; 820 call user_info_$login_data (my_person_id, (""), (""), anon); 821 if anon = 1 then 822 anonymous_user = "1"b; 823 else anonymous_user = "0"b; 824 if MAIL_TABLE_DIR = "" then MAIL_TABLE_DIR = mlsys_data_$system_directory; 825 call open_mail_table (); 826 already_inited = "1"b; 827 end; 828 return; 829 830 end setup; 831 832 cleanup_proc: 833 proc (); 834 835 call unlock_mail_table (); 836 call raise_validation (); 837 return; 838 839 end cleanup_proc; 840 841 any_other_proc: 842 proc (); 843 844 call fatal_error (mlsys_et_$bad_mail_table); 845 846 end any_other_proc; 847 848 /**** Use this for normal exit ***/ 849 exit_proc: 850 proc (); 851 852 P_code = 0; 853 go to GLOBAL_EXIT; 854 855 end exit_proc; 856 857 fatal_create_error: 858 proc (P_fe_code); 859 860 dcl P_fe_code fixed bin (35); 861 862 P_code = P_fe_code; 863 if DEBUGGING then call probe (); 864 go to JUST_EXIT; 865 866 end fatal_create_error; 867 868 fatal_error: 869 proc (P_fe_code); 870 871 dcl P_fe_code fixed bin (35); 872 873 P_code = P_fe_code; 874 if DEBUGGING then call probe (); 875 if already_in_fatal_error /* recursive error */ then 876 go to JUST_EXIT; /* ... and don't do anything else */ 877 else do; 878 already_in_fatal_error = "1"b; 879 go to GLOBAL_EXIT; 880 end; 881 882 end fatal_error; 883 884 open_mail_table: 885 proc (); 886 887 dcl code fixed bin (35); 888 889 code = 0; 890 if mt_ptr ^= null () then return; 891 call ms_table_mgr_$open (MAIL_TABLE_DIR, MAIL_TABLE_NAME, MAIL_TABLE_TYPE_STRING, mt_ptr, mthp, code); 892 if code ^= 0 then call fatal_error (code); 893 894 return; 895 896 end open_mail_table; 897 898 close_mail_table: 899 proc (); 900 901 dcl code fixed bin (35); 902 903 code = 0; 904 already_inited = "0"b; 905 if mt_ptr = null () then return; /* Already closed */ 906 call ms_table_mgr_$close (mt_ptr, code); 907 if code ^= 0 then call fatal_error (code); 908 mt_ptr = null (); 909 return; 910 911 end close_mail_table; 912 913 lock_mail_table: 914 proc (); 915 916 dcl code fixed bin (35); 917 918 mail_table_locked = "1"b; 919 code = 0; 920 call set_lock_$lock (mail_table_header.write_lock, LOCK_WAIT_TIME, code); 921 if code ^= 0 then 922 if code ^= error_table_$invalid_lock_reset then do; 923 mail_table_locked = "0"b; 924 call fatal_error (code); 925 end; 926 if mail_table_header.write_count = BIG_NUMBER then 927 mail_table_header.write_count = 0; 928 else mail_table_header.write_count = mail_table_header.write_count + 1; 929 return; 930 931 end lock_mail_table; 932 933 unlock_mail_table: 934 proc (); 935 936 dcl code fixed bin (35); 937 938 if ^mail_table_locked then return; 939 code = 0; 940 call set_lock_$unlock (mail_table_header.write_lock, code); 941 if code ^= 0 & code ^= error_table_$locked_by_other_process then call fatal_error (code); 942 mail_table_locked = "0"b; 943 return; 944 945 end unlock_mail_table; 946 947 get_write_count: 948 proc (); 949 950 dcl code fixed bin (35); 951 dcl temp_lock bit (36) aligned; 952 953 original_time = clock (); 954 GET_COUNT_AGAIN: 955 code = 0; 956 original_write_count = mail_table_header.write_count; 957 temp_lock = mail_table_header.write_lock; /* We may not be able to modify the real lock */ 958 call set_lock_$lock (temp_lock, 0, code); 959 if code ^= 0 then 960 if code = error_table_$lock_wait_time_exceeded then do; 961 /* It was locked, so wait */ 962 if too_long () then call fatal_error (error_table_$lock_wait_time_exceeded); 963 call timer_manager_$sleep (1, "11"b); /* Sleep for 1 second */ 964 go to GET_COUNT_AGAIN; 965 end; 966 else if code ^= error_table_$invalid_lock_reset then call fatal_error (code); 967 if mt_modified () then go to GET_COUNT_AGAIN; 968 return; 969 970 end get_write_count; 971 972 mt_modified: 973 proc () returns (bit (1)); 974 975 if mail_table_header.write_count = original_write_count then return ("0"b); 976 else if too_long () then /* We've been trying for too long */ 977 call fatal_error (error_table_$lock_wait_time_exceeded); 978 else return ("1"b); 979 980 end mt_modified; 981 982 too_long: 983 proc () returns (bit (1)); 984 985 return (clock () - original_time > LOCK_WAIT_TIME * 1e6); 986 987 end too_long; 988 989 make_new_entry: 990 proc (P_id, P_real_mtep); 991 992 dcl P_id char (*) varying; 993 dcl P_real_mtep ptr; /* Output -> real_mte */ 994 995 dcl code fixed bin (35); 996 dcl person_id char (32); 997 dcl rmte_ptr ptr; /* -> new entry */ 998 999 code = 0; 1000 person_id = P_id; 1001 rmte_ptr = null (); 1002 call ms_table_mgr_$new_entry (mt_ptr, person_id, rmte_ptr, code); 1003 if code ^= 0 then call fatal_error (code); 1004 mail_table_header.entry_count = mail_table_header.entry_count + 1; 1005 P_real_mtep = rmte_ptr; 1006 return; 1007 1008 end make_new_entry; 1009 1010 update_new_entry: 1011 procedure (P_real_mtep); 1012 1013 dcl P_real_mtep ptr parameter; 1014 dcl rmte_ptr ptr; 1015 dcl code fixed bin (35); 1016 1017 rmte_ptr = P_real_mtep; 1018 call ms_table_mgr_$update_entry (mt_ptr, rmte_ptr, code); 1019 if code ^= 0 then call fatal_error (code); 1020 P_real_mtep = null (); /* Just to make sure no one updates without telling ms_table_mgr_ */ 1021 return; 1022 end update_new_entry; 1023 1024 delete_real_mte: 1025 proc (P_real_mte); 1026 1027 dcl 1 P_real_mte aligned like real_mte; 1028 1029 dcl code fixed bin (35); 1030 dcl person_id char (32); 1031 1032 code = 0; 1033 person_id = P_real_mte.name; 1034 call ms_table_mgr_$delete_entry (mt_ptr, person_id, code); 1035 if code ^= 0 then call fatal_error (code); 1036 mail_table_header.entry_count = mail_table_header.entry_count - 1; 1037 return; 1038 1039 end delete_real_mte; 1040 1041 retrieve_real_mte: 1042 proc (P_id, P_chase, P_case_ins, P_real_mtep); 1043 1044 dcl P_case_ins bit (1) parameter; /* Try case insensitive */ 1045 dcl P_chase bit (1) parameter; /* Chase alias links */ 1046 dcl P_id char (*) varying parameter; 1047 /* Name of entry to retrieve */ 1048 dcl P_real_mtep ptr parameter; /* Output ptr to entry */ 1049 dcl code fixed bin (35); 1050 dcl name char (32); 1051 dcl person_id char (32); /* Non-varying name */ 1052 dcl 1 rmte aligned like real_mte based (rmtep); 1053 dcl rmtep ptr; 1054 1055 code = 0; 1056 P_real_mtep = null (); 1057 person_id = P_id; 1058 call ms_table_mgr_$find_entry (mt_ptr, person_id, rmtep, NO_WRITE, ignore_rs, code); 1059 if code = error_table_$checksum_failure then code = 0; 1060 if code ^= 0 then 1061 /*** Look for case insensitive match ***/ 1062 if P_case_ins & code = error_table_$id_not_found then do; 1063 code = 0; 1064 call ms_table_mgr_$find_entry_case_ins (mt_ptr, person_id, rmtep, NO_WRITE, ignore_rs, code); 1065 if code = error_table_$checksum_failure then code = 0; 1066 if code = error_table_$request_id_ambiguous then call fatal_error (mlsys_et_$ambiguous_address); 1067 if code ^= 0 then call fatal_error (code); 1068 end; 1069 else call fatal_error (code); 1070 if P_chase & rmte.alias_entry then do; 1071 name = rmte.primary_name; 1072 call ms_table_mgr_$find_entry (mt_ptr, name, rmtep, NO_WRITE, ignore_rs, code); 1073 if code = error_table_$checksum_failure then code = 0; 1074 if code ^= 0 then call fatal_error (code); 1075 end; 1076 P_real_mtep = rmtep; 1077 return; 1078 1079 end retrieve_real_mte; 1080 1081 retrieve_real_mte_n: 1082 proc (P_index, P_real_mtep); 1083 1084 dcl P_index fixed bin parameter; 1085 dcl P_real_mtep ptr parameter; 1086 1087 dcl index fixed bin (35); 1088 dcl rmtep ptr; 1089 1090 code = 0; 1091 P_real_mtep = null (); 1092 index = P_index; 1093 call ms_table_mgr_$abs_entry (mt_ptr, index, (""), NO_WRITE, rmtep, ignore_rs, code); 1094 if code ^= 0 then call fatal_error (code); 1095 P_real_mtep = rmtep; 1096 return; 1097 1098 end retrieve_real_mte_n; 1099 1100 get_address: 1101 proc (P_mte, P_address); 1102 1103 dcl 1 P_mte aligned like real_mte; 1104 dcl P_address ptr; 1105 1106 dcl code fixed bin (35); 1107 dcl mail_system_$create_user_mailbox_address 1108 entry (char (*) var, char (*) var, char (*) var, ptr, fixed bin (35)); 1109 dcl mlsys_utils_$parse_address_text 1110 entry (char (*), ptr, fixed bin (35)); 1111 1112 code = 0; 1113 P_address = null (); 1114 if P_mte.registered_user & P_mte.mailing_address = "" then 1115 call mail_system_$create_user_mailbox_address (P_mte.name || "." || P_mte.default_project, "", "", 1116 P_address, code); 1117 1118 else call mlsys_utils_$parse_address_text ((P_mte.mailing_address), P_address, code); 1119 if code ^= 0 then call fatal_error (code); 1120 return; 1121 end get_address; 1122 1123 format_address: 1124 proc (P_address, P_string); 1125 1126 dcl P_address ptr; 1127 dcl P_string char (*) varying; 1128 1129 dcl buffer char (256); 1130 dcl buffer_used fixed bin (21); 1131 dcl code fixed bin (35); 1132 1133 dcl mlsys_utils_$format_address_field 1134 entry (char (*) var, ptr, fixed bin, ptr, fixed bin (21), fixed bin (21), 1135 fixed bin (35)); 1136 1137 code = 0; 1138 P_string = ""; 1139 buffer_used = 0; 1140 call mlsys_utils_$format_address_field ("", P_address, -1, addr (buffer), length (buffer), buffer_used, code); 1141 if code = error_table_$smallarg then /* buffer is not large enough */ call fatal_error (error_table_$bigarg); 1142 /* means address is too big */ 1143 if code ^= 0 then call fatal_error (code); 1144 P_string = substr (buffer, 1, buffer_used); 1145 return; 1146 end format_address; 1147 1148 check_acs_access: 1149 proc (P_path); 1150 1151 dcl 1 P_path aligned like mail_table_raw_entry.acs_path; 1152 dcl hcs_$get_user_access_modes 1153 entry (char (*), char (*), char (*), fixed bin, bit (36) aligned, 1154 bit (36) aligned, fixed bin (35)); 1155 dcl code fixed bin (35); 1156 dcl modes bit (36) aligned; 1157 1158 code = 0; 1159 if P_path.dir = "" then call fatal_error (error_table_$insufficient_access); 1160 /* Noone has access to nonexistent ACS */ 1161 call hcs_$get_user_access_modes ((P_path.dir), (P_path.entry), "", initial_ring, modes, (""b), code); 1162 if code ^= 0 | bool (modes, RW_ACCESS, "0100"b) then call fatal_error (error_table_$insufficient_access); 1163 return; 1164 1165 end check_acs_access; 1166 1167 check_mtep: 1168 proc (P_mtep); 1169 1170 dcl P_mtep ptr parameter; 1171 1172 if P_mtep = null () then call fatal_error (error_table_$null_info_ptr); 1173 if P_mtep -> mail_table_entry.version ^= MAIL_TABLE_ENTRY_VERSION_1 then 1174 call fatal_error (error_table_$unimplemented_version); 1175 return; 1176 1177 end check_mtep; 1178 1179 check_mtrep: 1180 proc (P_mtrep); 1181 1182 dcl P_mtrep ptr parameter; 1183 1184 if P_mtrep = null () then call fatal_error (error_table_$null_info_ptr); 1185 if P_mtrep -> mail_table_raw_entry.version ^= MAIL_TABLE_RAW_ENTRY_VERSION_1 then 1186 call fatal_error (error_table_$unimplemented_version); 1187 if P_mtrep -> mail_table_raw_entry.mbz ^= ""b /* MUST be zero */ then 1188 call fatal_error (error_table_$bad_subr_arg); 1189 return; 1190 1191 end check_mtrep; 1192 1193 set_mail_table_acl: 1194 proc (); 1195 1196 dcl code fixed bin (35); 1197 dcl fcb_ptr ptr; 1198 dcl 1 mt_acl aligned like segment_acl_entry; 1199 dcl msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 1200 dcl msf_manager_$close entry (ptr); 1201 dcl msf_manager_$acl_replace 1202 entry (ptr, ptr, fixed bin, bit (1), fixed bin (35)); 1203 1204 fcb_ptr = null (); 1205 code = 0; 1206 on cleanup 1207 begin; 1208 if fcb_ptr ^= null () then call msf_manager_$close (fcb_ptr); 1209 end; 1210 call msf_manager_$open (MAIL_TABLE_DIR, MAIL_TABLE_NAME, fcb_ptr, code); 1211 if code ^= 0 then call fatal_create_error (code); 1212 mt_acl.access_name = "*.*.*"; 1213 mt_acl.mode = RW_ACCESS; 1214 mt_acl.extended_mode = ""b; 1215 mt_acl.status_code = 0; 1216 call msf_manager_$acl_replace (fcb_ptr, addr (mt_acl), 1, "1"b, code); 1217 if code ^= 0 & code ^= error_table_$argerr then call fatal_create_error (code); 1218 if mt_acl.status_code ^= 0 then call fatal_create_error (mt_acl.status_code); 1219 call msf_manager_$close (fcb_ptr); 1220 return; 1221 1222 end set_mail_table_acl; 1223 1224 end mail_table_mgr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/02/89 0813.2 mail_table_mgr_.pl1 >spec>install>1079>mail_table_mgr_.pl1 209 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 211 2 10/14/83 1606.6 acl_structures.incl.pl1 >ldd>include>acl_structures.incl.pl1 213 3 10/27/83 2104.2 mail_table_entry.incl.pl1 >ldd>include>mail_table_entry.incl.pl1 215 4 12/07/84 1102.1 ms_table_info.incl.pl1 >ldd>include>ms_table_info.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. BIG_NUMBER constant fixed bin(17,0) initial dcl 163 ref 926 DEBUGGING constant bit(1) initial packed unaligned dcl 164 ref 863 874 LOCK_WAIT_TIME 000026 constant fixed bin(17,0) initial dcl 187 set ref 920* 985 MAIL_TABLE_ALIASES_VERSION_1 000000 constant char(8) initial packed unaligned dcl 3-51 ref 582 593 MAIL_TABLE_DIR 000012 internal static char(168) initial packed unaligned dcl 188 set ref 646 646* 647* 668* 696* 698* 711* 713* 762* 764* 768* 771* 776* 779* 824 824* 891* 1210* MAIL_TABLE_ENTRY_VERSION_1 000004 constant char(8) initial packed unaligned dcl 3-16 ref 1173 MAIL_TABLE_NAME 000016 constant char(32) initial packed unaligned dcl 190 set ref 647* 695 759 762* 764* 768* 768* 771* 776* 779 891* 1210* MAIL_TABLE_RAW_ENTRY_VERSION_1 000002 constant char(8) initial packed unaligned dcl 3-39 ref 327 438 500 1185 MAIL_TABLE_TYPE_STRING 000006 constant char(32) initial dcl 191 set ref 631 689 711* 891* MS_TABLE_INFO_VERSION_3 constant fixed bin(17,0) initial dcl 4-11 ref 630 688 NO_WRITE 000045 constant bit(1) initial dcl 200 set ref 723* 1058* 1064* 1072* 1093* P_acs_path parameter char packed unaligned dcl 53 set ref 221 234* 236* P_address parameter pointer dcl 1126 in procedure "format_address" set ref 1123 1140* P_address parameter pointer dcl 1104 in procedure "get_address" set ref 1100 1113* 1114* 1118* P_address_ptr parameter pointer dcl 54 set ref 221 233* 244 257 259* 264 P_alias parameter varying char dcl 55 ref 459 464 524 528 536 540 P_area_ptr parameter pointer dcl 57 ref 576 584 587 P_case_ins parameter bit(1) packed unaligned dcl 1044 ref 1041 1060 P_chase parameter bit(1) packed unaligned dcl 1045 ref 1041 1070 P_code parameter fixed bin(35,0) dcl 58 set ref 221 244 275 293 303 350 375 399 412 426 459 524 536 576 610 623 628* 677 852* 862* 873* P_count parameter fixed bin(17,0) dcl 59 set ref 610 616* 623 634 677 684 692 P_dft_proj parameter char packed unaligned dcl 60 ref 275 284 P_fe_code parameter fixed bin(35,0) dcl 871 in procedure "fatal_error" ref 868 873 P_fe_code parameter fixed bin(35,0) dcl 860 in procedure "fatal_create_error" ref 857 862 P_id parameter varying char dcl 61 in procedure "mail_table_mgr_" ref 221 227 229 244 250 255 256 275 278 350 354 375 378 399 404 459 463 576 583 P_id parameter varying char dcl 992 in procedure "make_new_entry" ref 989 1000 P_id parameter varying char dcl 1046 in procedure "retrieve_real_mte" ref 1041 1057 P_index parameter fixed bin(17,0) dcl 1084 in procedure "retrieve_real_mte_n" ref 1081 1092 P_index parameter fixed bin(17,0) dcl 63 in procedure "mail_table_mgr_" ref 412 417 426 431 P_message parameter char packed unaligned dcl 64 set ref 677 680* 685* 698* 713* 719* 734* 746* 764* 771* 779* P_mta_ptr parameter pointer dcl 65 set ref 576 602* P_mte parameter structure level 1 dcl 1103 ref 1100 P_mte_ptr parameter pointer dcl 66 set ref 293 303 313* 314 375 382* 383 P_mtep parameter pointer dcl 1170 ref 1167 1172 1173 P_mtre_ptr parameter pointer dcl 67 set ref 399 412 441* 442 P_mtrep parameter pointer dcl 1182 ref 1179 1184 1185 1187 P_path parameter structure level 1 dcl 1151 ref 1148 P_pnt parameter bit(1) packed unaligned dcl 68 ref 293 303 308 350 353 459 462 524 527 536 539 P_real_mte parameter structure level 1 dcl 1027 ref 1024 P_real_mtep parameter pointer dcl 1085 in procedure "retrieve_real_mte_n" set ref 1081 1091* 1095* P_real_mtep parameter pointer dcl 1013 in procedure "update_new_entry" set ref 1010 1017 1020* P_real_mtep parameter pointer dcl 1048 in procedure "retrieve_real_mte" set ref 1041 1056* 1076* P_real_mtep parameter pointer dcl 993 in procedure "make_new_entry" set ref 989 1005* P_return_id parameter varying char dcl 69 set ref 426 448* P_string parameter varying char dcl 1127 set ref 1123 1138* 1144* P_test_dir parameter char packed unaligned dcl 71 ref 664 668 P_version parameter char packed unaligned dcl 72 ref 426 438 576 582 RW_ACCESS constant bit(3) initial packed unaligned dcl 1-11 ref 1162 1213 access_name 000104 automatic char(32) level 2 packed packed unaligned dcl 1198 set ref 1212* acs_path 50 parameter structure level 3 in structure "P_real_mte" dcl 1027 in procedure "delete_real_mte" acs_path 50 based structure level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 263* 339* 390 acs_path 50 based structure level 2 in structure "mail_table_raw_entry" dcl 3-19 in procedure "mail_table_mgr_" acs_path 13 based structure level 2 in structure "mail_table_entry" dcl 3-6 in procedure "mail_table_mgr_" set ref 339 390* acs_path 50 based structure level 3 in structure "rmte" dcl 1052 in procedure "retrieve_real_mte" acs_path 50 parameter structure level 3 in structure "P_mte" dcl 1103 in procedure "get_address" addr builtin function dcl 205 ref 647 647 696 696 1140 1140 1216 1216 address 000100 automatic varying char(256) dcl 76 set ref 257* 259* 266 alias 000201 automatic varying char(32) dcl 77 set ref 464* 468 469 499* 501 515 528* 540* 548* alias_entry 24 based bit(1) level 4 in structure "real_mte" packed packed unaligned dcl 120 in procedure "mail_table_mgr_" set ref 505* 549 alias_entry 24 based bit(1) level 4 in structure "rmte" packed packed unaligned dcl 1052 in procedure "retrieve_real_mte" ref 1070 already_in_fatal_error 000212 automatic bit(1) packed unaligned dcl 78 set ref 817* 875 878* already_inited 000010 internal static bit(1) initial packed unaligned dcl 161 set ref 819 826* 904* anon 000213 automatic fixed bin(17,0) dcl 80 set ref 820* 821 anonymous_user 000011 internal static bit(1) packed unaligned dcl 162 set ref 250 821* 823* any_other 000352 stack reference condition dcl 207 ref 225 248 280 311 356 380 435 466 545 580 614 644 682 bool builtin function dcl 205 ref 1162 buffer 000552 automatic char(256) packed unaligned dcl 1129 set ref 1140 1140 1140 1140 1144 buffer_used 000652 automatic fixed bin(21,0) dcl 1130 set ref 1139* 1140* 1144 by_name_number 000214 automatic bit(1) packed unaligned dcl 81 set ref 403* 416* 430* 437 446 448 451 by_number 000215 automatic bit(1) packed unaligned dcl 82 set ref 402* 415* 429* 446 case_insensitive_sw 000216 automatic bit(1) packed unaligned dcl 83 set ref 529* 541* 548* character builtin function dcl 205 ref 746 cleanup 000360 stack reference condition dcl 207 ref 224 247 279 310 355 379 433 465 470 491 543 579 613 639 656 681 707 1206 clock builtin function dcl 205 ref 753 753 953 985 code 000100 automatic fixed bin(35,0) dcl 916 in procedure "lock_mail_table" set ref 919* 920* 921 921 924* code 000100 automatic fixed bin(35,0) dcl 1196 in procedure "set_mail_table_acl" set ref 1205* 1210* 1211 1211* 1216* 1217 1217 1217* code 000100 automatic fixed bin(35,0) dcl 901 in procedure "close_mail_table" set ref 903* 906* 907 907* code 000100 automatic fixed bin(35,0) dcl 995 in procedure "make_new_entry" set ref 999* 1002* 1003 1003* code 000476 automatic fixed bin(35,0) dcl 1049 in procedure "retrieve_real_mte" set ref 1055* 1058* 1059 1059* 1060 1060 1063* 1064* 1065 1065* 1066 1067 1067* 1069* 1072* 1073 1073* 1074 1074* code 000100 automatic fixed bin(35,0) dcl 936 in procedure "unlock_mail_table" set ref 939* 940* 941 941 941* code 000452 automatic fixed bin(35,0) dcl 950 in procedure "get_write_count" set ref 954* 958* 959 959 966 966* code 000375 automatic fixed bin(35,0) dcl 626 in procedure "mail_table_mgr_" set ref 629* 647* 648 648* 696* 697 699* 711* 712 714* 723* 724 725* 726 729* 730 732 732* 736* 739 739* 741 743* 747* 762* 763 766* 768* 770 772* 776* 778 780* 1090* 1093* 1094 1094* code 000662 automatic fixed bin(35,0) dcl 1155 in procedure "check_acs_access" set ref 1158* 1161* 1162 code 000442 automatic fixed bin(35,0) dcl 887 in procedure "open_mail_table" set ref 889* 891* 892 892* code 000102 automatic fixed bin(35,0) dcl 1015 in procedure "update_new_entry" set ref 1018* 1019 1019* code 000100 automatic fixed bin(35,0) dcl 1029 in procedure "delete_real_mte" set ref 1032* 1034* 1035 1035* code 000542 automatic fixed bin(35,0) dcl 1106 in procedure "get_address" set ref 1112* 1114* 1118* 1119 1119* code 000653 automatic fixed bin(35,0) dcl 1131 in procedure "format_address" set ref 1137* 1140* 1141 1143 1143* cu_$level_get 000100 constant entry external dcl 126 ref 638 807 cu_$level_set 000102 constant entry external dcl 126 ref 799 808 cur_mtep 000220 automatic pointer dcl 84 set ref 476* 477 480* 481 482 486 487* 495 495 513 513* 552* 553 554 555 556* 557* 559 559* 561 561* day 000222 automatic fixed bin(17,0) dcl 85 set ref 753* 756 decode_clock_value_$date_time 000104 constant entry external dcl 130 ref 753 default_project 132 parameter varying char(12) level 3 in structure "P_mte" dcl 1103 in procedure "get_address" ref 1114 default_project 132 based varying char(12) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 284* 335 340* 389 509* default_project 75 based varying char(12) level 2 in structure "mail_table_entry" dcl 3-6 in procedure "mail_table_mgr_" set ref 316 335 340 389* delete_acl_entry based structure level 1 dcl 2-63 dir 50 based char(168) level 4 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 234 236 509* dir parameter char(168) level 2 in structure "P_path" dcl 1151 in procedure "check_acs_access" ref 1159 1161 directory_acl_entry based structure level 1 dcl 2-54 disp_day 000223 automatic picture(2) packed unaligned dcl 86 set ref 756* 759 disp_hour 000224 automatic picture(2) packed unaligned dcl 86 set ref 757* 759 disp_minute 000225 automatic picture(2) packed unaligned dcl 86 set ref 758* 759 disp_month 000226 automatic picture(2) packed unaligned dcl 86 set ref 755* 759 entry 52 parameter char(32) level 2 in structure "P_path" dcl 1151 in procedure "check_acs_access" ref 1161 entry 122 based char(32) level 4 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 236 509* entry_count 2 based fixed bin(17,0) level 2 in structure "nmth" dcl 704 in begin block on line 701 set ref 716* 728* 728 entry_count 2 based fixed bin(17,0) level 2 in structure "mail_table_header" dcl 116 in procedure "mail_table_mgr_" set ref 616 650* 684 1004* 1004 1036* 1036 entry_num 000227 automatic fixed bin(35,0) dcl 88 set ref 722* 723* 746* entry_size 12 000251 automatic fixed bin(18,0) level 2 unsigned dcl 99 set ref 633* 691* error_table_$action_not_performed 000152 external static fixed bin(35,0) dcl 165 set ref 250* error_table_$argerr 000154 external static fixed bin(35,0) dcl 165 ref 1217 error_table_$bad_index 000156 external static fixed bin(35,0) dcl 165 ref 741 error_table_$bad_subr_arg 000160 external static fixed bin(35,0) dcl 165 set ref 264* 316* 335* 360* 468* 475* 549* 1187* error_table_$bigarg 000162 external static fixed bin(35,0) dcl 165 set ref 256* 469* 1141* error_table_$checksum_failure 000164 external static fixed bin(35,0) dcl 165 ref 1059 1065 1073 error_table_$id_already_exists 000166 external static fixed bin(35,0) dcl 165 ref 732 error_table_$id_not_found 000170 external static fixed bin(35,0) dcl 165 ref 1060 error_table_$insufficient_access 000172 external static fixed bin(35,0) dcl 165 set ref 1159* 1162* error_table_$invalid_lock_reset 000174 external static fixed bin(35,0) dcl 165 ref 921 966 error_table_$lock_wait_time_exceeded 000176 external static fixed bin(35,0) dcl 165 set ref 959 962* 976* error_table_$locked_by_other_process 000200 external static fixed bin(35,0) dcl 165 ref 941 error_table_$no_record 000202 external static fixed bin(35,0) dcl 165 ref 739 error_table_$null_info_ptr 000204 external static fixed bin(35,0) dcl 165 set ref 584* 1172* 1184* error_table_$request_id_ambiguous 000206 external static fixed bin(35,0) dcl 165 ref 1066 error_table_$smallarg 000210 external static fixed bin(35,0) dcl 165 set ref 686* 1141 error_table_$unexpected_condition 000212 external static fixed bin(35,0) dcl 165 set ref 644* error_table_$unimplemented_version 000214 external static fixed bin(35,0) dcl 165 set ref 438* 582* 1173* 1185* extended_mode 11 000104 automatic bit(36) level 2 dcl 1198 set ref 1214* fcb_ptr 000102 automatic pointer dcl 1197 set ref 1204* 1208 1208* 1210* 1216* 1219* flags 24 based structure level 3 in structure "rmte" dcl 1052 in procedure "retrieve_real_mte" flags 24 parameter structure level 3 in structure "P_mte" dcl 1103 in procedure "get_address" flags 24 based structure level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 326* 503* flags 24 based structure level 2 in structure "mail_table_raw_entry" dcl 3-19 in procedure "mail_table_mgr_" general_acl_entry based structure level 1 unaligned dcl 2-12 general_delete_acl_entry based structure level 1 dcl 2-35 general_extended_acl_entry based structure level 1 dcl 2-23 get_ring_ 000106 constant entry external dcl 133 ref 808 hcs_$chname_file 000110 constant entry external dcl 134 ref 762 768 776 hcs_$get_user_access_modes 000234 constant entry external dcl 1152 ref 1161 header_size 11 000251 automatic fixed bin(18,0) level 2 unsigned dcl 99 set ref 632* 690* hour 000230 automatic fixed bin(17,0) dcl 89 set ref 753* 757 i 000231 automatic fixed bin(17,0) dcl 90 set ref 594* 595* ignore_code 000232 automatic fixed bin(35,0) dcl 91 set ref 709* 750* 753* ignore_rs 000233 automatic fixed bin(35,0) dcl 92 set ref 723* 753* 753* 753* 753* 1058* 1064* 1072* 1093* index 000234 automatic fixed bin(17,0) dcl 93 in procedure "mail_table_mgr_" set ref 417* 431* 447* index 000530 automatic fixed bin(35,0) dcl 1087 in procedure "retrieve_real_mte_n" set ref 1092* 1093* initial_ring 000235 automatic fixed bin(17,0) dcl 94 set ref 638* 799* 807* 1161* keep_meters 15 000251 automatic bit(1) level 2 dcl 99 set ref 636* 694* key 000236 automatic char(32) packed unaligned dcl 95 set ref 723* 725* 734 length builtin function dcl 205 ref 227 256 469 1140 1140 mail_system_$create_user_mailbox_address 000226 constant entry external dcl 1107 ref 1114 mail_table_aliases based structure level 1 dcl 3-42 set ref 591 599 mail_table_aliases_extent 000374 automatic fixed bin(17,0) dcl 3-49 set ref 589* 591 591 mail_table_aliases_ptr 000372 automatic pointer dcl 3-47 set ref 591* 593 594 595 599 602 mail_table_entry based structure level 1 dcl 3-6 mail_table_entry_ptr 000366 automatic pointer dcl 3-15 set ref 256 314* 316 325 328 334 335 339 340 341 383* 387 388 389 390 469 mail_table_header based structure level 1 dcl 116 set ref 632 690 mail_table_locked 000246 automatic bit(1) packed unaligned dcl 96 set ref 816* 918* 923* 938 942* mail_table_raw_entry based structure level 1 dcl 3-19 set ref 451* mail_table_raw_entry_ptr 000370 automatic pointer dcl 3-37 set ref 442* 451 mailing_address 101 based varying char(256) level 2 in structure "mail_table_entry" dcl 3-6 in procedure "mail_table_mgr_" set ref 341 388* mailing_address 136 based varying char(256) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 266* 341* 388 509* mailing_address 136 parameter varying char(256) level 3 in structure "P_mte" dcl 1103 in procedure "get_address" ref 1114 1118 max_entries 13 000251 automatic fixed bin(18,0) level 2 unsigned dcl 99 set ref 634* 692* max_size 14 000251 automatic fixed bin(19,0) level 2 dcl 99 set ref 635* 693* maxlength builtin function dcl 205 ref 256 469 mbz 24(02) based bit(34) level 3 packed packed unaligned dcl 3-19 set ref 1187 minute 000247 automatic fixed bin(17,0) dcl 97 set ref 753* 758 mlsys_data_$system_directory 000222 external static char(168) packed unaligned dcl 193 ref 646 824 mlsys_et_$ambiguous_address 000216 external static fixed bin(35,0) dcl 165 set ref 1066* mlsys_et_$bad_mail_table 000220 external static fixed bin(35,0) dcl 165 set ref 844* mlsys_utils_$format_address_field 000232 constant entry external dcl 1133 ref 1140 mlsys_utils_$parse_address_text 000230 constant entry external dcl 1109 ref 1118 mode 10 000104 automatic bit(36) level 2 dcl 1198 set ref 1213* modes 000663 automatic bit(36) dcl 1156 set ref 1161* 1162 month 000250 automatic fixed bin(17,0) dcl 98 set ref 753* 755 ms_table_info based structure level 1 dcl 4-14 ms_table_mgr_$abs_entry 000114 constant entry external dcl 136 ref 723 1093 ms_table_mgr_$close 000112 constant entry external dcl 135 ref 709 750 906 ms_table_mgr_$create 000116 constant entry external dcl 139 ref 647 696 ms_table_mgr_$delete_entry 000120 constant entry external dcl 140 ref 1034 ms_table_mgr_$find_entry 000122 constant entry external dcl 142 ref 1058 1072 ms_table_mgr_$find_entry_case_ins 000124 constant entry external dcl 144 ref 1064 ms_table_mgr_$new_entry 000126 constant entry external dcl 146 ref 725 1002 ms_table_mgr_$open 000130 constant entry external dcl 148 ref 711 891 ms_table_mgr_$update_entry 000132 constant entry external dcl 149 ref 729 1018 msf_manager_$acl_replace 000242 constant entry external dcl 1201 ref 1216 msf_manager_$close 000240 constant entry external dcl 1200 ref 1208 1219 msf_manager_$open 000236 constant entry external dcl 1199 ref 1210 msti 000251 automatic structure level 1 dcl 99 set ref 647 647 696 696 mt_acl 000104 automatic structure level 1 dcl 1198 set ref 1216 1216 mt_ptr 000064 internal static pointer initial dcl 195 set ref 637* 723* 890 891* 905 906* 908* 1002* 1018* 1034* 1058* 1064* 1072* 1093* mthp 000066 internal static pointer initial dcl 197 set ref 616 632 650 651 652 684 690 891* 920 926 926 928 928 940 956 957 975 1004 1004 1036 1036 my_area based area(1024) dcl 100 ref 591 599 my_area_ptr 000270 automatic pointer dcl 101 set ref 587* 591 599 my_person_id 000070 internal static char(32) packed unaligned dcl 199 set ref 227 254 263 820* n_names 2 based fixed bin(17,0) level 2 in structure "mail_table_aliases" dcl 3-42 in procedure "mail_table_mgr_" set ref 591* 594 599 n_names 25 based fixed bin(17,0) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 330* 514* 514 567* 567 589 name 2 based varying char(32) level 2 in structure "mail_table_entry" dcl 3-6 in procedure "mail_table_mgr_" set ref 256 325* 328 334* 387* 469 name 2 based varying char(32) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 263 328* 387 448 501* 502 554 595 name 2 parameter varying char(32) level 3 in structure "P_real_mte" dcl 1027 in procedure "delete_real_mte" ref 1033 name 000477 automatic char(32) packed unaligned dcl 1050 in procedure "retrieve_real_mte" set ref 1071* 1072* name 2 parameter varying char(32) level 3 in structure "P_mte" dcl 1103 in procedure "get_address" ref 1114 names 3 based varying char(32) array level 2 dcl 3-42 set ref 595* new 000272 automatic bit(1) packed unaligned dcl 102 set ref 296* 306* 316 324 new_mtep 000274 automatic pointer dcl 103 set ref 472* 493 494 499* 500 501 502 503 504 505 506 507 509 509 509 509 511* 725* 727 729* new_name 000276 automatic char(32) packed unaligned dcl 104 set ref 695* 696* 698* 711* 713* 776* 776* 779* new_new_name 000306 automatic char(32) packed unaligned dcl 105 set ref 759* 762* 764 next_name 26 based varying char(32) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 331* 361 362 477 477 486 507* 507 515* 554 555* 555 559 561* 596 596* next_name 000316 automatic varying char(32) dcl 106 in procedure "mail_table_mgr_" set ref 362* 364* 477* 480* nmt_ptr 000100 automatic pointer dcl 702 set ref 706* 709 709* 711* 725* 729* 750* nmth based structure level 1 dcl 704 nmth_ptr 000102 automatic pointer dcl 703 set ref 711* 716 717 718 728 728 null builtin function dcl 205 ref 257 264 322 472 487 493 495 513 553 557 559 584 637 706 709 890 905 908 1001 1020 1056 1091 1113 1172 1184 1204 1208 original_time 000330 automatic fixed bin(71,0) dcl 107 set ref 953* 985 original_write_count 000332 automatic fixed bin(17,0) dcl 108 set ref 956* 975 pathname_ 000134 constant entry external dcl 151 ref 236 698 713 764 771 779 person_id 000333 automatic varying char(32) dcl 109 in procedure "mail_table_mgr_" set ref 227* 229* 232* 254* 255* 261* 278* 283* 354* 359* 378* 386* 404* 450* 463* 474* 564* 566* 583* 588* person_id 000101 automatic char(32) packed unaligned dcl 1030 in procedure "delete_real_mte" set ref 1033* 1034* person_id 000507 automatic char(32) packed unaligned dcl 1051 in procedure "retrieve_real_mte" set ref 1057* 1058* 1064* person_id 000101 automatic char(32) packed unaligned dcl 996 in procedure "make_new_entry" set ref 1000* 1002* pnt 000344 automatic bit(1) packed unaligned dcl 110 set ref 308* 316 329 335 335 353* 360 462* 475 477 495 504 527* 539* 549 prev_name 37 based varying char(32) level 3 dcl 120 set ref 331* 506* primary_name 13 based varying char(32) level 3 in structure "rmte" dcl 1052 in procedure "retrieve_real_mte" ref 1071 primary_name 13 based varying char(32) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 328* 502* 552* 564 probe 000136 constant entry external dcl 152 ref 863 874 raw_entry based structure level 2 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 451 raw_entry parameter structure level 2 in structure "P_mte" dcl 1103 in procedure "get_address" raw_entry parameter structure level 2 in structure "P_real_mte" dcl 1027 in procedure "delete_real_mte" raw_entry based structure level 2 in structure "rmte" dcl 1052 in procedure "retrieve_real_mte" real_mte based structure level 1 dcl 120 set ref 233* 363* 366* 494* 565* 633 691 727* 727 real_mtep 000346 automatic pointer dcl 111 set ref 232* 233 234 236 236 261* 263 263 264 266 267* 283* 284 285* 322* 325* 326 327 328 328 329 330 331 331 334* 335 335 339 340 341 342* 359* 360 361 362 363 364* 366 386* 387 388 389 390 447* 448 450* 451 472* 474* 475 476 477 502 507 514 514 515 516* 548* 549 549 552 554 555 564 565 566* 567 567 568* 588* 589 595 596 596 596* 633 691 723* 727 registered_user 24(01) based bit(1) level 4 in structure "real_mte" packed packed unaligned dcl 120 in procedure "mail_table_mgr_" set ref 264 329* 335 360 475 481 482* 495* 504* 549 registered_user 24(01) parameter bit(1) level 4 in structure "P_mte" packed packed unaligned dcl 1103 in procedure "get_address" ref 1114 rmte based structure level 1 dcl 1052 rmte_ptr 000100 automatic pointer dcl 1014 in procedure "update_new_entry" set ref 1017* 1018* rmte_ptr 000112 automatic pointer dcl 997 in procedure "make_new_entry" set ref 1001* 1002* 1005 rmtep 000532 automatic pointer dcl 1088 in procedure "retrieve_real_mte_n" set ref 1093* 1095 rmtep 000520 automatic pointer dcl 1053 in procedure "retrieve_real_mte" set ref 1058* 1064* 1070 1071 1072* 1076 rtrim builtin function dcl 205 ref 695 734 759 764 segment_acl_entry based structure level 1 dcl 2-45 set_lock_$lock 000140 constant entry external dcl 153 ref 920 958 set_lock_$unlock 000142 constant entry external dcl 154 ref 940 size builtin function dcl 205 ref 632 633 690 691 status_code 12 000104 automatic fixed bin(35,0) level 2 dcl 1198 set ref 1215* 1218 1218* string builtin function dcl 205 set ref 326* 503* substr builtin function dcl 205 ref 1144 sys_info$max_seg_size 000224 external static fixed bin(19,0) dcl 201 ref 635 693 temp_lock 000453 automatic bit(36) dcl 951 set ref 957* 958* theres_more 000350 automatic bit(1) packed unaligned dcl 112 set ref 721* 722 742* timer_manager_$sleep 000144 constant entry external dcl 155 ref 963 type 1 000251 automatic char(32) level 2 dcl 99 set ref 631* 689* unique_chars_ 000146 constant entry external dcl 156 ref 695 user_info_$login_data 000150 constant entry external dcl 157 ref 820 version based char(8) level 2 in structure "mail_table_entry" dcl 3-6 in procedure "mail_table_mgr_" ref 1173 version based char(8) level 2 in structure "mail_table_aliases" dcl 3-42 in procedure "mail_table_mgr_" set ref 593* version based char(8) level 3 in structure "real_mte" dcl 120 in procedure "mail_table_mgr_" set ref 327* 500* version 000251 automatic fixed bin(17,0) level 2 in structure "msti" dcl 99 in procedure "mail_table_mgr_" set ref 630* 688* version based char(8) level 2 in structure "mail_table_raw_entry" dcl 3-19 in procedure "mail_table_mgr_" set ref 1185 write_count 1 based fixed bin(17,0) level 2 in structure "mail_table_header" dcl 116 in procedure "mail_table_mgr_" set ref 652* 926 926* 928* 928 956 975 write_count 1 based fixed bin(17,0) level 2 in structure "nmth" dcl 704 in begin block on line 701 set ref 718* write_lock based bit(36) level 2 in structure "mail_table_header" dcl 116 in procedure "mail_table_mgr_" set ref 651* 920* 940* 957 write_lock based bit(36) level 2 in structure "nmth" dcl 704 in begin block on line 701 set ref 717* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 2-77 A_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DELETE_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 DIR_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 E_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 GENERAL_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 GENERAL_DELETE_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 GENERAL_EXTENDED_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 M_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-30 SEG_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 W_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 acl_count automatic fixed bin(17,0) dcl 2-5 acl_ptr automatic pointer dcl 2-4 delete_acl based structure level 1 dcl 2-58 delete_acl_array based structure array level 1 dcl 2-64 directory_acl based structure level 1 dcl 2-49 directory_acl_array based structure array level 1 dcl 2-55 general_acl based structure level 1 dcl 2-7 general_delete_acl based structure level 1 dcl 2-30 general_extended_acl based structure level 1 dcl 2-18 segment_acl based structure level 1 dcl 2-40 segment_acl_array based structure array level 1 dcl 2-46 NAMES DECLARED BY EXPLICIT CONTEXT. ADD_THE_ALIAS 002623 constant label dcl 489 ref 484 ADD_UPDATE_COMMON 001144 constant label dcl 308 ref 297 CREATE_ERROR 005074 constant label dcl 734 ref 730 DELETE_ALIAS_COMMON 003126 constant label dcl 543 ref 530 GET_COUNT_AGAIN 006531 constant label dcl 954 ref 964 967 GET_RAW_COMMON 002153 constant label dcl 433 ref 405 418 GET_TRY_AGAIN 000355 constant label dcl 230 ref 237 GLOBAL_EXIT 006020 constant label dcl 789 ref 853 879 JUST_EXIT 006024 constant label dcl 791 ref 657 864 875 TRY_GET_ALIASES_AGAIN 003546 constant label dcl 585 ref 600 TRY_GET_RAW_AGAIN 002254 constant label dcl 444 ref 452 TRY_PRIV_GET_AGAIN 001773 constant label dcl 384 ref 391 any_other_proc 006176 constant entry internal dcl 841 ref 225 248 280 311 356 380 435 466 545 580 614 682 check_acs_access 007753 constant entry internal dcl 1148 ref 263 check_mtep 010064 constant entry internal dcl 1167 ref 313 382 check_mtrep 010120 constant entry internal dcl 1179 ref 441 cleanup_proc 006155 constant entry internal dcl 832 ref 224 247 279 310 355 379 433 465 470 543 579 613 681 789 close_mail_table 006352 constant entry internal dcl 898 ref 641 653 667 775 delete_real_mte 007050 constant entry internal dcl 1024 ref 363 366 494 565 exit_proc 006213 constant entry internal dcl 849 ref 238 269 287 344 368 392 453 518 570 603 617 783 fatal_create_error 006217 constant entry internal dcl 857 ref 644 648 1211 1217 1218 fatal_error 006242 constant entry internal dcl 868 ref 250 256 264 316 335 360 438 468 469 475 549 582 584 686 699 714 736 747 766 772 780 844 892 907 924 941 962 966 976 1003 1019 1035 1066 1067 1069 1074 1094 1119 1141 1143 1159 1162 1172 1173 1184 1185 1187 format_address 007632 constant entry internal dcl 1123 ref 259 get_address 007461 constant entry internal dcl 1100 ref 233 get_write_count 006526 constant entry internal dcl 947 ref 230 384 444 585 lock_mail_table 006413 constant entry internal dcl 913 ref 260 282 323 358 473 547 720 lower_validation 006043 constant entry internal dcl 804 ref 592 645 818 mail_table_mgr_ 000227 constant entry external dcl 48 mail_table_mgr_$add 001106 constant entry external dcl 293 mail_table_mgr_$add_alias 002333 constant entry external dcl 459 mail_table_mgr_$count_entries 003711 constant entry external dcl 610 mail_table_mgr_$create_table 003777 constant entry external dcl 623 mail_table_mgr_$delete 001460 constant entry external dcl 350 mail_table_mgr_$delete_alias 003026 constant entry external dcl 524 mail_table_mgr_$delete_alias_case_ins 003067 constant entry external dcl 536 mail_table_mgr_$get 000242 constant entry external dcl 221 mail_table_mgr_$get_aliases 003413 constant entry external dcl 576 mail_table_mgr_$get_name_by_index 002122 constant entry external dcl 426 mail_table_mgr_$get_raw_by_index 002076 constant entry external dcl 412 mail_table_mgr_$get_raw_by_name 002037 constant entry external dcl 399 mail_table_mgr_$priv_get 001663 constant entry external dcl 375 mail_table_mgr_$put 000461 constant entry external dcl 244 mail_table_mgr_$salvage 004246 constant entry external dcl 677 mail_table_mgr_$set_dft_proj 000737 constant entry external dcl 275 mail_table_mgr_$test 004213 constant entry external dcl 664 mail_table_mgr_$update 001127 constant entry external dcl 303 make_new_entry 006717 constant entry internal dcl 989 ref 325 499 mt_modified 006630 constant entry internal dcl 972 ref 237 391 452 598 967 open_mail_table 006275 constant entry internal dcl 884 ref 649 825 raise_validation 006026 constant entry internal dcl 796 ref 590 642 655 836 retrieve_real_mte 007122 constant entry internal dcl 1041 ref 232 261 283 334 359 364 386 450 474 480 548 552 561 566 588 596 retrieve_real_mte_n 007400 constant entry internal dcl 1081 ref 447 set_mail_table_acl 010172 constant entry internal dcl 1193 ref 654 782 setup 006074 constant entry internal dcl 813 ref 226 249 281 312 357 381 436 467 471 546 581 615 683 too_long 006673 constant entry internal dcl 982 ref 962 976 unlock_mail_table 006466 constant entry internal dcl 933 ref 268 286 343 367 517 569 774 835 update_new_entry 007007 constant entry internal dcl 1010 ref 267 285 342 511 513 516 556 568 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 12536 13002 10617 12546 Length 13624 10617 244 606 1717 70 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mail_table_mgr_ 862 external procedure is an external procedure. on unit on line 224 64 on unit on unit on line 225 64 on unit on unit on line 247 64 on unit on unit on line 248 64 on unit on unit on line 279 64 on unit on unit on line 280 64 on unit on unit on line 310 64 on unit on unit on line 311 64 on unit on unit on line 355 64 on unit on unit on line 356 64 on unit on unit on line 379 64 on unit on unit on line 380 64 on unit on unit on line 433 64 on unit on unit on line 435 64 on unit on unit on line 465 64 on unit on unit on line 466 64 on unit on unit on line 470 64 on unit begin block on line 489 82 begin block enables or reverts conditions. on unit on line 491 70 on unit on unit on line 543 64 on unit on unit on line 545 64 on unit on unit on line 579 64 on unit on unit on line 580 64 on unit on unit on line 613 64 on unit on unit on line 614 64 on unit on unit on line 639 64 on unit on unit on line 644 70 on unit on unit on line 681 64 on unit on unit on line 682 64 on unit begin block on line 701 144 begin block enables or reverts conditions. on unit on line 707 70 on unit raise_validation 68 internal procedure is called by several nonquick procedures. lower_validation internal procedure shares stack frame of external procedure mail_table_mgr_. setup internal procedure shares stack frame of external procedure mail_table_mgr_. cleanup_proc 64 internal procedure is called by several nonquick procedures. any_other_proc 70 internal procedure is called by several nonquick procedures. exit_proc internal procedure shares stack frame of external procedure mail_table_mgr_. fatal_create_error 64 internal procedure is called by several nonquick procedures. fatal_error 64 internal procedure is called by several nonquick procedures. open_mail_table internal procedure shares stack frame of external procedure mail_table_mgr_. close_mail_table 72 internal procedure is called by several nonquick procedures. lock_mail_table 74 internal procedure is called by several nonquick procedures. unlock_mail_table 72 internal procedure is called by several nonquick procedures. get_write_count internal procedure shares stack frame of external procedure mail_table_mgr_. mt_modified internal procedure shares stack frame of external procedure mail_table_mgr_. too_long internal procedure shares stack frame of external procedure mail_table_mgr_. make_new_entry 96 internal procedure is called by several nonquick procedures. update_new_entry 76 internal procedure is called by several nonquick procedures. delete_real_mte 88 internal procedure is called by several nonquick procedures. retrieve_real_mte internal procedure shares stack frame of external procedure mail_table_mgr_. retrieve_real_mte_n internal procedure shares stack frame of external procedure mail_table_mgr_. get_address internal procedure shares stack frame of external procedure mail_table_mgr_. format_address internal procedure shares stack frame of external procedure mail_table_mgr_. check_acs_access internal procedure shares stack frame of external procedure mail_table_mgr_. check_mtep internal procedure shares stack frame of external procedure mail_table_mgr_. check_mtrep internal procedure shares stack frame of external procedure mail_table_mgr_. set_mail_table_acl 108 internal procedure enables or reverts conditions. on unit on line 1206 68 on unit STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 already_inited mail_table_mgr_ 000011 anonymous_user mail_table_mgr_ 000012 MAIL_TABLE_DIR mail_table_mgr_ 000064 mt_ptr mail_table_mgr_ 000066 mthp mail_table_mgr_ 000070 my_person_id mail_table_mgr_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 701 000100 nmt_ptr begin block on line 701 000102 nmth_ptr begin block on line 701 close_mail_table 000100 code close_mail_table delete_real_mte 000100 code delete_real_mte 000101 person_id delete_real_mte lock_mail_table 000100 code lock_mail_table mail_table_mgr_ 000100 address mail_table_mgr_ 000201 alias mail_table_mgr_ 000212 already_in_fatal_error mail_table_mgr_ 000213 anon mail_table_mgr_ 000214 by_name_number mail_table_mgr_ 000215 by_number mail_table_mgr_ 000216 case_insensitive_sw mail_table_mgr_ 000220 cur_mtep mail_table_mgr_ 000222 day mail_table_mgr_ 000223 disp_day mail_table_mgr_ 000224 disp_hour mail_table_mgr_ 000225 disp_minute mail_table_mgr_ 000226 disp_month mail_table_mgr_ 000227 entry_num mail_table_mgr_ 000230 hour mail_table_mgr_ 000231 i mail_table_mgr_ 000232 ignore_code mail_table_mgr_ 000233 ignore_rs mail_table_mgr_ 000234 index mail_table_mgr_ 000235 initial_ring mail_table_mgr_ 000236 key mail_table_mgr_ 000246 mail_table_locked mail_table_mgr_ 000247 minute mail_table_mgr_ 000250 month mail_table_mgr_ 000251 msti mail_table_mgr_ 000270 my_area_ptr mail_table_mgr_ 000272 new mail_table_mgr_ 000274 new_mtep mail_table_mgr_ 000276 new_name mail_table_mgr_ 000306 new_new_name mail_table_mgr_ 000316 next_name mail_table_mgr_ 000330 original_time mail_table_mgr_ 000332 original_write_count mail_table_mgr_ 000333 person_id mail_table_mgr_ 000344 pnt mail_table_mgr_ 000346 real_mtep mail_table_mgr_ 000350 theres_more mail_table_mgr_ 000366 mail_table_entry_ptr mail_table_mgr_ 000370 mail_table_raw_entry_ptr mail_table_mgr_ 000372 mail_table_aliases_ptr mail_table_mgr_ 000374 mail_table_aliases_extent mail_table_mgr_ 000375 code mail_table_mgr_ 000442 code open_mail_table 000452 code get_write_count 000453 temp_lock get_write_count 000476 code retrieve_real_mte 000477 name retrieve_real_mte 000507 person_id retrieve_real_mte 000520 rmtep retrieve_real_mte 000530 index retrieve_real_mte_n 000532 rmtep retrieve_real_mte_n 000542 code get_address 000552 buffer format_address 000652 buffer_used format_address 000653 code format_address 000662 code check_acs_access 000663 modes check_acs_access make_new_entry 000100 code make_new_entry 000101 person_id make_new_entry 000112 rmte_ptr make_new_entry set_mail_table_acl 000100 code set_mail_table_acl 000102 fcb_ptr set_mail_table_acl 000104 mt_acl set_mail_table_acl unlock_mail_table 000100 code unlock_mail_table update_new_entry 000100 rmte_ptr update_new_entry 000102 code update_new_entry THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 r_l_a r_ne_as alloc_char_temp realloc_char_temp cat_realloc_chars enter_begin_block leave_begin_block call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 signal_op enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc op_alloc_ op_freen_ clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$level_get cu_$level_set decode_clock_value_$date_time get_ring_ hcs_$chname_file hcs_$get_user_access_modes mail_system_$create_user_mailbox_address mlsys_utils_$format_address_field mlsys_utils_$parse_address_text ms_table_mgr_$abs_entry ms_table_mgr_$close ms_table_mgr_$create ms_table_mgr_$delete_entry ms_table_mgr_$find_entry ms_table_mgr_$find_entry_case_ins ms_table_mgr_$new_entry ms_table_mgr_$open ms_table_mgr_$update_entry msf_manager_$acl_replace msf_manager_$close msf_manager_$open pathname_ probe set_lock_$lock set_lock_$unlock timer_manager_$sleep unique_chars_ user_info_$login_data THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$argerr error_table_$bad_index error_table_$bad_subr_arg error_table_$bigarg error_table_$checksum_failure error_table_$id_already_exists error_table_$id_not_found error_table_$insufficient_access error_table_$invalid_lock_reset error_table_$lock_wait_time_exceeded error_table_$locked_by_other_process error_table_$no_record error_table_$null_info_ptr error_table_$request_id_ambiguous error_table_$smallarg error_table_$unexpected_condition error_table_$unimplemented_version mlsys_data_$system_directory mlsys_et_$ambiguous_address mlsys_et_$bad_mail_table sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 48 000226 221 000234 224 000265 225 000307 226 000331 227 000332 229 000345 230 000355 232 000356 233 000364 234 000375 236 000411 237 000446 238 000453 244 000454 247 000477 248 000521 249 000543 250 000544 254 000565 y ~ B &y L_ f vm state.absout y L_)GLg$ * :vm"vhw 2v*@y : *v*y 2*@y &L8 J Jva BOopen L=2G2 $ h xvavhw pv*@ x hv* p*@ B&9L笏 va trs.1993 9LOGs$ va=vhw v*@9 v*9 *@9 &:|L c va trs.detail :|L칸G$ vabvhw v*@:| v*:| *@:| : &ݳL"  va `ERF_4.LIS ݳLެGr$ " 2vagvhw *v*ݳ 2 "v*ݳ **@ݳ  &O̪L(I B `va ` :hMCRB O̪L3|tŸz n ~va~2rvhw B :mcrb O̪ vv*O̪ ~ nv*@O̪ v*O̪ &M\ va m.format M0G2-$ vaNvhw v*@ v* *@  & Pgk va glb_include PY_  \va~2rvhwv*@ \ v*@ 4*@ H :&ZL va *test_ceil.pl1 ZLGQ$ ( 8vavhw 0v*Z 8 (v*Z 0*@Z:&fPS6 H Hva @ mcrs fPT+GL $ . va vhw`(v*vv*T *@v*vhwv*@vhw &a1Mfe& va kermit.log a1Mfx+G$ va Qvhw *@a1 v*a1 v*@a1 &Ms va jact_incl M   va~2rvhw * v*@ v* H&`MLT  va vtest5678901234567890123456.test `ML G;$ @ 0vavhw 8*@` 0 @v*` 8v*` &`MLRh P Pva Htest56789012345678901234567.test`ML G$ ~ nvavhw v*@` n ~v*` vv*` &gM6 va Vu.act.12/02/93 gM~G$ vavhw *@g v*g v*g F&CM> va format CMWG2_$ va2vhw *@C v*C v* 647 004126 648 004154 649 004164 650 004165 651 004170 652 004171 653 004172 654 004176 655 004202 656 004206 657 004207 664 004210 667 004226 668 004232 669 004241 677 004242 680 004264 681 004272 682 004314 683 004336 684 004337 685 004345 686 004352 688 004360 689 004362 690 004365 691 004367 692 004371 693 004374 694 004377 695 004400 696 004453 697 004503 698 004505 699 004543 701 004552 706 004555 707 004557 709 004573 710 004611 711 004612 712 004647 713 004652 714 004711 716 004721 717 004723 718 004724 719 004725 720 004734 721 004741 722 004744 723 004751 724 005007 725 005012 726 005036 727 005041 728 005046 729 005050 730 005063 731 005066 732 005067 734 005074 736 005136 738 005146 739 005147 741 005154 742 005156 743 005157 744 005160 746 005161 747 005206 749 005216 750 005224 751 005235 753 005236 755 005273 756 005303 757 005313 758 005323 759 005333 762 005442 763 005473 764 005475 766 005567 768 005576 770 005625 771 005627 772 005665 774 005674 775 005700 776 005704 778 005732 779 005734 780 006004 782 006013 783 006017 789 006020 791 006024 796 006025 799 006033 800 006042 804 006043 807 006044 808 006053 809 006073 813 006074 816 006075 817 006076 818 006077 819 006100 820 006103 821 006126 823 006135 824 006137 825 006147 826 006150 828 006153 832 006154 835 006162 836 006167 837 006174 841 006175 844 006203 846 006212 849 006213 852 006214 853 006215 857 006216 862 006224 863 006230 864 006236 868 006241 873 006247 874 006253 875 006261 878 006267 879 006272 884 006275 889 006276 890 006277 891 006305 892 006340 894 006350 898 006351 903 006357 904 006360 905 006361 906 006365 907 006375 908 006406 909 006411 913 006412 918 006420 919 006423 920 006424 921 006436 923 006443 924 006445 926 006454 928 006463 929 006464 933 006465 938 006473 939 006476 940 006477 941 006507 942 006523 943 006525 947 006526 953 006527 954 006531 956 006532 957 006536 958 006540 959 006553 962 006560 963 006574 964 006611 966 006612 967 006622 968 006627 972 006630 975 006632 976 006644 978 006661 980 006667 982 006673 985 006675 989 006716 999 006732 1000 006733 1001 006741 1002 006743 1003 006766 1004 006777 1005 007002 1006 007005 1010 007006 1017 007014 1018 007020 1019 007032 1020 007043 1021 007046 1024 007047 1032 007055 1033 007056 1034 007064 1035 007104 1036 007115 1037 007121 1041 007122 1055 007133 1056 007134 1057 007137 1058 007144 1059 007177 1060 007204 1063 007216 1064 007217 1065 007251 1066 007256 1067 007267 1068 007277 1069 007300 1070 007306 1071 007320 1072 007324 1073 007357 1074 007364 1076 007374 1077 007377 1081 007400 1090 007402 1091 007403 1092 007405 1093 007407 1094 007445 1095 007455 1096 007460 1100 007461 1112 007463 1113 007464 1114 007466 1118 007565 1119 007620 1120 007631 1123 007632 1137 007643 1138 007644 1139 007647 1140 007650 1141 007716 1143 007730 1144 007740 1145 007752 1148 007753 1158 007755 1159 007756 1161 007772 1162 010044 1163 010063 1167 010064 1172 010066 1173 010101 1175 010117 1179 010120 1184 010122 1185 010135 1187 010153 1189 010170 1193 010171 1204 010177 1205 010201 1206 010202 1208 010216 1209 010231 1210 010232 1211 010257 1212 010270 1213 010273 1214 010275 1215 010276 1216 010277 1217 010324 1218 010340 1219 010351 1220 010360 ----------------------------------------------------------- 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