COMPILATION LISTING OF SEGMENT mlsys_address_mgr_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 06/30/86 1400.1 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 7 /* format: off */ 8 9 /* Address management for the Multics Mail System */ 10 11 /* Created: May 1981 by G. Palter */ 12 /* Recoded: July 1983 by G. Palter as part of the new mail system interface */ 13 /* Modified: March 1984 by G. Palter to fix the following mail system errors: 14* #0420 -- the mail system doesn't translate error_table_$no_component into mlsys_et_$no_address_list 15* #0428 -- during initialization, the mail system extracts the user's full name from the default default value segment 16* (>udd>Project>Person>Person.value) rather than the current default value segment as set by value_set_path 17* #0429 -- mail_system_$create_savebox_address should not create a logbox address when given the pathname of the 18* user's logbox. Similarly, mail_system_$create_mailbox_address should not create a savebox address when given 19* the pathname of a savebox 20* #0436 -- if a forum meeting is not found in the "forum" search list, the mail system will treat it as a version 1 21* meeting in the working directory */ 22 23 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen */ 24 25 26 mlsys_address_mgr_: 27 procedure () options (rename ((alloc_, mlsys_storage_mgr_$allocate))); 28 29 return; /* not an entrypoint */ 30 31 32 /* Parameters */ 33 34 dcl P_address_ptr pointer parameter; 35 dcl P_code fixed binary (35) parameter; 36 37 dcl P_default_mailbox_address pointer parameter; /* values returned by the get_address_constants entrypoint */ 38 dcl P_mail_table_address pointer parameter; /* ... */ 39 dcl P_logbox_address pointer parameter; /* ... */ 40 41 dcl P_address_name character (*) varying parameter; /* the address name of the address */ 42 dcl P_address_comment character (*) varying parameter; /* the address comment */ 43 44 dcl P_address_string character (*) varying parameter; /* the string portion of an address (User_id, etc.) */ 45 46 dcl P_address_dirname character (*) parameter; /* an address pathname's component parts ... */ 47 dcl P_address_ename character (*) parameter; /* ... */ 48 dcl P_address_component character (*) parameter; /* ... */ 49 50 dcl P_foreign_system character (256) varying parameter; /* the foreign system on which the address resides */ 51 dcl P_address_route_ptr pointer parameter; /* -> an explicit/implicit route associated with an address */ 52 53 dcl P_address_list_ptr pointer parameter; /* -> the address list which is the address expansion */ 54 dcl P_display_list bit (1) aligned parameter; /* ON => show the list in printed representation of address */ 55 56 dcl P_address_type fixed binary parameter; /* set to the type of the given address */ 57 58 dcl P_address_route_version character (8) parameter; /* version of address_route structure expected by caller */ 59 60 dcl P_address_1_ptr pointer parameter; /* -> an address to be compared */ 61 dcl P_address_2_ptr pointer parameter; /* ... */ 62 63 dcl P_mail_table_address_ptr pointer parameter; /* set -> address found in the mail table */ 64 65 dcl P_address_list_version character (8) parameter; /* version of address_list structure desired when expanding */ 66 67 68 /* Local copies of parameters */ 69 70 dcl code fixed binary (35); 71 72 dcl (address_1_ptr, address_2_ptr) pointer; 73 74 dcl mail_table_address_ptr pointer; 75 76 77 /* Remaining declarations */ 78 79 dcl mls_text character (mls_lth) unaligned based (mls_ptr); 80 dcl mls_ptr pointer; 81 dcl mls_bitcount fixed binary (24); 82 dcl mls_lth fixed binary (21); 83 84 dcl comparison_result bit (1) aligned; 85 dcl (address_1_dirname, address_2_dirname) character (168); 86 dcl (address_1_ename, address_2_ename) character (32); 87 dcl suffixless_forum_ename character (26); /* longest valid meeting name */ 88 dcl (address_1_mte_address_ptr, address_2_mte_address_ptr) pointer; 89 dcl (address_1_route_ptr, address_2_route_ptr) pointer; 90 dcl (address_1_mls_ptr, address_2_mls_ptr) pointer; 91 dcl (address_list_1_ptr, address_list_2_ptr) pointer; 92 dcl (mailbox_1_uid, mailbox_2_uid) bit (36) aligned; 93 dcl partial_comparison_result bit (1) aligned; 94 dcl (code_1, code_2) fixed binary (35); 95 dcl (forum_1_index, forum_2_index) fixed binary; 96 dcl (idx, jdx) fixed binary; 97 98 dcl current_mtle_ptr pointer; /* used to resolve recusive mail table entries */ 99 100 dcl ANONYMOUS character (9) static options (constant) initial ("anonymous"); 101 102 dcl NULL_STRING character (1) static options (constant) initial (""); 103 104 /* format: off */ 105 dcl (LOWERCASE initial ("abcdefghijklmnopqrstuvwxyz"), 106 UPPERCASE initial ("ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 107 character (26) static options (constant); 108 109 dcl (error_table_$entlong, error_table_$id_not_found, error_table_$no_component, error_table_$noentry, 110 error_table_$smallarg, error_table_$unimplemented_version, mlsys_et_$circular_mtes, mlsys_et_$incorrect_suffix, 111 mlsys_et_$mte_not_found, mlsys_et_$no_address_pathname, mlsys_et_$no_address_route, mlsys_et_$no_address_string, 112 mlsys_et_$no_mailing_list, mlsys_et_$not_address, mlsys_et_$not_foreign_address, mlsys_et_$not_list_address, 113 mlsys_et_$not_mail_table_address, mlsys_et_$not_named_group_address, mlsys_et_$null_foreign_address, 114 mlsys_et_$null_named_group_name, mlsys_et_$unknown_system) 115 fixed binary (35) external; 116 /* format: on */ 117 118 dcl forum_$close_forum entry (fixed binary, fixed binary (35)); 119 dcl forum_$open_forum entry (character (*), character (*), fixed binary, fixed binary (35)); 120 dcl initiate_file_$component 121 entry (character (*), character (*), character (*), bit (*), pointer, fixed binary (24), fixed binary (35)); 122 dcl mail_table_$get entry (character (*) varying, pointer, character (*), fixed binary (35)); 123 dcl mailbox_$get_uid_file entry (character (*), character (*), bit (36) aligned, fixed binary (35)); 124 dcl mlsys_address_list_mgr_$create_user_freeable_address_list entry (character (8), pointer, fixed binary (35)); 125 dcl mlsys_address_list_mgr_$decrement_reference_count entry (pointer); 126 dcl mlsys_address_list_mgr_$free_address_list entry (pointer, fixed binary (35)); 127 dcl mlsys_address_list_mgr_$increment_reference_count entry (pointer); 128 dcl mlsys_address_list_mgr_$verify_address_list entry (pointer, fixed binary (35)) returns (bit (1) aligned); 129 dcl mlsys_address_route_mgr_$compute_optimum_route entry (pointer, pointer, fixed binary (35)); 130 dcl mlsys_address_route_mgr_$create_address_route entry ((*) character (256) varying, pointer); 131 dcl mlsys_address_route_mgr_$decrement_reference_count entry (pointer); 132 dcl mlsys_address_route_mgr_$free_address_route entry (pointer); 133 dcl mlsys_address_route_mgr_$increment_reference_count entry (pointer); 134 dcl mlsys_nit_interface_$get_fully_qualified_name entry (character (256) varying) returns (character (256) varying); 135 dcl mlsys_parse_text_$parse_address_text entry (character (*), pointer, fixed binary (35)); 136 dcl mlsys_parse_text_$parse_mailing_list_text entry (character (*), character (8), pointer, fixed binary (35)); 137 dcl mlsys_psp_$forum_not_available entry () returns (bit (1) aligned); 138 dcl mlsys_user_mte_syntax_$validate_mte_name entry (character (*) varying, fixed binary (35)); 139 dcl mlsys_user_mte_syntax_$validate_person_id entry (character (*) varying, fixed binary (35)); 140 dcl mlsys_user_mte_syntax_$validate_user_id 141 entry (character (*) varying, character (*) varying, character (*) varying, fixed binary (35)); 142 dcl terminate_file_ entry (pointer, fixed binary (24), bit (*), fixed binary (35)); 143 144 dcl cleanup condition; 145 146 dcl (addr, baseno, binary, divide, index, length, maxlength, null, reverse, rtrim, size, string, translate) builtin; 147 148 /* Definitions of the various types of addresses used by the Multics mail system */ 149 150 dcl address_ptr pointer; /* all following structures are based on this pointer */ 151 1 1 /* BEGIN INCLUDE FILE ... mlsys_address_types.incl.pl1 */ 1 2 /* Created: June 1983 by G. Palter */ 1 3 1 4 /* Types of addresses supported by the Multics Mail System */ 1 5 1 6 dcl (INVALID_ADDRESS initial (0), /* a syntactically invalid address: used as a place holder 1 7* when parsing printed representations */ 1 8 USER_MAILBOX_ADDRESS initial (1), /* identifies a user's default mailbox */ 1 9 LOGBOX_ADDRESS initial (2), /* identifies a user's logbox */ 1 10 SAVEBOX_ADDRESS initial (3), /* identifies one of a user's saveboxes by pathname */ 1 11 MAILBOX_ADDRESS initial (4), /* identifies some other mailbox by pathname */ 1 12 FORUM_ADDRESS initial (5), /* identifies a forum meeting by pathname */ 1 13 FOREIGN_ADDRESS initial (6), /* identifies a user (or group) on another compute system */ 1 14 MAIL_TABLE_ADDRESS initial (7), /* identifies an entry in the system's mail table */ 1 15 MAILING_LIST_ADDRESS initial (8), /* identifies a mailing list by pathname */ 1 16 NAMED_GROUP_ADDRESS initial (9)) /* identifies a named group of addresses */ 1 17 fixed binary static options (constant); 1 18 1 19 /* END INCLUDE FILE ... mlsys_address_types.incl.pl1 */ 152 153 154 dcl WAS_FOREIGN_ADDRESS initial (-1) /* identifies an address which was a foreign address but was 155* converted into a local address during validation */ 156 fixed binary static options (constant); 157 158 159 /* Standard header present in all addresses */ 160 161 dcl 1 address_header aligned based (address_ptr), 162 2 version character (8) unaligned, 163 2 type fixed binary, /* type of address (see above) */ 164 2 reference_count fixed binary, /* # of address lists and messages referencing this address */ 165 2 name, /* the address name */ 166 3 name_ptr pointer, 167 3 name_lth fixed binary (21), 168 2 comment, /* the address comment */ 169 3 comment_ptr pointer, 170 3 comment_lth fixed binary (21), 171 2 flags, 172 3 never_free bit (1) unaligned, /* ON => don't free this address even if ref count is zero */ 173 3 free_name bit (1) unaligned, /* ON => free the address name when freeing the address */ 174 3 free_comment bit (1) unaligned, /* ON => free the address comment when freeing the address */ 175 3 pad bit (33) unaligned; 176 177 dcl ADDRESS_VERSION_2 character (8) static options (constant) initial ("mlsaddr2"); 178 179 dcl address_name character (address_header.name_lth) unaligned based (address_header.name_ptr); 180 181 dcl address_comment character (address_header.comment_lth) unaligned based (address_header.comment_ptr); 182 183 /* Address comparison dispatch table: referenced by both address types */ 184 185 /* format: off */ 186 dcl COMPARISON_OPERATIONS (0:9, 0:9) fixed binary static options (constant) initial ( 187 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* invalid address */ 188 -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* user mailbox address */ 189 -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* logbox address */ 190 -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* savebox address */ 191 -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* mailbox address */ 192 -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, /* forum address */ 193 -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, /* foreign address */ 194 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* mail table address (never used) */ 195 -1, -1, -1, -1, -1, -1, -1, -1, 4, 5, /* mailing list address */ 196 -1, -1, -1, -1, -1, -1, -1, -1, 5, 5); /* named group address */ 197 /* format: on */ 198 199 /* format: ^indcomtxt */ 200 201 /* WAS_FOREGIN_ADDRESS: When a foreign address is created, the mail system does not actually validate that the address 202* is, indeed, an off-site address. Therefore, it is possible to create a "foreign" address for what is, in fact, a local 203* address. When the address is finally validated, the mail system will create the proper address and convert the foreign 204* address into a was-foreign address. The was-foreign address serves as a place holder in the various messages, address 205* lists, etc. that already had a pointer to the foreign address */ 206 207 dcl 1 was_foreign_address aligned based (address_ptr), 208 2 header like address_header, 209 2 actual_address_ptr pointer, /* -> the actual local address into which it was converted */ 210 2 unused (size (foreign_address) - size (address_header) - size (address_ptr)) bit (36); 211 212 213 /* INVALID_ADDRESS: is used by the mail system to represent a text string which could not be converted into one of the 214* other, standard addresses. It is used when parsing old-style ring-1 messages and, optionally, when requested by 215* user-ring applications which allow users to create message headers (eg: "qedx -header" in send_mail) */ 216 217 dcl 1 invalid_address aligned based (address_ptr), 218 2 header like address_header, 219 2 text, /* the text which could not be parsed */ 220 3 text_ptr pointer, 221 3 text_lth fixed binary (21), 222 2 flags, 223 3 free_text bit (1) unaligned, /* ON => free the invalid text when freeing this address */ 224 3 pad bit (35) unaligned; 225 226 dcl invalid_address_text character (invalid_address.text_lth) unaligned based (invalid_address.text_ptr); 227 228 229 /* Common portion of all addresses which reference one of a specific user's mailboxes (default mailbox/logbox/savebox) */ 230 231 dcl 1 user_address_template aligned based (address_ptr), 232 2 header like address_header, 233 2 person_id character (32) varying, /* the user's Person_id ... */ 234 2 project_id character (32) varying, /* ... and Project_id */ 235 2 flags, 236 3 is_anonymous bit (1) unaligned, /* ON => this is the address of an anonymous user's mailbox */ 237 3 pad bit (35) unaligned; 238 239 240 /* USER_MAILBOX_ADDRESS: identifies a user's default mailbox. The pathname of a user's default mailbox is: 241* >udd>Project_id>Person_id>Person_id.mbx */ 242 243 dcl 1 user_mailbox_address aligned based (address_ptr), 244 2 user like user_address_template; 245 246 247 /* LOGBOX_ADDRESS: identifies a user's logbox. The pathname of a user's logbox is: 248* >udd>Project_id>Person_id>Person_id.sv.mbx */ 249 250 dcl 1 logbox_address aligned based (address_ptr), 251 2 user like user_address_template; 252 253 254 /* SAVEBOX_ADDRESS: identifies one of a user's saveboxes by pathname */ 255 256 dcl 1 savebox_address aligned based (address_ptr), 257 2 user like user_address_template, 258 2 mbx_dirname character (168) unaligned, /* pathname of directory containing the savebox */ 259 2 mbx_ename character (32) unaligned; /* entryname of the savebox including "sv.mbx" suffix */ 260 261 262 /* MAILBOX_ADDRESS: identifies an arbitrary mailbox by pathname */ 263 264 dcl 1 mailbox_address aligned based (address_ptr), 265 2 header like address_header, 266 2 mbx_dirname character (168) unaligned, /* pathname of directory containing the mailbox */ 267 2 mbx_ename character (32) unaligned; /* entryname of the mailbox including "mbx" suffix */ 268 269 270 /* FORUM_ADDRESS: identifies an arbitrary forum meeting by pathname */ 271 272 dcl 1 forum_address aligned based (address_ptr), 273 2 header like address_header, 274 2 forum_dirname character (168) unaligned, /* pathname of directory containing the meeting */ 275 2 forum_ename character (32) unaligned; /* entryname of meeting including "control"/"forum" suffix */ 276 277 278 /* FOREIGN_ADDRESS: identifies a user (or group of user) on another computer system */ 279 280 dcl 1 foreign_address aligned based (address_ptr), 281 2 header like address_header, 282 2 local_part, /* the name of the user/entity on the foreign system */ 283 3 local_part_ptr pointer, 284 3 local_part_lth fixed binary (21), 285 2 foreign_system character (256) varying, /* the name of the foreign system */ 286 2 explicit_route pointer, /* -> optional explicit route given by a user */ 287 2 implicit_route pointer, /* -> an implicit route also associated with this address */ 288 2 flags, 289 3 free_local_part bit (1) unaligned, /* ON => free the local part text when freeing the address */ 290 3 pad bit (35) unaligned; 291 292 dcl foreign_address_local_part character (foreign_address.local_part_lth) unaligned 293 based (foreign_address.local_part_ptr); 294 295 296 /* MAIL_TABLE_ADDRESS: identifies an entry in the system-wide mail table which provides a translation between an arbitrary 297* character string (usually a user's Person_id) and a mail system address */ 298 299 dcl 1 mail_table_address aligned based (address_ptr), 300 2 header like address_header, 301 2 mte_name character (32) varying; /* the name of the entry in the mail table */ 302 303 304 /* MAILING_LIST_ADDRESS: identifies an arbitrary mailing list by pathname. A mailing list may be an archive component in 305* addition to a segment and is an ASCII file containing the printed representations of one or more addresses to which 306* mail is to be sent whenever mail is sent to the mailing list */ 307 308 dcl 1 mailing_list_address aligned based (address_ptr), 309 2 header like address_header, 310 2 mls_dirname character (168) unaligned, /* pathname of the directory containing the mailing list */ 311 2 mls_ename character (32) unaligned, /* entryname of the mailing list or containing archive */ 312 2 mls_component character (32) unaligned; /* component name of the list including "mls" suffix */ 313 314 315 /* NAMED_GROUP_ADDRESS: identifies a named group of addresses. A named group is different from a mailing list in that it 316* is intended to be a temporary grouping and, as such, does not have a permanent form (eg: segment/archive component) */ 317 318 dcl 1 named_group_address aligned based (address_ptr), 319 2 header like address_header, 320 2 address_list pointer, /* -> to the address list itself */ 321 2 flags, 322 3 display_list bit (1) unaligned, /* ON => include actual list in the printed representation */ 323 3 pad bit (35) unaligned; 324 325 /* format: indcomtxt */ 326 327 /* Protect the supplied address from being accidentaly freed (used for the mlsys_data_$*_address variables) */ 328 329 protect_address: 330 entry (P_address_ptr); 331 332 P_address_ptr -> address_header.never_free = "1"b; 333 334 return; 335 336 337 338 /* Return the three address constants created in the mail system's ring to the caller: These "constants" represent the 339* user's default mailbox, mail table, and logbox addresses */ 340 341 get_users_addresses: 342 entry (P_default_mailbox_address, P_mail_table_address, P_logbox_address); 343 344 P_default_mailbox_address = mlsys_data_$user_default_mailbox_address; 345 346 P_mail_table_address = mlsys_data_$user_mail_table_address; 347 348 P_logbox_address = mlsys_data_$user_logbox_address; 349 350 return; 351 352 353 354 /* Set the full name for the user's default mailbox and mail table addresses */ 355 356 set_users_full_name: 357 entry (P_address_name); 358 359 if mlsys_data_$user_default_mailbox_address -> user_mailbox_address.name_lth = 0 then 360 call set_address_variable_string (P_address_name, 361 mlsys_data_$user_default_mailbox_address -> user_mailbox_address.name, 362 mlsys_data_$user_default_mailbox_address -> user_mailbox_address.free_name); 363 364 if mlsys_data_$user_mail_table_address -> mail_table_address.name_lth = 0 then 365 call set_address_variable_string (P_address_name, 366 mlsys_data_$user_mail_table_address -> mail_table_address.name, 367 mlsys_data_$user_mail_table_address -> mail_table_address.free_name); 368 369 return; 370 371 /* Create an invalid address */ 372 373 create_invalid_address: 374 entry (P_address_string, P_address_name, P_address_comment, P_address_ptr, P_code); 375 376 address_ptr = null (); /* for cleanup handler */ 377 378 on condition (cleanup) 379 begin; 380 if address_ptr ^= null () then call free_address (address_ptr, (0)); 381 end; 382 383 call initialize_address (INVALID_ADDRESS); 384 385 call set_address_variable_string (P_address_string, invalid_address.text, invalid_address.free_text); 386 387 call set_address_variable_string (P_address_name, invalid_address.name, invalid_address.free_name); 388 call set_address_variable_string (P_address_comment, invalid_address.comment, invalid_address.free_comment); 389 390 P_address_ptr = address_ptr; 391 P_code = 0; /* success */ 392 393 return; 394 395 /* Create a user default mailbox address */ 396 397 create_user_mailbox_address: 398 entry (P_address_string, P_address_name, P_address_comment, P_address_ptr, P_code); 399 400 address_ptr = null (); /* for cleanup handler */ 401 402 on condition (cleanup) 403 begin; 404 if address_ptr ^= null () then call free_address (address_ptr, (0)); 405 end; 406 407 call initialize_address (USER_MAILBOX_ADDRESS); 408 409 call mlsys_user_mte_syntax_$validate_user_id (P_address_string, user_mailbox_address.person_id, 410 user_mailbox_address.project_id, code); 411 if code ^= 0 then do; /* invalid syntax */ 412 BAD_USER_MAILBOX_ADDRESS: 413 call free_address (address_ptr, (0)); 414 P_code = code; 415 return; 416 end; 417 418 if user_mailbox_address.person_id = ANONYMOUS then do; 419 user_mailbox_address.is_anonymous = "1"b; 420 if P_address_name ^= "" then do; /* this must be the anonymous user's Person_id */ 421 call mlsys_user_mte_syntax_$validate_person_id (P_address_name, code); 422 if code ^= 0 then go to BAD_USER_MAILBOX_ADDRESS; 423 user_mailbox_address.person_id = P_address_name; 424 end; 425 end; 426 427 else if (user_mailbox_address.person_id = mlsys_data_$person_id) 428 & (user_mailbox_address.project_id = mlsys_data_$project_id) & mlsys_data_$user_is_anonymous then 429 user_mailbox_address.is_anonymous = "1"b; 430 431 else call set_address_variable_string (P_address_name, user_mailbox_address.name, 432 user_mailbox_address.free_name); 433 434 call set_address_variable_string (P_address_comment, user_mailbox_address.comment, 435 user_mailbox_address.free_comment); 436 437 P_address_ptr = address_ptr; 438 P_code = 0; /* success */ 439 440 return; 441 442 /* Create a logbox address */ 443 444 create_logbox_address: 445 entry (P_address_string, P_address_name, P_address_comment, P_address_ptr, P_code); 446 447 address_ptr = null (); /* for cleanup handler */ 448 449 on condition (cleanup) 450 begin; 451 if address_ptr ^= null () then call free_address (address_ptr, (0)); 452 end; 453 454 call initialize_address (LOGBOX_ADDRESS); 455 456 call mlsys_user_mte_syntax_$validate_user_id (P_address_string, logbox_address.person_id, 457 logbox_address.project_id, code); 458 if code ^= 0 then do; /* invalid syntax */ 459 BAD_LOGBOX_ADDRESS: 460 call free_address (address_ptr, (0)); 461 P_code = code; 462 return; 463 end; 464 465 if logbox_address.person_id = ANONYMOUS then do; 466 logbox_address.is_anonymous = "1"b; 467 if P_address_name ^= "" then do; /* this must be the anonymous user's Person_id */ 468 call mlsys_user_mte_syntax_$validate_person_id (P_address_name, code); 469 if code ^= 0 then go to BAD_LOGBOX_ADDRESS; 470 logbox_address.person_id = P_address_name; 471 end; 472 end; 473 474 else if (logbox_address.person_id = mlsys_data_$person_id) 475 & (logbox_address.project_id = mlsys_data_$project_id) & mlsys_data_$user_is_anonymous then 476 logbox_address.is_anonymous = "1"b; 477 478 else call set_address_variable_string (P_address_name, logbox_address.name, logbox_address.free_name); 479 480 call set_address_variable_string (P_address_comment, logbox_address.comment, logbox_address.free_comment); 481 482 P_address_ptr = address_ptr; 483 P_code = 0; /* success */ 484 485 return; 486 487 /* Create a savebox address */ 488 489 create_savebox_address: 490 entry (P_address_string, P_address_dirname, P_address_ename, P_address_name, P_address_comment, P_address_ptr, 491 P_code); 492 493 address_ptr = null (); /* for cleanup handler */ 494 495 on condition (cleanup) 496 begin; 497 if address_ptr ^= null () then call free_address (address_ptr, (0)); 498 end; 499 500 call initialize_address (SAVEBOX_ADDRESS); 501 502 call mlsys_user_mte_syntax_$validate_user_id (P_address_string, savebox_address.person_id, 503 savebox_address.project_id, code); 504 if code ^= 0 then do; /* invalid syntax */ 505 BAD_SAVEBOX_ADDRESS: 506 call free_address (address_ptr, (0)); 507 P_code = code; 508 return; 509 end; 510 511 savebox_address.mbx_dirname = P_address_dirname; 512 513 if validate_entryname (P_address_ename, ".sv.mbx", savebox_address.mbx_ename, code) then 514 savebox_address.mbx_ename = P_address_ename; 515 else go to BAD_SAVEBOX_ADDRESS; 516 517 if savebox_address.person_id = ANONYMOUS then do; 518 savebox_address.is_anonymous = "1"b; 519 if P_address_name ^= "" then do; /* this must be the anonymous user's Person_id */ 520 call mlsys_user_mte_syntax_$validate_person_id (P_address_name, code); 521 if code ^= 0 then go to BAD_SAVEBOX_ADDRESS; 522 savebox_address.person_id = P_address_name; 523 end; 524 end; 525 526 else if (savebox_address.person_id = mlsys_data_$person_id) 527 & (savebox_address.project_id = mlsys_data_$project_id) & mlsys_data_$user_is_anonymous then 528 savebox_address.is_anonymous = "1"b; 529 530 else call set_address_variable_string (P_address_name, savebox_address.name, savebox_address.free_name); 531 532 call set_address_variable_string (P_address_comment, savebox_address.comment, savebox_address.free_comment); 533 534 P_address_ptr = address_ptr; 535 P_code = 0; /* success */ 536 537 return; 538 539 /* Create a mailbox address */ 540 541 create_mailbox_address: 542 entry (P_address_dirname, P_address_ename, P_address_name, P_address_comment, P_address_ptr, P_code); 543 544 address_ptr = null (); /* for cleanup handler */ 545 546 on condition (cleanup) 547 begin; 548 if address_ptr ^= null () then call free_address (address_ptr, (0)); 549 end; 550 551 call initialize_address (MAILBOX_ADDRESS); 552 553 mailbox_address.mbx_dirname = P_address_dirname; 554 555 if validate_entryname (P_address_ename, ".mbx", mailbox_address.mbx_ename, code) then 556 mailbox_address.mbx_ename = P_address_ename; 557 else do; /* something's wrong with the entry name */ 558 call free_address (address_ptr, (0)); 559 P_code = code; 560 return; 561 end; 562 563 call set_address_variable_string (P_address_name, mailbox_address.name, mailbox_address.free_name); 564 call set_address_variable_string (P_address_comment, mailbox_address.comment, mailbox_address.free_comment); 565 566 P_address_ptr = address_ptr; 567 P_code = 0; /* success */ 568 569 return; 570 571 /* Create a forum address */ 572 573 create_forum_address: 574 entry (P_address_dirname, P_address_ename, P_address_name, P_address_comment, P_address_ptr, P_code); 575 576 address_ptr = null (); /* for cleanup handler */ 577 578 on condition (cleanup) 579 begin; 580 if address_ptr ^= null () then call free_address (address_ptr, (0)); 581 end; 582 583 call initialize_address (FORUM_ADDRESS); 584 585 forum_address.forum_dirname = P_address_dirname; 586 587 if validate_entryname (P_address_ename, ".control", forum_address.forum_ename, code) 588 | validate_entryname (P_address_ename, ".forum", forum_address.forum_ename, code) then 589 forum_address.forum_ename = P_address_ename; 590 591 else if mlsys_psp_$forum_not_available () | (forum_address.forum_dirname = "") then 592 /*** no Forum PSP or making an address for a meeting not found in the search list ... */ 593 if validate_entryname (P_address_ename, "", suffixless_forum_ename, code) then 594 forum_address.forum_ename = P_address_ename; 595 else go to BAD_FORUM_ADDRESS; 596 597 else do; /* something's wrong with the entry name */ 598 if validate_entryname (P_address_ename, "", suffixless_forum_ename, code) then 599 code = mlsys_et_$incorrect_suffix; 600 BAD_FORUM_ADDRESS: 601 call free_address (address_ptr, (0)); 602 P_code = code; 603 return; 604 end; 605 606 call set_address_variable_string (P_address_name, forum_address.name, forum_address.free_name); 607 call set_address_variable_string (P_address_comment, forum_address.comment, forum_address.free_comment); 608 609 P_address_ptr = address_ptr; 610 P_code = 0; /* success */ 611 612 return; 613 614 /* Create a foreign address */ 615 616 create_foreign_address: 617 entry (P_address_string, P_foreign_system, P_address_route_ptr, P_address_name, P_address_comment, P_address_ptr, 618 P_code); 619 620 if P_address_string = "" then do; /* can't allow a null local part */ 621 P_code = mlsys_et_$null_foreign_address; 622 return; 623 end; 624 625 if P_foreign_system = "" then do; /* can't allow a null system name */ 626 P_code = mlsys_et_$unknown_system; 627 return; 628 end; 629 630 if P_address_route_ptr ^= null () then /* check for proper version ... */ 631 if P_address_route_ptr -> address_route.version ^= ADDRESS_ROUTE_VERSION_1 then do; 632 P_code = error_table_$unimplemented_version; 633 return; 634 end; 635 636 address_ptr = null (); /* for cleanup handler */ 637 638 on condition (cleanup) 639 begin; 640 if address_ptr ^= null () then call free_address (address_ptr, (0)); 641 end; 642 643 call initialize_address (FOREIGN_ADDRESS); 644 645 call set_address_variable_string (P_address_string, foreign_address.local_part, foreign_address.free_local_part) 646 ; 647 648 if P_address_route_ptr = null () then /* we should know the foreign system name */ 649 foreign_address.foreign_system = mlsys_nit_interface_$get_fully_qualified_name (P_foreign_system); 650 else foreign_address.foreign_system = translate (P_foreign_system, UPPERCASE, LOWERCASE); 651 652 if P_address_route_ptr ^= null () then do; /* user has supplied an explicit route ... */ 653 address_route_ptr = copy_ptr (P_address_route_ptr); 654 /* ... for following call to work ... */ 655 call mlsys_address_route_mgr_$create_address_route (address_route.relays, foreign_address.explicit_route); 656 call mlsys_address_route_mgr_$increment_reference_count (foreign_address.explicit_route); 657 end; 658 659 call set_address_variable_string (P_address_name, foreign_address.name, foreign_address.free_name); 660 call set_address_variable_string (P_address_comment, foreign_address.comment, foreign_address.free_comment); 661 662 P_address_ptr = address_ptr; 663 P_code = 0; /* success */ 664 665 return; 666 667 /* Create a mail table address */ 668 669 create_mail_table_address: 670 entry (P_address_string, P_address_name, P_address_comment, P_address_ptr, P_code); 671 672 address_ptr = null (); /* for cleanup handler */ 673 674 on condition (cleanup) 675 begin; 676 if address_ptr ^= null () then call free_address (address_ptr, (0)); 677 end; 678 679 call initialize_address (MAIL_TABLE_ADDRESS); 680 681 call mlsys_user_mte_syntax_$validate_mte_name (P_address_string, code); 682 if code ^= 0 then do; 683 call free_address (address_ptr, (0)); 684 P_code = code; 685 return; 686 end; 687 688 mail_table_address.mte_name = P_address_string; 689 call set_address_variable_string (P_address_name, mail_table_address.name, mail_table_address.free_name); 690 call set_address_variable_string (P_address_comment, mail_table_address.comment, 691 mail_table_address.free_comment); 692 693 P_address_ptr = address_ptr; 694 P_code = 0; /* success */ 695 696 return; 697 698 /* Create a mailing list address */ 699 700 create_mailing_list_address: 701 entry (P_address_dirname, P_address_ename, P_address_component, P_address_name, P_address_comment, P_address_ptr, 702 P_code); 703 704 address_ptr = null (); /* for cleanup handler */ 705 706 on condition (cleanup) 707 begin; 708 if address_ptr ^= null () then call free_address (address_ptr, (0)); 709 end; 710 711 call initialize_address (MAILING_LIST_ADDRESS); /* sets mls_component to a null string */ 712 713 mailing_list_address.mls_dirname = P_address_dirname; 714 715 if P_address_component = "" then /* mailing list is in a segment */ 716 if validate_entryname (P_address_ename, ".mls", mailing_list_address.mls_ename, code) then 717 mailing_list_address.mls_ename = P_address_ename; 718 else do; /* something's wrong with the entry/component name */ 719 BAD_MAILING_LIST_ADDRESS: 720 call free_address (address_ptr, (0)); 721 P_code = code; 722 return; 723 end; 724 725 else do; /* mailing list is in an archive component */ 726 if validate_entryname (P_address_ename, ".archive", mailing_list_address.mls_ename, code) then do; 727 mailing_list_address.mls_ename = P_address_ename; 728 if validate_entryname (P_address_component, ".mls", mailing_list_address.mls_component, code) then 729 mailing_list_address.mls_component = P_address_component; 730 end; 731 if code ^= 0 then go to BAD_MAILING_LIST_ADDRESS; 732 end; 733 734 call set_address_variable_string (P_address_name, mailing_list_address.name, mailing_list_address.free_name); 735 call set_address_variable_string (P_address_comment, mailing_list_address.comment, 736 mailing_list_address.free_comment); 737 738 P_address_ptr = address_ptr; 739 P_code = 0; /* success */ 740 741 return; 742 743 /* Create a named group address */ 744 745 create_named_group_address: 746 entry (P_address_name, P_address_list_ptr, P_display_list, P_address_comment, P_address_ptr, P_code); 747 748 if ^mlsys_address_list_mgr_$verify_address_list (P_address_list_ptr, P_code) then return; 749 750 if P_address_name = "" then do; /* can't be a blank name */ 751 P_code = mlsys_et_$null_named_group_name; 752 return; 753 end; 754 755 address_ptr = null (); /* for cleanup handler */ 756 757 on condition (cleanup) 758 begin; 759 if address_ptr ^= null () then call free_address (address_ptr, (0)); 760 end; 761 762 call initialize_address (NAMED_GROUP_ADDRESS); 763 764 named_group_address.address_list = copy_ptr (P_address_list_ptr); 765 call mlsys_address_list_mgr_$increment_reference_count (named_group_address.address_list); 766 767 named_group_address.display_list = P_display_list; 768 769 call set_address_variable_string (P_address_name, named_group_address.name, named_group_address.free_name); 770 call set_address_variable_string (P_address_comment, named_group_address.comment, 771 named_group_address.free_comment); 772 773 P_address_ptr = address_ptr; 774 P_code = 0; /* success */ 775 776 return; 777 778 /* Free an address if its reference count is zero (ie: if no other mail system object has a pointer to this address) */ 779 780 free_address: 781 entry (P_address_ptr, P_code); 782 783 if ^verify_address (P_address_ptr, P_code) then return; 784 785 address_ptr = copy_ptr (P_address_ptr); 786 P_address_ptr = null (); /* insure that the caller doesn't use it anymore */ 787 788 P_code = 0; /* indicates that this call has succeeded */ 789 790 if address_header.never_free | (address_header.reference_count > 0) then return; 791 /* someone's still using it */ 792 793 if address_header.free_name then /* the address name was allocated simultaneously */ 794 free address_name in (mlsys_area); 795 if address_header.free_comment then free address_comment in (mlsys_area); 796 797 go to FREE_ADDRESS (address_header.type); 798 799 FREE_ADDRESS (-1): /* was-foreign address */ 800 call decrement_reference_count (was_foreign_address.actual_address_ptr); 801 free was_foreign_address in (mlsys_area); /* above call probably will free the real address */ 802 return; 803 804 FREE_ADDRESS (0): /* invalid address */ 805 if invalid_address.free_text then /* we allocated this text when we created the address */ 806 free invalid_address_text in (mlsys_area); 807 free invalid_address in (mlsys_area); 808 return; 809 810 FREE_ADDRESS (1): /* user mailbox address */ 811 free user_mailbox_address in (mlsys_area); 812 return; 813 814 FREE_ADDRESS (2): /* logbox address */ 815 free logbox_address in (mlsys_area); 816 return; 817 818 FREE_ADDRESS (3): /* savebox address */ 819 free savebox_address in (mlsys_area); 820 return; 821 822 FREE_ADDRESS (4): /* mailbox address */ 823 free mailbox_address in (mlsys_area); 824 return; 825 826 FREE_ADDRESS (5): /* forum address */ 827 free forum_address in (mlsys_area); 828 return; 829 830 FREE_ADDRESS (6): /* foreign address */ 831 if foreign_address.free_local_part then /* the local part was allocated simultaneously */ 832 free foreign_address_local_part in (mlsys_area); 833 if foreign_address.explicit_route ^= null () then 834 call mlsys_address_route_mgr_$decrement_reference_count (foreign_address.explicit_route); 835 if foreign_address.implicit_route ^= null () then 836 call mlsys_address_route_mgr_$decrement_reference_count (foreign_address.implicit_route); 837 free foreign_address in (mlsys_area); 838 return; 839 840 FREE_ADDRESS (7): /* mail table address */ 841 free mail_table_address in (mlsys_area); 842 return; 843 844 FREE_ADDRESS (8): /* mailing list address */ 845 free mailing_list_address in (mlsys_area); 846 return; 847 848 FREE_ADDRESS (9): /* named group address */ 849 call mlsys_address_list_mgr_$decrement_reference_count (named_group_address.address_list); 850 free named_group_address in (mlsys_area); 851 return; 852 853 /* Increment the reference count of an address: to avoid the user accidently freeing an address which is in use by other 854* parts of the mail system (eg: references within a message, an address list, or another address) */ 855 856 increment_reference_count: 857 entry (P_address_ptr); 858 859 P_address_ptr -> address_header.reference_count = P_address_ptr -> address_header.reference_count + 1; 860 861 return; 862 863 864 865 /* Decrement the reference count of an address: If the reference count reaches zero, nothing in the mail system is using 866* this address any longer and its storage is released */ 867 868 decrement_reference_count: 869 entry (P_address_ptr); 870 871 P_address_ptr -> address_header.reference_count = P_address_ptr -> address_header.reference_count - 1; 872 873 if (P_address_ptr -> address_header.reference_count <= 0) & ^P_address_ptr -> address_header.never_free then 874 call free_address (P_address_ptr, (0)); 875 876 P_address_ptr = null (); /* keep the caller from using it anymore */ 877 878 return; 879 880 881 882 /* Decrement the reference count of an address but do not free it when the reference count reaches zero */ 883 884 decrement_reference_count_no_free: 885 entry (P_address_ptr); 886 887 P_address_ptr -> address_header.reference_count = P_address_ptr -> address_header.reference_count - 1; 888 889 P_address_ptr = null (); /* keep the caller from using it anymore */ 890 891 return; 892 893 /* Return the type of the given address */ 894 895 get_address_type: 896 entry (P_address_ptr, P_address_type, P_code); 897 898 if ^verify_address (P_address_ptr, P_code) then return; 899 900 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 901 902 P_address_type = address_header.type; 903 P_code = 0; /* success */ 904 905 return; 906 907 908 909 /* Return the character string associated with the given address, if any: The address string has various interpretations 910* dependent on the address type (eg: User_id, foreign user/entity name, etc.) */ 911 912 get_address_string: 913 entry (P_address_ptr, P_address_string, P_code); 914 915 if ^verify_address (P_address_ptr, P_code) then return; 916 917 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 918 919 go to GET_ADDRESS_STRING (address_header.type); 920 921 GET_ADDRESS_STRING (0): /* invalid address */ 922 call set_output_variable (invalid_address_text, P_address_string, P_code); 923 return; 924 925 GET_ADDRESS_STRING (1): /* user mailbox address */ 926 GET_ADDRESS_STRING (2): /* logbox address */ 927 GET_ADDRESS_STRING (3): /* savebox address */ 928 if user_address_template.is_anonymous then 929 call set_output_variable ((ANONYMOUS || "." || user_address_template.project_id), P_address_string, P_code) 930 ; 931 else call set_output_variable ((user_address_template.person_id || "." || user_address_template.project_id), 932 P_address_string, P_code); 933 return; 934 935 GET_ADDRESS_STRING (4): /* mailbox address */ 936 GET_ADDRESS_STRING (5): /* forum address */ 937 P_code = mlsys_et_$no_address_string; 938 return; 939 940 GET_ADDRESS_STRING (6): /* foreign address */ 941 call set_output_variable (foreign_address_local_part, P_address_string, P_code); 942 return; 943 944 GET_ADDRESS_STRING (7): /* mail table address */ 945 call set_output_variable ((mail_table_address.mte_name), P_address_string, P_code); 946 return; 947 948 GET_ADDRESS_STRING (8): /* mailing list address */ 949 GET_ADDRESS_STRING (9): /* named group address */ 950 P_code = mlsys_et_$no_address_string; 951 return; 952 953 /* Return the pathname associated with the given address, if any */ 954 955 get_address_pathname: 956 entry (P_address_ptr, P_address_dirname, P_address_ename, P_address_component, P_code); 957 958 if ^verify_address (P_address_ptr, P_code) then return; 959 960 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 961 962 go to GET_ADDRESS_PATHNAME (address_header.type); 963 964 GET_ADDRESS_PATHNAME (0): /* invalid address */ 965 P_code = mlsys_et_$no_address_pathname; 966 return; 967 968 GET_ADDRESS_PATHNAME (1): /* user mailbox address */ 969 P_address_dirname = ">udd>" || user_mailbox_address.project_id || ">" || user_mailbox_address.person_id; 970 P_address_ename = user_mailbox_address.person_id || ".mbx"; 971 P_address_component = ""; 972 P_code = 0; 973 return; 974 975 GET_ADDRESS_PATHNAME (2): /* logbox address */ 976 P_address_dirname = ">udd>" || logbox_address.project_id || ">" || logbox_address.person_id; 977 P_address_ename = logbox_address.person_id || ".sv.mbx"; 978 P_address_component = ""; 979 P_code = 0; 980 return; 981 982 GET_ADDRESS_PATHNAME (3): /* savebox address */ 983 P_address_dirname = savebox_address.mbx_dirname; 984 P_address_ename = savebox_address.mbx_ename; 985 P_address_component = ""; 986 P_code = 0; 987 return; 988 989 GET_ADDRESS_PATHNAME (4): /* mailbox address */ 990 P_address_dirname = mailbox_address.mbx_dirname; 991 P_address_ename = mailbox_address.mbx_ename; 992 P_address_component = ""; 993 P_code = 0; 994 return; 995 996 GET_ADDRESS_PATHNAME (5): /* forum address */ 997 P_address_dirname = forum_address.forum_dirname; 998 P_address_ename = forum_address.forum_ename; 999 P_address_component = ""; 1000 P_code = 0; 1001 return; 1002 1003 GET_ADDRESS_PATHNAME (6): /* foreign address */ 1004 GET_ADDRESS_PATHNAME (7): /* mail table address */ 1005 P_code = mlsys_et_$no_address_pathname; 1006 return; 1007 1008 GET_ADDRESS_PATHNAME (8): /* mailing list address */ 1009 P_address_dirname = mailing_list_address.mls_dirname; 1010 P_address_ename = mailing_list_address.mls_ename; 1011 P_address_component = mailing_list_address.mls_component; 1012 P_code = 0; 1013 return; 1014 1015 GET_ADDRESS_PATHNAME (9): /* named group address */ 1016 P_code = mlsys_et_$no_address_pathname; 1017 return; 1018 1019 /* Return the explicit route to be used to send mail to the given address which must be a foreign address: The explicit 1020* route is a route supplied by a user (either local or foreign) and is always used even though the mail system could 1021* compute a shorter route to the foreign system if permitted */ 1022 1023 get_address_explicit_route: 1024 entry (P_address_ptr, P_address_route_version, P_address_route_ptr, P_code); 1025 1026 if ^verify_address (P_address_ptr, P_code) then return; 1027 1028 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1029 1030 if address_header.type = FOREIGN_ADDRESS then 1031 if foreign_address.explicit_route ^= null () then 1032 if P_address_route_version = ADDRESS_ROUTE_VERSION_1 then do; 1033 P_address_route_ptr = foreign_address.explicit_route; 1034 P_code = 0; /* ... success */ 1035 end; 1036 else P_code = error_table_$unimplemented_version; 1037 1038 else P_code = mlsys_et_$no_address_route; /* no route at this time */ 1039 1040 else P_code = mlsys_et_$not_foreign_address; 1041 1042 return; 1043 1044 1045 1046 /* Return the name of the foreign system associated with the given address which must be a foreign address */ 1047 1048 get_address_system: 1049 entry (P_address_ptr, P_foreign_system, P_code); 1050 1051 if ^verify_address (P_address_ptr, P_code) then return; 1052 1053 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1054 1055 if address_header.type = FOREIGN_ADDRESS then do; 1056 P_foreign_system = foreign_address.foreign_system; 1057 P_code = 0; 1058 end; 1059 1060 else P_code = mlsys_et_$not_foreign_address; 1061 1062 return; 1063 1064 /* Set the implicit route associated with the given address which must be a foreign address: The implicit route is a 1065* route associated with all the addresses in a message that is used by the mail system to send mail to the given address 1066* if it can not compute a route on its own */ 1067 1068 set_address_implicit_route: 1069 entry (P_address_ptr, P_address_route_ptr, P_code); 1070 1071 if ^verify_address (P_address_ptr, P_code) then return; 1072 1073 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADRESS type */ 1074 1075 if address_header.type = FOREIGN_ADDRESS then 1076 if P_address_route_ptr -> address_route.version = ADDRESS_ROUTE_VERSION_1 then do; 1077 address_route_ptr = copy_ptr (P_address_route_ptr); 1078 if foreign_address.implicit_route ^= null () then 1079 call mlsys_address_route_mgr_$decrement_reference_count (foreign_address.implicit_route); 1080 if mlsys_data_$valid_segments (binary (baseno (address_route_ptr), 18, 0)) then 1081 foreign_address.implicit_route = address_route_ptr; 1082 else call mlsys_address_route_mgr_$create_address_route (address_route.relays, 1083 foreign_address.implicit_route); 1084 call mlsys_address_route_mgr_$increment_reference_count (foreign_address.implicit_route); 1085 P_code = 0; /* success */ 1086 end; 1087 else P_code = error_table_$unimplemented_version; 1088 1089 else P_code = mlsys_et_$not_foreign_address; 1090 1091 return; 1092 1093 1094 1095 /* Return the implicit route associated with the given address which must be a foreign address */ 1096 1097 get_address_implicit_route: 1098 entry (P_address_ptr, P_address_route_version, P_address_route_ptr, P_code); 1099 1100 if ^verify_address (P_address_ptr, P_code) then return; 1101 1102 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1103 1104 if address_header.type = FOREIGN_ADDRESS then 1105 if foreign_address.implicit_route ^= null () then 1106 if P_address_route_version = ADDRESS_ROUTE_VERSION_1 then do; 1107 P_address_route_ptr = foreign_address.implicit_route; 1108 P_code = 0; /* ... success */ 1109 end; 1110 else P_code = error_table_$unimplemented_version; 1111 1112 else P_code = mlsys_et_$no_address_route; /* no route at this time */ 1113 1114 else P_code = mlsys_et_$not_foreign_address; 1115 1116 return; 1117 1118 /* Return the setting of the display_list flag of the given address which must be a named group address */ 1119 1120 get_named_group_display_flag: 1121 entry (P_address_ptr, P_display_list, P_code); 1122 1123 if ^verify_address (P_address_ptr, P_code) then return; 1124 1125 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1126 1127 if address_header.type = NAMED_GROUP_ADDRESS then do; 1128 P_display_list = named_group_address.display_list; 1129 P_code = 0; 1130 end; 1131 1132 else P_code = mlsys_et_$not_named_group_address; 1133 1134 return; 1135 1136 1137 1138 /* Return the address name of the given address */ 1139 1140 get_address_name: 1141 entry (P_address_ptr, P_address_name, P_code); 1142 1143 if ^verify_address (P_address_ptr, P_code) then return; 1144 1145 call set_address_ptr (); 1146 1147 if (address_header.type = USER_MAILBOX_ADDRESS) | (address_header.type = LOGBOX_ADDRESS) 1148 | (address_header.type = SAVEBOX_ADDRESS) then 1149 if user_address_template.is_anonymous then /* the address name for anonymous users is their Person_id */ 1150 call set_output_variable ((user_address_template.person_id), P_address_name, P_code); 1151 else call set_output_variable (address_name, P_address_name, P_code); 1152 else call set_output_variable (address_name, P_address_name, P_code); 1153 1154 return; 1155 1156 1157 1158 /* Return the address comment of the given address */ 1159 1160 get_address_comment: 1161 entry (P_address_ptr, P_address_comment, P_code); 1162 1163 if ^verify_address (P_address_ptr, P_code) then return; 1164 1165 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1166 1167 call set_output_variable (address_comment, P_address_comment, P_code); 1168 1169 return; 1170 1171 /* Compares two addresses for equality: Two addresses are equal if mail transmitted to either address will be delivered 1172* to the same set of recipients */ 1173 1174 compare_addresses: 1175 entry (P_address_1_ptr, P_address_2_ptr, P_code) returns (bit (1) aligned); 1176 1177 if ^verify_address (P_address_1_ptr, P_code) then return ("0"b); 1178 if ^verify_address (P_address_2_ptr, P_code) then return ("0"b); 1179 1180 P_code = 0; /* the comparison will succeed */ 1181 1182 if P_address_1_ptr = P_address_2_ptr then /* they are the same physical structure */ 1183 return ("1"b); 1184 1185 address_1_mte_address_ptr, /* for cleanup handler */ 1186 address_2_mte_address_ptr, address_1_route_ptr, address_2_route_ptr, address_1_mls_ptr, address_2_mls_ptr, 1187 address_list_1_ptr, address_list_2_ptr, address_list_ptr = null (); 1188 forum_1_index, forum_2_index = 0; 1189 1190 on condition (cleanup) call cleanup_address_comparison (); 1191 1192 address_1_ptr = copy_ptr (P_address_1_ptr); /* copy inputs and check for was-foreign addresses */ 1193 if address_1_ptr -> address_header.type = FOREIGN_ADDRESS then call check_if_actually_local (address_1_ptr); 1194 /* ... might not really be a foreign address */ 1195 if address_1_ptr -> address_header.type = WAS_FOREIGN_ADDRESS then 1196 address_1_ptr = address_1_ptr -> was_foreign_address.actual_address_ptr; 1197 1198 address_2_ptr = copy_ptr (P_address_2_ptr); 1199 if address_2_ptr -> address_header.type = FOREIGN_ADDRESS then call check_if_actually_local (address_2_ptr); 1200 if address_2_ptr -> address_header.type = WAS_FOREIGN_ADDRESS then 1201 address_2_ptr = address_2_ptr -> was_foreign_address.actual_address_ptr; 1202 1203 1204 /* Lookup any mail table addresses before proceeeding: If both addresses are mail table addresses, check if they have the 1205* same mail table name right now. If only one is a mail table address or the names do not match and one or both can not 1206* be found in the mail table, then we can guarentee that the addresses aren't equal */ 1207 1208 if (address_1_ptr -> address_header.type = MAIL_TABLE_ADDRESS) 1209 & (address_2_ptr -> address_header.type = MAIL_TABLE_ADDRESS) then 1210 if address_1_ptr -> mail_table_address.mte_name = address_2_ptr -> mail_table_address.mte_name then 1211 call return_comparison_result ("1"b); 1212 1213 if address_1_ptr -> address_header.type = MAIL_TABLE_ADDRESS then do; 1214 call get_mail_table_address (address_1_ptr, address_1_mte_address_ptr, code); 1215 if code ^= 0 then call return_comparison_result ("0"b); 1216 address_1_ptr = address_1_mte_address_ptr; /* need 2nd copy as address_1_ptr may get changed */ 1217 if address_1_ptr -> address_header.type = FOREIGN_ADDRESS then 1218 call check_if_actually_local (address_1_ptr); 1219 if address_1_ptr -> address_header.type = WAS_FOREIGN_ADDRESS then 1220 address_1_ptr = address_1_ptr -> was_foreign_address.actual_address_ptr; 1221 end; 1222 1223 if address_2_ptr -> address_header.type = MAIL_TABLE_ADDRESS then do; 1224 call get_mail_table_address (address_2_ptr, address_2_mte_address_ptr, code); 1225 if code ^= 0 then call return_comparison_result ("0"b); 1226 address_2_ptr = address_2_mte_address_ptr; /* need 2nd copy as address_2_ptr may get changed */ 1227 if address_2_ptr -> address_header.type = FOREIGN_ADDRESS then 1228 call check_if_actually_local (address_2_ptr); 1229 if address_2_ptr -> address_header.type = WAS_FOREIGN_ADDRESS then 1230 address_2_ptr = address_2_ptr -> was_foreign_address.actual_address_ptr; 1231 end; 1232 1233 1234 /* If one of the addresses is a mailing list or named group but the other is not, expand the list address and compare the 1235* expansion with the other address -- all addresses in the expansion must equal the other address */ 1236 1237 if (is_list_address (address_1_ptr) & ^is_list_address (address_2_ptr)) 1238 | (is_list_address (address_2_ptr) & ^is_list_address (address_1_ptr)) then do; 1239 1240 if is_list_address (address_1_ptr) then /* we know that only one is a list address */ 1241 call expand_list_address (address_1_ptr, ADDRESS_LIST_VERSION_2, address_list_ptr, code); 1242 else do; 1243 call expand_list_address (address_2_ptr, ADDRESS_LIST_VERSION_2, address_list_ptr, code); 1244 address_2_ptr = address_1_ptr; /* "swap" the two addresses */ 1245 end; 1246 if code ^= 0 then call return_comparison_result ("0"b); 1247 /* couldn't expand: can't be equal */ 1248 1249 if address_list.n_addresses = 0 then /* the address list is empty: can't be equal */ 1250 comparison_result = "0"b; 1251 else do; 1252 comparison_result = "1"b; /* really need do until here ... */ 1253 do idx = 1 to address_list.n_addresses while (comparison_result); 1254 comparison_result = compare_addresses (address_list.addresses (idx), address_2_ptr, (0)); 1255 end; 1256 end; 1257 1258 call return_comparison_result (comparison_result); 1259 end; 1260 1261 1262 /* Both addresses are simple or both are list addresses */ 1263 1264 go to COMPARE_ADDRESSES ( 1265 COMPARISON_OPERATIONS (address_1_ptr -> address_header.type, address_2_ptr -> address_header.type)); 1266 1267 COMPARE_ADDRESSES (-1): /* incompatible types */ 1268 call return_comparison_result ("0"b); 1269 1270 1271 COMPARE_ADDRESSES (0): /* two invalid addresses: do a string comparison */ 1272 begin; 1273 dcl address_1_text char (address_1_ptr -> invalid_address.text_lth) based (address_1_ptr -> invalid_address.text_ptr); 1274 dcl address_2_text char (address_2_ptr -> invalid_address.text_lth) based (address_2_ptr -> invalid_address.text_ptr); 1275 call return_comparison_result (address_1_text = address_2_text); 1276 end; 1277 1278 1279 /* Both are addresses of mailboxes: check the pathnames before actually trying to find their UIDs */ 1280 1281 COMPARE_ADDRESSES (1): 1282 call get_address_pathname (address_1_ptr, address_1_dirname, address_1_ename, ((32)" "), (0)); 1283 call get_address_pathname (address_2_ptr, address_2_dirname, address_2_ename, ((32)" "), (0)); 1284 1285 if (address_1_dirname = address_2_dirname) & (address_1_ename = address_2_ename) then 1286 call return_comparison_result ("1"b); /* pathname strings match (whew) */ 1287 1288 call mailbox_$get_uid_file (address_1_dirname, address_1_ename, mailbox_1_uid, code_1); 1289 call mailbox_$get_uid_file (address_2_dirname, address_2_ename, mailbox_2_uid, code_2); 1290 1291 if (code_1 = 0) & (code_2 = 0) then /* got both UIDs */ 1292 comparison_result = (mailbox_1_uid = mailbox_2_uid); 1293 else comparison_result = "0"b; /* got only one UID (or none): can't be equal */ 1294 1295 call return_comparison_result (comparison_result); 1296 1297 1298 /* Both are addresses of forum meetings: check the pathnames before actually trying to access the meetings */ 1299 1300 COMPARE_ADDRESSES (2): 1301 call get_address_pathname (address_1_ptr, address_1_dirname, address_1_ename, ((32)" "), (0)); 1302 call get_address_pathname (address_2_ptr, address_2_dirname, address_2_ename, ((32)" "), (0)); 1303 1304 if (address_1_dirname = address_2_dirname) & (address_1_ename = address_2_ename) then 1305 call return_comparison_result ("1"b); /* pathname strings match (whew) */ 1306 1307 if mlsys_psp_$forum_not_available () then /* if no forum on system ... */ 1308 call return_comparison_result ("0"b); /* ... they can't be equal as pathnames don't match */ 1309 1310 if (address_1_dirname = "") | (address_2_dirname = "") then call return_comparison_result ("0"b); 1311 /* at least one of the forums doesn't exist */ 1312 1313 call forum_$open_forum (address_1_dirname, address_1_ename, forum_1_index, code_1); 1314 call forum_$open_forum (address_2_dirname, address_2_ename, forum_2_index, code_2); 1315 1316 if (code_1 = 0) & (code_2 = 0) then /* were able to open both */ 1317 comparison_result = (forum_1_index = forum_2_index); 1318 else comparison_result = "0"b; /* couldn't open one or both: can't be equal */ 1319 1320 call return_comparison_result (comparison_result); 1321 1322 1323 /* Both are foreign addresses */ 1324 1325 COMPARE_ADDRESSES (3): 1326 begin; 1327 dcl address_1_local_part character (address_1_ptr -> foreign_address.local_part_lth) 1328 based (address_1_ptr -> foreign_address.local_part_ptr); 1329 dcl address_2_local_part character (address_2_ptr -> foreign_address.local_part_lth) 1330 based (address_2_ptr -> foreign_address.local_part_ptr); 1331 if address_1_local_part ^= address_2_local_part then call return_comparison_result ("0"b); 1332 end; /* can't be equal if local parts differ */ 1333 1334 /*** check system names and routes */ 1335 call mlsys_address_route_mgr_$compute_optimum_route (address_1_ptr, address_1_route_ptr, code_1); 1336 call mlsys_address_route_mgr_$compute_optimum_route (address_2_ptr, address_2_route_ptr, code_2); 1337 /* these routes includes the actual target system */ 1338 1339 if (code_1 = 0) & (code_2 = 0) then /* have a way to get to both systems */ 1340 if address_1_route_ptr -> address_route.n_relays = address_2_route_ptr -> address_route.n_relays then do; 1341 comparison_result = "1"b; /* ... need do until */ 1342 do idx = 1 to address_1_route_ptr -> address_route.n_relays while (comparison_result); 1343 comparison_result = 1344 (translate (address_1_route_ptr -> address_route.relays (idx), UPPERCASE, LOWERCASE) 1345 = translate (address_2_route_ptr -> address_route.relays (idx), UPPERCASE, LOWERCASE)); 1346 end; 1347 end; 1348 else comparison_result = "0"b; /* ... not the same number of hops */ 1349 else comparison_result = "0"b; /* ... can't get to one or both */ 1350 1351 call return_comparison_result (comparison_result); 1352 1353 1354 /* Both are mailing list addresses: check for the same segment/archive components before checking the actual addresses in 1355* the two lists */ 1356 1357 COMPARE_ADDRESSES (4): 1358 if (address_1_ptr -> mailing_list_address.mls_dirname = address_2_ptr -> mailing_list_address.mls_dirname) 1359 & (address_1_ptr -> mailing_list_address.mls_ename = address_2_ptr -> mailing_list_address.mls_ename) 1360 & (address_1_ptr -> mailing_list_address.mls_component 1361 = address_2_ptr -> mailing_list_address.mls_component) then 1362 call return_comparison_result ("1"b); /* pathnames match */ 1363 1364 call initiate_file_$component (address_1_ptr -> mailing_list_address.mls_dirname, 1365 address_1_ptr -> mailing_list_address.mls_ename, address_1_ptr -> mailing_list_address.mls_component, 1366 R_ACCESS, address_1_mls_ptr, (0), code_1); 1367 call initiate_file_$component (address_2_ptr -> mailing_list_address.mls_dirname, 1368 address_2_ptr -> mailing_list_address.mls_ename, address_2_ptr -> mailing_list_address.mls_component, 1369 R_ACCESS, address_2_mls_ptr, (0), code_2); 1370 1371 if (code_1 = 0) & (code_2 = 0) then /* got them both: are they the same? */ 1372 comparison_result = (address_1_mls_ptr = address_2_mls_ptr); 1373 else comparison_result = "0"b; /* couldn't initiate both: this will fail again later */ 1374 1375 if comparison_result then /* they match */ 1376 call return_comparison_result ("1"b); 1377 /*** not the same mailing list: fall through and check their contents */ 1378 1379 1380 /* Both are list addresses: check the individual addresses within the two lists */ 1381 1382 COMPARE_ADDRESSES (5): 1383 call expand_list_address (address_1_ptr, ADDRESS_LIST_VERSION_2, address_list_1_ptr, code_1); 1384 call expand_list_address (address_2_ptr, ADDRESS_LIST_VERSION_2, address_list_2_ptr, code_2); 1385 1386 if (code_1 ^= 0) | (code_2 ^= 0) then /* couldn't expand both: can't be equal */ 1387 call return_comparison_result ("0"b); 1388 1389 if (address_list_1_ptr -> address_list.n_addresses = 0) & (address_list_2_ptr -> address_list.n_addresses = 0) 1390 then comparison_result = "1"b; /* both lists are empty */ 1391 1392 else if (address_list_1_ptr -> address_list.n_addresses = 0) 1393 | (address_list_2_ptr -> address_list.n_addresses = 0) then 1394 comparison_result = "0"b; /* one is empty and the other isn't: can't be equal */ 1395 1396 else do; /* must check each address in both lists */ 1397 comparison_result = "1"b; /* ... need do until again */ 1398 do idx = 1 to address_list_1_ptr -> address_list.n_addresses while (comparison_result); 1399 partial_comparison_result = "0"b; 1400 do jdx = 1 to address_list_2_ptr -> address_list.n_addresses while (^partial_comparison_result); 1401 partial_comparison_result = 1402 compare_addresses (address_list_1_ptr -> address_list.addresses (idx), 1403 address_list_2_ptr -> address_list.addresses (jdx), (0)); 1404 end; 1405 comparison_result = partial_comparison_result; 1406 end; /* ... stop as soon as we find one not in the other list */ 1407 do idx = 1 to address_list_2_ptr -> address_list.n_addresses while (comparison_result); 1408 partial_comparison_result = "0"b; 1409 do jdx = 1 to address_list_2_ptr -> address_list.n_addresses while (^partial_comparison_result); 1410 partial_comparison_result = 1411 compare_addresses (address_list_2_ptr -> address_list.addresses (idx), 1412 address_list_1_ptr -> address_list.addresses (jdx), (0)); 1413 end; 1414 comparison_result = partial_comparison_result; 1415 end; /* ... stop as soon as we find one not in the other list */ 1416 end; 1417 1418 call return_comparison_result (comparison_result); 1419 1420 1421 1422 /* Return the result of the address comparison (after proper cleanup, of course) */ 1423 1424 return_comparison_result: 1425 procedure (p_result); 1426 1427 dcl p_result bit (1) aligned; 1428 1429 call cleanup_address_comparison (); 1430 1431 comparison_result = p_result; /* set the result in the caller's stack frame */ 1432 1433 go to RETURN_FROM_COMPARE_ADDRESSES; 1434 1435 end return_comparison_result; 1436 1437 RETURN_FROM_COMPARE_ADDRESSES: /* actually return point for mail_system_$compare_addresses */ 1438 return (comparison_result); 1439 1440 1441 1442 /* Cleanup after an address comparison operation */ 1443 1444 cleanup_address_comparison: 1445 procedure (); 1446 1447 if address_1_mte_address_ptr ^= null () then call free_address (address_1_mte_address_ptr, (0)); 1448 if address_2_mte_address_ptr ^= null () then call free_address (address_2_mte_address_ptr, (0)); 1449 1450 if address_list_ptr ^= null () then call mlsys_address_list_mgr_$free_address_list (address_list_ptr, (0)); 1451 1452 if forum_1_index ^= 0 then call forum_$close_forum (forum_1_index, (0)); 1453 if forum_2_index ^= 0 then call forum_$close_forum (forum_2_index, (0)); 1454 forum_1_index, forum_2_index = 0; 1455 1456 if address_1_route_ptr ^= null () then call mlsys_address_route_mgr_$free_address_route (address_1_route_ptr); 1457 if address_2_route_ptr ^= null () then call mlsys_address_route_mgr_$free_address_route (address_2_route_ptr); 1458 1459 if address_1_mls_ptr ^= null () then call terminate_file_ (address_1_mls_ptr, 0, TERM_FILE_TERM, (0)); 1460 if address_2_mls_ptr ^= null () then call terminate_file_ (address_2_mls_ptr, 0, TERM_FILE_TERM, (0)); 1461 address_1_mls_ptr, address_2_mls_ptr = null (); 1462 1463 if address_list_1_ptr ^= null () then call mlsys_address_list_mgr_$free_address_list (address_list_1_ptr, (0)); 1464 if address_list_2_ptr ^= null () then call mlsys_address_list_mgr_$free_address_list (address_list_2_ptr, (0)); 1465 1466 return; 1467 1468 end cleanup_address_comparison; 1469 1470 /* Return the actual address in the system's mail table corresponding to the given address */ 1471 1472 get_mail_table_address: 1473 entry (P_address_ptr, P_mail_table_address_ptr, P_code); 1474 1475 if ^verify_address (P_address_ptr, P_code) then return; 1476 1477 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1478 1479 if address_header.type ^= MAIL_TABLE_ADDRESS then do; 1480 P_code = mlsys_et_$not_mail_table_address; 1481 return; 1482 end; 1483 1484 current_mtle_ptr = null (); /* this is the top of the list */ 1485 call lookup_mail_table_entry (mail_table_address.mte_name); 1486 1487 P_mail_table_address_ptr = mail_table_address_ptr; 1488 code = 0; /* success */ 1489 1490 RETURN_FROM_GET_MAIL_TABLE_ADDRESS: 1491 P_code = code; 1492 1493 return; 1494 1495 1496 1497 /* Searches the mail table for the given name: If found, a check is made for a circular definition as the mail table 1498* software does not prevent recursive entries */ 1499 1500 lookup_mail_table_entry: 1501 procedure (p_mte_name); 1502 1503 dcl p_mte_name character (32) varying parameter; 1504 1505 dcl 1 mtle aligned based (mtle_ptr), 1506 2 previous_mtle_ptr pointer, 1507 2 name character (32) varying; 1508 dcl mtle_ptr pointer; 1509 1510 dcl 1 local_mtle aligned like mtle; 1511 dcl next_mte_name character (32) varying; 1512 1513 call mail_table_$get (p_mte_name, mail_table_address_ptr, ((168)" "), code); 1514 if code = error_table_$id_not_found then code = mlsys_et_$mte_not_found; 1515 if code ^= 0 then go to RETURN_FROM_GET_MAIL_TABLE_ADDRESS; 1516 1517 if mail_table_address_ptr -> address_header.type ^= MAIL_TABLE_ADDRESS then return; 1518 /* target isn't another mail table entry: this is it */ 1519 1520 next_mte_name = mail_table_address_ptr -> mail_table_address.mte_name; 1521 call free_address (mail_table_address_ptr, (0)); /* we don't need this address anymore */ 1522 1523 local_mtle.name = p_mte_name; /* put it onto the stack */ 1524 local_mtle.previous_mtle_ptr = current_mtle_ptr; 1525 current_mtle_ptr = addr (local_mtle); 1526 1527 do mtle_ptr = current_mtle_ptr repeat (mtle.previous_mtle_ptr) while (mtle_ptr ^= null ()); 1528 if next_mte_name = mtle.name then do; /* the name is circular ... */ 1529 code = mlsys_et_$circular_mtes; 1530 go to RETURN_FROM_GET_MAIL_TABLE_ADDRESS; 1531 end; 1532 end; 1533 1534 call lookup_mail_table_entry (next_mte_name); /* recurse */ 1535 1536 end lookup_mail_table_entry; 1537 1538 /* Returns the address list which is the expansion of a list address (mailing list/named group) */ 1539 1540 expand_list_address: 1541 entry (P_address_ptr, P_address_list_version, P_address_list_ptr, P_code); 1542 1543 if ^verify_address (P_address_ptr, P_code) then return; 1544 1545 call set_address_ptr (); /* bypass the infamous WAS_FOREIGN_ADDRESS type */ 1546 1547 if ^is_list_address (address_ptr) then do; /* must be a mailing list or a named group */ 1548 P_code = mlsys_et_$not_list_address; 1549 return; 1550 end; 1551 1552 if P_address_list_version ^= ADDRESS_LIST_VERSION_2 then do; 1553 P_code = error_table_$unimplemented_version; 1554 return; 1555 end; 1556 1557 if address_header.type = NAMED_GROUP_ADDRESS then 1558 if named_group_address.address_list = null () then 1559 /*** no address list: return an empty list to the caller */ 1560 call mlsys_address_list_mgr_$create_user_freeable_address_list (P_address_list_version, 1561 P_address_list_ptr, P_code); 1562 else do; /* there is a list present */ 1563 P_address_list_ptr = named_group_address.address_list; 1564 P_code = 0; 1565 end; 1566 1567 else /*** if address_header.type = MAILING_LIST_ADDRESS then */ 1568 do; 1569 /*** Mailing list: initiate the segment/archive component and then parse its content */ 1570 mls_ptr = null (); /* for cleanup handler */ 1571 on condition (cleanup) 1572 begin; 1573 if mls_ptr ^= null () then call terminate_file_ (mls_ptr, 0, TERM_FILE_TERM, (0)); 1574 end; 1575 call initiate_file_$component (mailing_list_address.mls_dirname, mailing_list_address.mls_ename, 1576 mailing_list_address.mls_component, R_ACCESS, mls_ptr, mls_bitcount, code); 1577 if (code = error_table_$noentry) | (code = error_table_$no_component) then 1578 code = mlsys_et_$no_mailing_list; 1579 if code = 0 then do; /* it's there and we have access ... */ 1580 mls_lth = divide ((mls_bitcount + 8), 9, 21, 0); 1581 call mlsys_parse_text_$parse_mailing_list_text (mls_text, P_address_list_version, address_list_ptr, 1582 code); 1583 end; 1584 else address_list_ptr = null (); /* ... no luck */ 1585 if mls_ptr ^= null () then call terminate_file_ (mls_ptr, 0, TERM_FILE_TERM, (0)); 1586 P_address_list_ptr = address_list_ptr; 1587 P_code = code; 1588 end; 1589 1590 return; 1591 1592 1593 1594 /* Return "1"b if the supplied address is a list address (ie: either a mailing list or a named group address) */ 1595 1596 is_list_address: 1597 procedure (p_address_ptr) returns (bit (1) aligned); 1598 1599 dcl p_address_ptr pointer parameter; 1600 1601 return ((p_address_ptr -> address_header.type = MAILING_LIST_ADDRESS) 1602 | (p_address_ptr -> address_header.type = NAMED_GROUP_ADDRESS)); 1603 1604 end is_list_address; 1605 1606 /* Checks if the supplied address is actually a local address by computing the optimum route to reach said address: If 1607* the route shows that the address is local, this entrypoint will convert it into its proper representation */ 1608 1609 check_if_actually_local: 1610 entry (P_address_ptr); 1611 1612 if P_address_ptr -> address_header.type = FOREIGN_ADDRESS then call check_if_actually_local (P_address_ptr); 1613 1614 return; 1615 1616 1617 1618 /* Acutally checks if a foreign address is really local (called by several entrypoints) */ 1619 1620 check_if_actually_local: 1621 procedure (p_address_ptr); 1622 1623 dcl p_address_ptr pointer parameter; 1624 1625 dcl foreign_local_part character (old_address_ptr -> foreign_address.local_part_lth) unaligned 1626 based (old_address_ptr -> foreign_address.local_part_ptr); 1627 dcl new_address_name character (new_address_ptr -> address_header.name_lth) unaligned 1628 based (new_address_ptr -> address_header.name_ptr); 1629 dcl new_address_comment character (new_address_ptr -> address_header.comment_lth) unaligned 1630 based (new_address_ptr -> address_header.comment_ptr); 1631 dcl (old_address_ptr, new_address_ptr, new_new_address_ptr) pointer; 1632 1633 1634 old_address_ptr = copy_ptr (p_address_ptr); 1635 1636 address_route_ptr = null (); /* not set by following procedure if there were errors */ 1637 call mlsys_address_route_mgr_$compute_optimum_route (old_address_ptr, address_route_ptr, code); 1638 1639 if (address_route_ptr ^= null ()) | (code ^= 0) then do; 1640 if address_route_ptr ^= null () then call mlsys_address_route_mgr_$free_address_route (address_route_ptr); 1641 return; /* got a route or an error: it's really foreign */ 1642 end; 1643 1644 call mlsys_parse_text_$parse_address_text (foreign_local_part, new_address_ptr, code); 1645 if code ^= 0 then /* won't parse: create an invalid address */ 1646 call create_invalid_address ((foreign_local_part), "", "", new_address_ptr, (0)); 1647 1648 if new_address_ptr -> address_header.type = FOREIGN_ADDRESS then do; 1649 /*** New address is still foreign: check again to see if it's really local */ 1650 call check_if_actually_local (new_address_ptr); 1651 if new_address_ptr -> address_header.type = WAS_FOREIGN_ADDRESS then do; 1652 /*** Eliminate an extra level of indirection: increment the real target's (new_new) reference count 1653* now; otherwise, it will be freed when the middle address (new) is freed */ 1654 new_new_address_ptr = new_address_ptr -> was_foreign_address.actual_address_ptr; 1655 call increment_reference_count (new_new_address_ptr); 1656 call free_address (new_address_ptr, (0)); 1657 new_address_ptr = new_new_address_ptr; 1658 end; 1659 else new_new_address_ptr = null (); /* used as a flag to indicated whether reference count ... */ 1660 end; 1661 else new_new_address_ptr = null (); /* ... has already been incremented for the target */ 1662 1663 if old_address_ptr -> foreign_address.free_local_part then free foreign_local_part in (mlsys_area); 1664 1665 old_address_ptr -> address_header.type = WAS_FOREIGN_ADDRESS; 1666 1667 old_address_ptr -> was_foreign_address.actual_address_ptr = new_address_ptr; 1668 if new_new_address_ptr = null () then /* we didn't increment the target's refcount above ... */ 1669 call increment_reference_count (new_address_ptr); 1670 1671 if new_address_ptr -> address_header.free_name then free new_address_name in (mlsys_area); 1672 if new_address_ptr -> address_header.free_comment then free new_address_comment in (mlsys_area); 1673 /* the address will use the original name and comment */ 1674 1675 new_address_ptr -> address_header.name = old_address_ptr -> address_header.name; 1676 new_address_ptr -> address_header.comment = old_address_ptr -> address_header.comment; 1677 new_address_ptr -> address_header.free_name, /* the name and comment will be freed (if needed) ... */ 1678 new_address_ptr -> address_header.free_comment = "0"b; 1679 /* ... when the original address is freed */ 1680 1681 return; 1682 1683 end check_if_actually_local; 1684 1685 /* Verify that the caller supplied a pointer to a mail system address */ 1686 1687 verify_address: 1688 entry (P_address_ptr, P_code) returns (bit (1) aligned); 1689 1690 return (verify_address (P_address_ptr, P_code)); /* just a transfer to the internal procedure */ 1691 1692 1693 1694 /* Actually verify the supplied pointer */ 1695 1696 verify_address: 1697 procedure (p_address_ptr, p_code) returns (bit (1) aligned); 1698 1699 dcl p_address_ptr pointer parameter; 1700 dcl p_code fixed binary (35) parameter; 1701 1702 if p_address_ptr = null () then p_code = mlsys_et_$not_address; 1703 1704 else if ^mlsys_data_$valid_segments (binary (baseno (p_address_ptr), 18, 0)) then 1705 p_code = mlsys_et_$not_address; /* supplied "address" wasn't allocated by us */ 1706 1707 else if p_address_ptr -> address_header.version ^= ADDRESS_VERSION_2 then p_code = mlsys_et_$not_address; 1708 /* supplied "address" is some other type of structure */ 1709 1710 else p_code = 0; /* it's an address */ 1711 1712 return ((p_code = 0)); 1713 1714 end verify_address; 1715 1716 1717 1718 /* Sets the local address_ptr variable from the caller's P_address_ptr parameter */ 1719 1720 set_address_ptr: 1721 procedure (); 1722 1723 address_ptr = copy_ptr (P_address_ptr); 1724 1725 if address_header.type = WAS_FOREIGN_ADDRESS then /* bypass this place-holder address */ 1726 address_ptr = was_foreign_address.actual_address_ptr; 1727 1728 return; 1729 1730 end set_address_ptr; 1731 1732 /* Sets the specified string in an address to the supplied value */ 1733 1734 set_address_variable_string: 1735 procedure (p_input_value, p_address_variable, p_free_address_variable); 1736 1737 dcl p_input_value character (*) parameter varying; 1738 dcl 1 p_address_variable aligned parameter, 1739 2 text_ptr pointer, 1740 2 text_lth fixed binary (21); 1741 dcl p_free_address_variable bit (1) unaligned parameter; 1742 1743 dcl address_variable character (p_address_variable.text_lth) unaligned based (p_address_variable.text_ptr); 1744 1745 if p_input_value = "" then do; /* nothing supplied here */ 1746 p_address_variable.text_ptr = addr (NULL_STRING); 1747 p_address_variable.text_lth = 0; 1748 p_free_address_variable = "0"b; 1749 end; 1750 1751 else do; 1752 p_address_variable.text_lth = length (p_input_value); 1753 allocate address_variable in (mlsys_area) set (p_address_variable.text_ptr); 1754 address_variable = p_input_value; 1755 p_free_address_variable = "1"b; 1756 end; 1757 1758 return; 1759 1760 end set_address_variable_string; 1761 1762 1763 1764 /* Sets the given output parameter to the supplied string while checking for truncation of the string */ 1765 1766 set_output_variable: 1767 procedure (p_output_value, p_output_parameter, p_code); 1768 1769 dcl p_output_value character (*) parameter; /* the value to be returned */ 1770 dcl p_output_parameter character (*) varying parameter; /* the caller's output parameter */ 1771 dcl p_code fixed binary (35) parameter; 1772 1773 if length (p_output_value) > maxlength (p_output_parameter) then 1774 p_code = error_table_$smallarg; /* it's too long */ 1775 1776 else do; /* it fits */ 1777 p_output_parameter = p_output_value; 1778 p_code = 0; 1779 end; 1780 1781 return; 1782 1783 end set_output_variable; 1784 1785 /* Validates that the given entry name ends in the proper suffix and is also not overlength */ 1786 1787 validate_entryname: 1788 procedure (p_ename, p_suffix, p_actual_ename, p_code) returns (bit (1) aligned); 1789 1790 dcl (p_ename, p_suffix, p_actual_ename) character (*) parameter; 1791 dcl p_code fixed binary (35) parameter; 1792 1793 p_code = 0; /* assume success */ 1794 1795 if p_suffix ^= "" then /* caller has a suffix to check ... */ 1796 if index (reverse (rtrim (p_ename)), reverse (p_suffix)) ^= 1 then p_code = mlsys_et_$incorrect_suffix; 1797 1798 if p_code = 0 then /* check length if the suffix is OK */ 1799 if length (rtrim (p_ename)) > length (p_actual_ename) then p_code = error_table_$entlong; 1800 1801 return ((p_code = 0)); /* let caller know if it's OK */ 1802 1803 end validate_entryname; 1804 1805 /* Allocates and initializes an address of the requested type */ 1806 1807 initialize_address: 1808 procedure (p_address_type); 1809 1810 dcl p_address_type fixed binary parameter; 1811 1812 go to INITIALIZE_ADDRESS (p_address_type); 1813 1814 INITIALIZE_ADDRESS (0): /* invalid address */ 1815 allocate invalid_address in (mlsys_area) set (address_ptr); 1816 call initialize_header (); 1817 invalid_address.text_ptr = addr (NULL_STRING); /* haven't got the text yet */ 1818 invalid_address.text_lth = 0; 1819 string (invalid_address.flags) = ""b; /* nothing to free yet */ 1820 return; 1821 1822 INITIALIZE_USER_MAILBOX_COMMON: /* shared code for user mailboxes (default/logbox/savebox) */ 1823 call initialize_header (); 1824 user_address_template.person_id, user_address_template.project_id = ""; 1825 string (user_address_template.flags) = ""b; /* don't know yet if it's anonymous */ 1826 return; 1827 1828 INITIALIZE_ADDRESS (1): /* user mailbox address */ 1829 allocate user_mailbox_address in (mlsys_area) set (address_ptr); 1830 go to INITIALIZE_USER_MAILBOX_COMMON; 1831 1832 INITIALIZE_ADDRESS (2): /* logbox address */ 1833 allocate logbox_address in (mlsys_area) set (address_ptr); 1834 go to INITIALIZE_USER_MAILBOX_COMMON; 1835 1836 INITIALIZE_ADDRESS (3): /* savebox address */ 1837 allocate savebox_address in (mlsys_area) set (address_ptr); 1838 savebox_address.mbx_dirname, savebox_address.mbx_ename = ""; 1839 go to INITIALIZE_USER_MAILBOX_COMMON; 1840 1841 INITIALIZE_ADDRESS (4): /* mailbox address */ 1842 allocate mailbox_address in (mlsys_area) set (address_ptr); 1843 call initialize_header (); 1844 mailbox_address.mbx_dirname, mailbox_address.mbx_ename = ""; 1845 return; 1846 1847 INITIALIZE_ADDRESS (5): /* forum address */ 1848 allocate forum_address in (mlsys_area) set (address_ptr); 1849 call initialize_header (); 1850 forum_address.forum_dirname, forum_address.forum_ename = ""; 1851 return; 1852 1853 INITIALIZE_ADDRESS (6): /* foreign address */ 1854 allocate foreign_address in (mlsys_area) set (address_ptr); 1855 call initialize_header (); 1856 foreign_address.local_part_ptr = addr (NULL_STRING); 1857 /* no local part yet */ 1858 foreign_address.local_part_lth = 0; 1859 foreign_address.foreign_system = ""; /* no system name */ 1860 foreign_address.explicit_route, /* no explicit/implicit route */ 1861 foreign_address.implicit_route = null (); 1862 string (foreign_address.flags) = ""b; /* nothing to free yet */ 1863 return; 1864 1865 INITIALIZE_ADDRESS (7): /* mail table address */ 1866 allocate mail_table_address in (mlsys_area) set (address_ptr); 1867 call initialize_header (); 1868 mail_table_address.mte_name = ""; 1869 return; 1870 1871 INITIALIZE_ADDRESS (8): /* mailing list address */ 1872 allocate mailing_list_address in (mlsys_area) set (address_ptr); 1873 call initialize_header (); 1874 mailing_list_address.mls_dirname, mailing_list_address.mls_ename, mailing_list_address.mls_component = ""; 1875 return; 1876 1877 INITIALIZE_ADDRESS (9): /* named group address */ 1878 allocate named_group_address in (mlsys_area) set (address_ptr); 1879 call initialize_header (); 1880 named_group_address.address_list = null (); /* nothing in the group yet */ 1881 string (named_group_address.flags) = ""b; /* don't know whether or not to display the addresses */ 1882 return; 1883 1884 1885 1886 /* Internal to initialize_address: initializes the address header */ 1887 1888 initialize_header: 1889 procedure (); 1890 1891 address_header.version = ADDRESS_VERSION_2; 1892 1893 address_header.type = p_address_type; /* as requested by the caller */ 1894 1895 address_header.reference_count = 0; /* nothing else in the mail system knows about it */ 1896 1897 address_header.name_ptr = addr (NULL_STRING);/* no name ... */ 1898 address_header.name_lth = 0; 1899 1900 address_header.comment_ptr = addr (NULL_STRING); 1901 address_header.comment_lth = 0; /* ... and no comment */ 1902 1903 string (address_header.flags) = ""b; /* nothing to free and it's OK to free it */ 1904 1905 return; 1906 1907 end initialize_header; 1908 1909 end initialize_address; 1910 2 1 /* BEGIN INCLUDE FILE ... mlsys_copy_ptr.incl.pl1 */ 2 2 /* Created: August 1983 by G. Palter */ 2 3 /* Recoded: October 1983 by W. Olin Sibert to be guarenteed to work */ 2 4 2 5 /* Copies a pointer parameter while changing the ring number in said pointer to the ring of execution: This change of 2 6* ring number is required to allow the mail system to properly manipulate ring-2 objects as requested by the caller as 2 7* the caller's pointer to said object would cause an access violation. The mail system does its own validation to insure 2 8* that the pointer provided by the caller is legitimate */ 2 9 2 10 copy_ptr: 2 11 procedure (p_pointer) returns (pointer); 2 12 2 13 dcl p_pointer pointer parameter; 2 14 dcl return_value pointer options (packed); 2 15 2 16 return_value = p_pointer; /* packed pointers don't have ring numbers ... */ 2 17 2 18 return (return_value); /* ... so it will be set to the ring of execution */ 2 19 2 20 end copy_ptr; 2 21 2 22 /* END INCLUDE FILE ... mlsys_copy_ptr.incl.pl1 */ 1911 1912 3 1 /* BEGIN INCLUDE FILE ... mlsys_data.incl.pl1 */ 3 2 /* Created: 20 Decembber 1978 by G. Palter */ 3 3 /* Modified: 1 July 1983 by G. Palter to merge with mlsys_internal_data_ */ 3 4 3 5 /* Constants defined by the Multics mail system for external use */ 3 6 3 7 dcl mlsys_data_$system_directory character (168) external; /* directory containing per-system data (mail table/queues) */ 3 8 3 9 3 10 /* Static data defined by the Multics mail system for external use */ 3 11 3 12 dcl mlsys_data_$user_default_mailbox_address pointer external; 3 13 /* -> the address of the user's default mailbox */ 3 14 dcl mlsys_data_$user_mail_table_address pointer external; /* -> the address of the user's entry in the mail table */ 3 15 dcl mlsys_data_$user_logbox_address pointer external; /* -> the address of the user's logbox */ 3 16 3 17 /* END INCLUDE FILE ... mlsys_data.incl.pl1 */ 1913 1914 4 1 /* BEGIN INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 4 2 4 3 4 4 /****^ HISTORY COMMENTS: 4 5* 1) change(86-06-11,Mills), approve(86-06-11,MCR7419), 4 6* audit(86-06-17,Margolin), install(86-06-30,MR12.0-1080): 4 7* Added mlsys_data_$domains_available. 4 8* END HISTORY COMMENTS */ 4 9 4 10 4 11 /* Created: May 1981 by G. Palter */ 4 12 /* Modified: July 1983 by G. Palter to merge with mlsys_data_ */ 4 13 4 14 /* Constants used internally by the Multics mail system */ 4 15 4 16 dcl mlsys_data_$max_opening_retries fixed binary external; /* maximum number of times to reopen a mailbox if it gets 4 17* damaged and salvaged while open */ 4 18 4 19 dcl mlsys_data_$max_lock_wait_retries fixed binary external; 4 20 /* maximum number of times to try to send a message while the 4 21* mailbox is locked (being salvaged?) */ 4 22 4 23 4 24 /* Allocation overhead factors: When allocating those structures with refer extents, insure that the variable portion of 4 25* the structure contains a multiple of the appropriate constant number of slots. These extra slots will be used for 4 26* later additions to the structure; when a new element must be added to a full structure, add this many new slots (rather 4 27* than a single new slot) 4 28* 4 29* The following expression should be used to determine the initial allocation: 4 30* 4 31* n_slots_to_allocate = n_slots_needed + CONSTANT - mod (n_slots_needed, CONSTANT); */ 4 32 4 33 dcl (mlsys_data_$mailbox_allocation, /* mailbox.messages */ 4 34 mlsys_data_$message_body_sections_allocation, /* message.body_sections */ 4 35 mlsys_data_$message_redistributions_list_allocation, /* message_redistributions_list.redistributions */ 4 36 mlsys_data_$message_user_fields_allocation, /* message_user_fields_list.user_fields */ 4 37 mlsys_data_$message_references_list_allocation, /* message_references_list.references */ 4 38 mlsys_data_$address_list_allocation) /* address_list.addresses */ 4 39 fixed binary external; 4 40 4 41 4 42 /* Static data user by the Multics mail system */ 4 43 4 44 dcl (mlsys_data_$forum_not_available, /* 1 => forum isn't available on the system or in this ring */ 4 45 mlsys_data_$ism_not_available, /* 1 => no inter-system mailer on this system */ 4 46 mlsys_data_$domains_available) /* 1 => domain name system software on this sytem */ 4 47 fixed binary (1) external; 4 48 4 49 dcl (mlsys_data_$subsystem_ring, /* ring in which the mail system is secured */ 4 50 mlsys_data_$highest_usable_ring, /* highest ring of execution which may use the mail system */ 4 51 mlsys_data_$lowest_forum_ring) /* lowest ring of execution with access to forum */ 4 52 fixed binary (3) external; 4 53 4 54 dcl mlsys_data_$temp_segment_list_ptr pointer external; /* -> list of all mail system temporary segments */ 4 55 4 56 dcl mlsys_data_$valid_segments (0:4095) bit (1) unaligned external; 4 57 /* indicates which segments have been used by the mail system 4 58* for the allocation of user-visible data in order to 4 59* validate that pointers passed from the user-ring are OK */ 4 60 4 61 dcl mlsys_area area based (mlsys_data_$subsystem_area_ptr);/* area used for all user-visible allocations ... */ 4 62 dcl mlsys_data_$subsystem_area_ptr pointer external; /* ... and the pointer on which it is based */ 4 63 4 64 dcl mlsys_data_$hash_tables_segment_ptr pointer external; /* -> hash tables used by the mail system */ 4 65 4 66 dcl mlsys_data_$transmit_cache_ptr pointer external; /* -> cache of recently used mailboxes for mlsys_transmit_ */ 4 67 4 68 dcl mlsys_data_$user_is_anonymous bit (1) aligned external;/* ON => the user is an anonymous user */ 4 69 4 70 dcl mlsys_data_$person_id character (24) varying external; /* the user's Person_id */ 4 71 dcl mlsys_data_$project_id character (12) varying external;/* the user's Project_id */ 4 72 dcl mlsys_data_$user_id character (32) varying external; /* the user's User_id (Person_id.Project_id) */ 4 73 4 74 /* END INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 1915 1916 5 1 /* BEGIN INCLUDE FILE ... mlsys_address_route.incl.pl1 */ 5 2 /* Created: June 1983 by G. Palter */ 5 3 5 4 /* Definition of a mail system address route */ 5 5 5 6 dcl 1 address_route aligned based (address_route_ptr), 5 7 2 header, 5 8 3 version character (8) unaligned, 5 9 3 reserved bit (144), /* ... exclusively for use by the mail system */ 5 10 3 n_relays fixed binary, /* # of relay systems in the route */ 5 11 2 relays (address_route_n_relays refer (address_route.n_relays)) character (256) varying; 5 12 /* the relays: relays(1) is closest to the local host */ 5 13 5 14 dcl ADDRESS_ROUTE_VERSION_1 character (8) static options (constant) initial ("mlsrte01"); 5 15 5 16 dcl address_route_ptr pointer; 5 17 5 18 dcl address_route_n_relays fixed binary; /* for allocating above structure (users do on occasion) */ 5 19 5 20 /* END INCLUDE FILE ... mlsys_address_route.incl.pl1 */ 1917 1918 6 1 /* BEGIN INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 6 2 /* Created: June 1983 by G. Palter */ 6 3 6 4 /* Definition of an address list -- a collection of addresses used as the value of certain message fields, etc. */ 6 5 6 6 dcl 1 address_list aligned based (address_list_ptr), 6 7 2 version character (8) unaligned, 6 8 2 reserved bit (144), /* ... exclusively for use by the mail system */ 6 9 2 n_addresses fixed binary, /* # of address in this list */ 6 10 2 addresses (address_list_n_addresses refer (address_list.n_addresses)) pointer; 6 11 6 12 dcl ADDRESS_LIST_VERSION_2 character (8) static options (constant) initial ("mlsals02"); 6 13 6 14 dcl address_list_ptr pointer; 6 15 6 16 dcl address_list_n_addresses fixed binary; /* reserved exclusively for use by the mail system */ 6 17 6 18 /* END INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 1919 1920 7 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 7 2* 7 3* Values for the "access mode" argument so often used in hardcore 7 4* James R. Davis 26 Jan 81 MCR 4844 7 5* Added constants for SM access 4/28/82 Jay Pattin 7 6* Added text strings 03/19/85 Chris Jones 7 7**/ 7 8 7 9 7 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 7 11 dcl ( 7 12 N_ACCESS init ("000"b), 7 13 R_ACCESS init ("100"b), 7 14 E_ACCESS init ("010"b), 7 15 W_ACCESS init ("001"b), 7 16 RE_ACCESS init ("110"b), 7 17 REW_ACCESS init ("111"b), 7 18 RW_ACCESS init ("101"b), 7 19 S_ACCESS init ("100"b), 7 20 M_ACCESS init ("010"b), 7 21 A_ACCESS init ("001"b), 7 22 SA_ACCESS init ("101"b), 7 23 SM_ACCESS init ("110"b), 7 24 SMA_ACCESS init ("111"b) 7 25 ) bit (3) internal static options (constant); 7 26 7 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 7 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 7 29 7 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 7 31 static options (constant); 7 32 7 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 7 34 static options (constant); 7 35 7 36 dcl ( 7 37 N_ACCESS_BIN init (00000b), 7 38 R_ACCESS_BIN init (01000b), 7 39 E_ACCESS_BIN init (00100b), 7 40 W_ACCESS_BIN init (00010b), 7 41 RW_ACCESS_BIN init (01010b), 7 42 RE_ACCESS_BIN init (01100b), 7 43 REW_ACCESS_BIN init (01110b), 7 44 S_ACCESS_BIN init (01000b), 7 45 M_ACCESS_BIN init (00010b), 7 46 A_ACCESS_BIN init (00001b), 7 47 SA_ACCESS_BIN init (01001b), 7 48 SM_ACCESS_BIN init (01010b), 7 49 SMA_ACCESS_BIN init (01011b) 7 50 ) fixed bin (5) internal static options (constant); 7 51 7 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 1921 1922 8 1 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 8 2 /* format: style2,^inddcls,idind32 */ 8 3 8 4 declare 1 terminate_file_switches based, 8 5 2 truncate bit (1) unaligned, 8 6 2 set_bc bit (1) unaligned, 8 7 2 terminate bit (1) unaligned, 8 8 2 force_write bit (1) unaligned, 8 9 2 delete bit (1) unaligned; 8 10 8 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 8 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 8 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 8 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 8 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 8 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 8 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 8 18 8 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 1923 1924 1925 end mlsys_address_mgr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/30/86 1343.8 mlsys_address_mgr_.pl1 >spec>install>1080>mlsys_address_mgr_.pl1 152 1 10/27/83 2104.2 mlsys_address_types.incl.pl1 >ldd>include>mlsys_address_types.incl.pl1 1911 2 10/27/83 2104.2 mlsys_copy_ptr.incl.pl1 >ldd>include>mlsys_copy_ptr.incl.pl1 1913 3 10/27/83 2104.2 mlsys_data.incl.pl1 >ldd>include>mlsys_data.incl.pl1 1915 4 06/30/86 1338.7 mlsys_internal_data.incl.pl1 >spec>install>1080>mlsys_internal_data.incl.pl1 1917 5 10/27/83 2104.2 mlsys_address_route.incl.pl1 >ldd>include>mlsys_address_route.incl.pl1 1919 6 10/27/83 2104.2 mlsys_address_list.incl.pl1 >ldd>include>mlsys_address_list.incl.pl1 1921 7 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1923 8 04/06/83 1239.4 terminate_file.incl.pl1 >ldd>include>terminate_file.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. ADDRESS_LIST_VERSION_2 000062 constant char(8) initial unaligned dcl 6-12 set ref 1240* 1243* 1382* 1384* 1552 ADDRESS_ROUTE_VERSION_1 000064 constant char(8) initial unaligned dcl 5-14 ref 630 1030 1075 1104 ADDRESS_VERSION_2 000232 constant char(8) initial unaligned dcl 177 ref 1707 1891 ANONYMOUS 000252 constant char(9) initial unaligned dcl 100 ref 418 465 517 925 COMPARISON_OPERATIONS 000066 constant fixed bin(17,0) initial array dcl 186 ref 1264 FOREIGN_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 643* 1030 1055 1075 1104 1193 1199 1217 1227 1612 1648 FORUM_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 583* INVALID_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 383* LOGBOX_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 454* 1147 LOWERCASE 000243 constant char(26) initial unaligned dcl 105 ref 650 1343 1343 MAILBOX_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 551* MAILING_LIST_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 711* 1601 MAIL_TABLE_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 679* 1208 1208 1213 1223 1479 1517 NAMED_GROUP_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 762* 1127 1557 1601 NULL_STRING 000255 constant char(1) initial unaligned dcl 102 set ref 1746 1817 1856 1897 1900 P_address_1_ptr parameter pointer dcl 60 set ref 1174 1177* 1182 1192* P_address_2_ptr parameter pointer dcl 61 set ref 1174 1178* 1182 1198* P_address_comment parameter varying char dcl 42 set ref 373 388* 397 434* 444 480* 489 532* 541 564* 573 607* 616 660* 669 690* 700 735* 745 770* 1160 1167* P_address_component parameter char unaligned dcl 48 set ref 700 715 728* 728 955 971* 978* 985* 992* 999* 1011* P_address_dirname parameter char unaligned dcl 46 set ref 489 511 541 553 573 585 700 713 955 968* 975* 982* 989* 996* 1008* P_address_ename parameter char unaligned dcl 47 set ref 489 513* 513 541 555* 555 573 587* 587* 587 591* 591 598* 700 715* 715 726* 727 955 970* 977* 984* 991* 998* 1010* P_address_list_ptr parameter pointer dcl 53 set ref 745 748* 764* 1540 1557* 1563* 1586* P_address_list_version parameter char(8) unaligned dcl 65 set ref 1540 1552 1557* 1581* P_address_name parameter varying char dcl 41 set ref 356 359* 364* 373 387* 397 420 421* 423 431* 444 467 468* 470 478* 489 519 520* 522 530* 541 563* 573 606* 616 659* 669 689* 700 734* 745 750 769* 1140 1147* 1151* 1152* P_address_ptr parameter pointer dcl 34 set ref 329 332 373 390* 397 437* 444 482* 489 534* 541 566* 573 609* 616 662* 669 693* 700 738* 745 773* 780 783* 785* 786* 856 859 859 868 871 871 873 873 873* 876* 884 887 887 889* 895 898* 912 915* 955 958* 1023 1026* 1048 1051* 1068 1071* 1097 1100* 1120 1123* 1140 1143* 1160 1163* 1472 1475* 1540 1543* 1609 1612 1612* 1687 1690* 1723* P_address_route_ptr parameter pointer dcl 51 set ref 616 630 630 648 652 653* 1023 1033* 1068 1075 1077* 1097 1107* P_address_route_version parameter char(8) unaligned dcl 58 ref 1023 1030 1097 1104 P_address_string parameter varying char dcl 44 set ref 373 385* 397 409* 444 456* 489 502* 616 620 645* 669 681* 688 912 921* 925* 931* 940* 944* P_address_type parameter fixed bin(17,0) dcl 56 set ref 895 902* P_code parameter fixed bin(35,0) dcl 35 set ref 373 391* 397 414* 438* 444 461* 483* 489 507* 535* 541 559* 567* 573 602* 610* 616 621* 626* 632* 663* 669 684* 694* 700 721* 739* 745 748* 751* 774* 780 783* 788* 895 898* 903* 912 915* 921* 925* 931* 935* 940* 944* 948* 955 958* 964* 972* 979* 986* 993* 1000* 1003* 1012* 1015* 1023 1026* 1034* 1036* 1038* 1040* 1048 1051* 1057* 1060* 1068 1071* 1085* 1087* 1089* 1097 1100* 1108* 1110* 1112* 1114* 1120 1123* 1129* 1132* 1140 1143* 1147* 1151* 1152* 1160 1163* 1167* 1174 1177* 1178* 1180* 1472 1475* 1480* 1490* 1540 1543* 1548* 1553* 1557* 1564* 1587* 1687 1690* P_default_mailbox_address parameter pointer dcl 37 set ref 341 344* P_display_list parameter bit(1) dcl 54 set ref 745 767 1120 1128* P_foreign_system parameter varying char(256) dcl 50 set ref 616 625 648* 650 1048 1056* P_logbox_address parameter pointer dcl 39 set ref 341 348* P_mail_table_address parameter pointer dcl 38 set ref 341 346* P_mail_table_address_ptr parameter pointer dcl 63 set ref 1472 1487* R_ACCESS 000305 constant bit(3) initial unaligned dcl 7-11 set ref 1364* 1367* 1575* SAVEBOX_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 500* 1147 TERM_FILE_TERM 000060 constant bit(3) initial unaligned dcl 8-14 set ref 1459* 1460* 1573* 1585* UPPERCASE 000234 constant char(26) initial unaligned dcl 105 ref 650 1343 1343 USER_MAILBOX_ADDRESS constant fixed bin(17,0) initial dcl 1-6 set ref 407* 1147 WAS_FOREIGN_ADDRESS 015346 constant fixed bin(17,0) initial dcl 154 ref 1195 1200 1219 1229 1651 1665 1725 actual_address_ptr 14 based pointer level 2 dcl 207 set ref 799* 1195 1200 1219 1229 1654 1667* 1725 addr builtin function dcl 146 ref 1525 1746 1817 1856 1897 1900 address_1_dirname 000115 automatic char(168) unaligned dcl 85 set ref 1281* 1285 1288* 1300* 1304 1310 1313* address_1_ename 000241 automatic char(32) unaligned dcl 86 set ref 1281* 1285 1288* 1300* 1304 1313* address_1_local_part based char unaligned dcl 1327 ref 1331 address_1_mls_ptr 000300 automatic pointer dcl 90 set ref 1185* 1364* 1371 1459 1459* 1461* address_1_mte_address_ptr 000270 automatic pointer dcl 88 set ref 1185* 1214* 1216 1447 1447* address_1_ptr 000102 automatic pointer dcl 72 set ref 1192* 1193 1193* 1195 1195* 1195 1208 1208 1213 1214* 1216* 1217 1217* 1219 1219* 1219 1237* 1237* 1240* 1240* 1244 1264 1275 1275 1281* 1300* 1331 1331 1335* 1357 1357 1357 1364 1364 1364 1382* address_1_route_ptr 000274 automatic pointer dcl 89 set ref 1185* 1335* 1339 1342 1343 1456 1456* address_1_text based char unaligned dcl 1273 ref 1275 address_2_dirname 000167 automatic char(168) unaligned dcl 85 set ref 1283* 1285 1289* 1302* 1304 1310 1314* address_2_ename 000251 automatic char(32) unaligned dcl 86 set ref 1283* 1285 1289* 1302* 1304 1314* address_2_local_part based char unaligned dcl 1329 ref 1331 address_2_mls_ptr 000302 automatic pointer dcl 90 set ref 1185* 1367* 1371 1460 1460* 1461* address_2_mte_address_ptr 000272 automatic pointer dcl 88 set ref 1185* 1224* 1226 1448 1448* address_2_ptr 000104 automatic pointer dcl 72 set ref 1198* 1199 1199* 1200 1200* 1200 1208 1208 1223 1224* 1226* 1227 1227* 1229 1229* 1229 1237* 1237* 1243* 1244* 1254* 1264 1275 1275 1283* 1302* 1331 1331 1336* 1357 1357 1357 1367 1367 1367 1384* address_2_route_ptr 000276 automatic pointer dcl 89 set ref 1185* 1336* 1339 1343 1457 1457* address_2_text based char unaligned dcl 1274 ref 1275 address_comment based char unaligned dcl 181 set ref 795 1167* address_header based structure level 1 dcl 161 set ref 801 address_list based structure level 1 dcl 6-6 in procedure "mlsys_address_mgr_" address_list 14 based pointer level 2 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" set ref 764* 765* 848* 1557 1563 1880* address_list_1_ptr 000304 automatic pointer dcl 91 set ref 1185* 1382* 1389 1392 1398 1401 1410 1463 1463* address_list_2_ptr 000306 automatic pointer dcl 91 set ref 1185* 1384* 1389 1392 1400 1401 1407 1409 1410 1464 1464* address_list_ptr 000336 automatic pointer dcl 6-14 set ref 1185* 1240* 1243* 1249 1253 1254 1450 1450* 1581* 1584* 1586 address_name based char unaligned dcl 179 set ref 793 1151* 1152* address_ptr 000332 automatic pointer dcl 150 set ref 376* 380 380* 385 385 387 387 388 388 390 400* 404 404* 409 409 412* 418 419 423 427 427 427 431 431 434 434 437 447* 451 451* 456 456 459* 465 466 470 474 474 474 478 478 480 480 482 493* 497 497* 502 502 505* 511 513 513 517 518 522 526 526 526 530 530 532 532 534 544* 548 548* 553 555 555 558* 563 563 564 564 566 576* 580 580* 585 587 587 587 591 591 600* 606 606 607 607 609 636* 640 640* 645 645 648 650 655 656 659 659 660 660 662 672* 676 676* 683* 688 689 689 690 690 693 704* 708 708* 713 715 715 719* 726 727 728 728 734 734 735 735 738 755* 759 759* 764 765 767 769 769 770 770 773 785* 790 790 793 793 793 793 795 795 795 795 797 799 801 801 801 801 804 804 804 804 807 810 814 818 822 826 830 830 830 830 833 833 835 835 837 840 844 848 850 902 919 921 921 921 925 925 931 931 940 940 940 944 962 968 968 970 975 975 977 982 984 989 991 996 998 1008 1010 1011 1030 1030 1033 1055 1056 1075 1078 1078 1080 1082 1084 1104 1104 1107 1127 1128 1147 1147 1147 1147 1147 1151 1151 1151 1152 1152 1152 1167 1167 1167 1479 1485 1547* 1557 1557 1563 1575 1575 1575 1723* 1725 1725* 1725 1814* 1817 1818 1819 1824 1824 1825 1828* 1832* 1836* 1838 1838 1841* 1844 1844 1847* 1850 1850 1853* 1856 1858 1859 1860 1860 1862 1865* 1868 1871* 1874 1874 1874 1877* 1880 1881 1891 1893 1895 1897 1898 1900 1901 1903 address_route based structure level 1 dcl 5-6 address_route_ptr 000334 automatic pointer dcl 5-16 set ref 653* 655 1077* 1080 1080 1082 1636* 1637* 1639 1640 1640* address_variable based char unaligned dcl 1743 set ref 1753 1754* addresses 10 based pointer array level 2 dcl 6-6 set ref 1254* 1401* 1401* 1410* 1410* baseno builtin function dcl 146 ref 1080 1704 binary builtin function dcl 146 ref 1080 1704 cleanup 000324 stack reference condition dcl 144 ref 378 402 449 495 546 578 638 674 706 757 1190 1571 code 000100 automatic fixed bin(35,0) dcl 70 set ref 409* 411 414 421* 422 456* 458 461 468* 469 502* 504 507 513* 520* 521 555* 559 587* 587* 591* 598* 598* 602 681* 682 684 715* 721 726* 728* 731 1214* 1215 1224* 1225 1240* 1243* 1246 1488* 1490 1513* 1514 1514* 1515 1529* 1575* 1577 1577 1577* 1579 1581* 1587 1637* 1639 1644* 1645 code_1 000313 automatic fixed bin(35,0) dcl 94 set ref 1288* 1291 1313* 1316 1335* 1339 1364* 1371 1382* 1386 code_2 000314 automatic fixed bin(35,0) dcl 94 set ref 1289* 1291 1314* 1316 1336* 1339 1367* 1371 1384* 1386 comment 10 based structure level 3 in structure "mail_table_address" dcl 299 in procedure "mlsys_address_mgr_" set ref 690* comment 10 based structure level 3 in structure "foreign_address" dcl 280 in procedure "mlsys_address_mgr_" set ref 660* comment 10 based structure level 3 in structure "forum_address" dcl 272 in procedure "mlsys_address_mgr_" set ref 607* comment 10 based structure level 4 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" set ref 532* comment 10 based structure level 4 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" set ref 480* comment 10 based structure level 3 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" set ref 388* comment 10 based structure level 3 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" set ref 770* comment 10 based structure level 4 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" set ref 434* comment 10 based structure level 2 in structure "address_header" dcl 161 in procedure "mlsys_address_mgr_" set ref 1676* 1676 comment 10 based structure level 3 in structure "mailing_list_address" dcl 308 in procedure "mlsys_address_mgr_" set ref 735* comment 10 based structure level 3 in structure "mailbox_address" dcl 264 in procedure "mlsys_address_mgr_" set ref 564* comment_lth 12 based fixed bin(21,0) level 3 dcl 161 set ref 795 795 1167 1167 1672 1672 1901* comment_ptr 10 based pointer level 3 dcl 161 set ref 795 1167 1672 1900* comparison_result 000114 automatic bit(1) dcl 84 set ref 1249* 1252* 1253 1254* 1258* 1291* 1293* 1295* 1316* 1318* 1320* 1341* 1342 1343* 1348* 1349* 1351* 1371* 1373* 1375 1389* 1392* 1397* 1398 1405* 1407 1414* 1418* 1431* 1437 current_mtle_ptr 000322 automatic pointer dcl 98 set ref 1484* 1524 1525* 1527 display_list 16 based bit(1) level 3 packed unaligned dcl 318 set ref 767* 1128 divide builtin function dcl 146 ref 1580 error_table_$entlong 000014 external static fixed bin(35,0) dcl 109 ref 1798 error_table_$id_not_found 000016 external static fixed bin(35,0) dcl 109 ref 1514 error_table_$no_component 000020 external static fixed bin(35,0) dcl 109 ref 1577 error_table_$noentry 000022 external static fixed bin(35,0) dcl 109 ref 1577 error_table_$smallarg 000024 external static fixed bin(35,0) dcl 109 ref 1773 error_table_$unimplemented_version 000026 external static fixed bin(35,0) dcl 109 ref 632 1036 1087 1110 1553 explicit_route 120 based pointer level 2 dcl 280 set ref 655* 656* 833 833* 1030 1033 1860* flags 36 based structure level 3 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" flags 13 based structure level 3 in structure "forum_address" dcl 272 in procedure "mlsys_address_mgr_" flags 16 based structure level 2 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" set ref 1881* flags 13 based structure level 3 in structure "mail_table_address" dcl 299 in procedure "mlsys_address_mgr_" flags 13 based structure level 3 in structure "mailbox_address" dcl 264 in procedure "mlsys_address_mgr_" flags 124 based structure level 2 in structure "foreign_address" dcl 280 in procedure "mlsys_address_mgr_" set ref 1862* flags 13 based structure level 3 in structure "foreign_address" dcl 280 in procedure "mlsys_address_mgr_" flags 13 based structure level 4 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" flags 17 based structure level 2 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" set ref 1819* flags 13 based structure level 4 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" flags 13 based structure level 3 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" flags 13 based structure level 3 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" flags 36 based structure level 3 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" flags 36 based structure level 2 in structure "user_address_template" dcl 231 in procedure "mlsys_address_mgr_" set ref 1825* flags 13 based structure level 3 in structure "mailing_list_address" dcl 308 in procedure "mlsys_address_mgr_" flags 36 based structure level 3 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" flags 13 based structure level 4 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" flags 13 based structure level 2 in structure "address_header" dcl 161 in procedure "mlsys_address_mgr_" set ref 1903* foreign_address based structure level 1 dcl 280 set ref 801 837 1853 foreign_address_local_part based char unaligned dcl 292 set ref 830 940* foreign_local_part based char unaligned dcl 1625 set ref 1644* 1645 1663 foreign_system 17 based varying char(256) level 2 dcl 280 set ref 648* 650* 1056 1859* forum_$close_forum 000066 constant entry external dcl 118 ref 1452 1453 forum_$open_forum 000070 constant entry external dcl 119 ref 1313 1314 forum_1_index 000315 automatic fixed bin(17,0) dcl 95 set ref 1188* 1313* 1316 1452 1452* 1454* forum_2_index 000316 automatic fixed bin(17,0) dcl 95 set ref 1188* 1314* 1316 1453 1453* 1454* forum_address based structure level 1 dcl 272 set ref 826 1847 forum_dirname 14 based char(168) level 2 packed unaligned dcl 272 set ref 585* 591 996 1850* forum_ename 66 based char(32) level 2 packed unaligned dcl 272 set ref 587* 587* 587* 591* 998 1850* free_comment 13(02) based bit(1) level 4 in structure "foreign_address" packed unaligned dcl 280 in procedure "mlsys_address_mgr_" set ref 660* free_comment 13(02) based bit(1) level 3 in structure "address_header" packed unaligned dcl 161 in procedure "mlsys_address_mgr_" set ref 795 1672 1677* free_comment 13(02) based bit(1) level 4 in structure "forum_address" packed unaligned dcl 272 in procedure "mlsys_address_mgr_" set ref 607* free_comment 13(02) based bit(1) level 5 in structure "logbox_address" packed unaligned dcl 250 in procedure "mlsys_address_mgr_" set ref 480* free_comment 13(02) based bit(1) level 4 in structure "mailbox_address" packed unaligned dcl 264 in procedure "mlsys_address_mgr_" set ref 564* free_comment 13(02) based bit(1) level 4 in structure "invalid_address" packed unaligned dcl 217 in procedure "mlsys_address_mgr_" set ref 388* free_comment 13(02) based bit(1) level 4 in structure "mailing_list_address" packed unaligned dcl 308 in procedure "mlsys_address_mgr_" set ref 735* free_comment 13(02) based bit(1) level 5 in structure "savebox_address" packed unaligned dcl 256 in procedure "mlsys_address_mgr_" set ref 532* free_comment 13(02) based bit(1) level 5 in structure "user_mailbox_address" packed unaligned dcl 243 in procedure "mlsys_address_mgr_" set ref 434* free_comment 13(02) based bit(1) level 4 in structure "named_group_address" packed unaligned dcl 318 in procedure "mlsys_address_mgr_" set ref 770* free_comment 13(02) based bit(1) level 4 in structure "mail_table_address" packed unaligned dcl 299 in procedure "mlsys_address_mgr_" set ref 690* free_local_part 124 based bit(1) level 3 packed unaligned dcl 280 set ref 645* 830 1663 free_name 13(01) based bit(1) level 5 in structure "logbox_address" packed unaligned dcl 250 in procedure "mlsys_address_mgr_" set ref 478* free_name 13(01) based bit(1) level 5 in structure "savebox_address" packed unaligned dcl 256 in procedure "mlsys_address_mgr_" set ref 530* free_name 13(01) based bit(1) level 4 in structure "foreign_address" packed unaligned dcl 280 in procedure "mlsys_address_mgr_" set ref 659* free_name 13(01) based bit(1) level 4 in structure "invalid_address" packed unaligned dcl 217 in procedure "mlsys_address_mgr_" set ref 387* free_name 13(01) based bit(1) level 4 in structure "mail_table_address" packed unaligned dcl 299 in procedure "mlsys_address_mgr_" set ref 364* 689* free_name 13(01) based bit(1) level 4 in structure "forum_address" packed unaligned dcl 272 in procedure "mlsys_address_mgr_" set ref 606* free_name 13(01) based bit(1) level 4 in structure "mailbox_address" packed unaligned dcl 264 in procedure "mlsys_address_mgr_" set ref 563* free_name 13(01) based bit(1) level 4 in structure "mailing_list_address" packed unaligned dcl 308 in procedure "mlsys_address_mgr_" set ref 734* free_name 13(01) based bit(1) level 3 in structure "address_header" packed unaligned dcl 161 in procedure "mlsys_address_mgr_" set ref 793 1671 1677* free_name 13(01) based bit(1) level 4 in structure "named_group_address" packed unaligned dcl 318 in procedure "mlsys_address_mgr_" set ref 769* free_name 13(01) based bit(1) level 5 in structure "user_mailbox_address" packed unaligned dcl 243 in procedure "mlsys_address_mgr_" set ref 359* 431* free_text 17 based bit(1) level 3 packed unaligned dcl 217 set ref 385* 804 header based structure level 2 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" header based structure level 3 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "foreign_address" dcl 280 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "mailbox_address" dcl 264 in procedure "mlsys_address_mgr_" header based structure level 3 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "mail_table_address" dcl 299 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "forum_address" dcl 272 in procedure "mlsys_address_mgr_" header based structure level 3 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "mailing_list_address" dcl 308 in procedure "mlsys_address_mgr_" header based structure level 2 in structure "address_route" dcl 5-6 in procedure "mlsys_address_mgr_" idx 000317 automatic fixed bin(17,0) dcl 96 set ref 1253* 1254* 1342* 1343 1343* 1398* 1401* 1407* 1410* implicit_route 122 based pointer level 2 dcl 280 set ref 835 835* 1078 1078* 1080* 1082* 1084* 1104 1107 1860* index builtin function dcl 146 ref 1795 initiate_file_$component 000072 constant entry external dcl 120 ref 1364 1367 1575 invalid_address based structure level 1 dcl 217 set ref 807 1814 invalid_address_text based char unaligned dcl 226 set ref 804 921* is_anonymous 36 based bit(1) level 4 in structure "user_mailbox_address" packed unaligned dcl 243 in procedure "mlsys_address_mgr_" set ref 419* 427* is_anonymous 36 based bit(1) level 4 in structure "logbox_address" packed unaligned dcl 250 in procedure "mlsys_address_mgr_" set ref 466* 474* is_anonymous 36 based bit(1) level 4 in structure "savebox_address" packed unaligned dcl 256 in procedure "mlsys_address_mgr_" set ref 518* 526* is_anonymous 36 based bit(1) level 3 in structure "user_address_template" packed unaligned dcl 231 in procedure "mlsys_address_mgr_" set ref 925 1147 jdx 000320 automatic fixed bin(17,0) dcl 96 set ref 1400* 1401* 1409* 1410* length builtin function dcl 146 ref 1752 1773 1798 1798 local_mtle 000102 automatic structure level 1 dcl 1510 set ref 1525 local_part 14 based structure level 2 dcl 280 set ref 645* local_part_lth 16 based fixed bin(21,0) level 3 dcl 280 set ref 830 830 940 940 1331 1331 1644 1644 1645 1663 1663 1858* local_part_ptr 14 based pointer level 3 dcl 280 set ref 830 940 1331 1331 1644 1645 1663 1856* logbox_address based structure level 1 dcl 250 set ref 814 1832 mail_table_$get 000074 constant entry external dcl 122 ref 1513 mail_table_address based structure level 1 dcl 299 set ref 840 1865 mail_table_address_ptr 000106 automatic pointer dcl 74 set ref 1487 1513* 1517 1520 1521* mailbox_$get_uid_file 000076 constant entry external dcl 123 ref 1288 1289 mailbox_1_uid 000310 automatic bit(36) dcl 92 set ref 1288* 1291 mailbox_2_uid 000311 automatic bit(36) dcl 92 set ref 1289* 1291 mailbox_address based structure level 1 dcl 264 set ref 822 1841 mailing_list_address based structure level 1 dcl 308 set ref 844 1871 maxlength builtin function dcl 146 ref 1773 mbx_dirname 37 based char(168) level 2 in structure "savebox_address" packed unaligned dcl 256 in procedure "mlsys_address_mgr_" set ref 511* 982 1838* mbx_dirname 14 based char(168) level 2 in structure "mailbox_address" packed unaligned dcl 264 in procedure "mlsys_address_mgr_" set ref 553* 989 1844* mbx_ename 111 based char(32) level 2 in structure "savebox_address" packed unaligned dcl 256 in procedure "mlsys_address_mgr_" set ref 513* 513* 984 1838* mbx_ename 66 based char(32) level 2 in structure "mailbox_address" packed unaligned dcl 264 in procedure "mlsys_address_mgr_" set ref 555* 555* 991 1844* mls_bitcount 000112 automatic fixed bin(24,0) dcl 81 set ref 1575* 1580 mls_component 76 based char(32) level 2 packed unaligned dcl 308 set ref 728* 728* 1011 1357 1357 1364* 1367* 1575* 1874* mls_dirname 14 based char(168) level 2 packed unaligned dcl 308 set ref 713* 1008 1357 1357 1364* 1367* 1575* 1874* mls_ename 66 based char(32) level 2 packed unaligned dcl 308 set ref 715* 715* 726* 727* 1010 1357 1357 1364* 1367* 1575* 1874* mls_lth 000113 automatic fixed bin(21,0) dcl 82 set ref 1580* 1581 1581 mls_ptr 000110 automatic pointer dcl 80 set ref 1570* 1573 1573* 1575* 1581 1585 1585* mls_text based char unaligned dcl 79 set ref 1581* mlsys_address_list_mgr_$create_user_freeable_address_list 000100 constant entry external dcl 124 ref 1557 mlsys_address_list_mgr_$decrement_reference_count 000102 constant entry external dcl 125 ref 848 mlsys_address_list_mgr_$free_address_list 000104 constant entry external dcl 126 ref 1450 1463 1464 mlsys_address_list_mgr_$increment_reference_count 000106 constant entry external dcl 127 ref 765 mlsys_address_list_mgr_$verify_address_list 000110 constant entry external dcl 128 ref 748 mlsys_address_route_mgr_$compute_optimum_route 000112 constant entry external dcl 129 ref 1335 1336 1637 mlsys_address_route_mgr_$create_address_route 000114 constant entry external dcl 130 ref 655 1082 mlsys_address_route_mgr_$decrement_reference_count 000116 constant entry external dcl 131 ref 833 835 1078 mlsys_address_route_mgr_$free_address_route 000120 constant entry external dcl 132 ref 1456 1457 1640 mlsys_address_route_mgr_$increment_reference_count 000122 constant entry external dcl 133 ref 656 1084 mlsys_area based area(1024) dcl 4-61 ref 793 795 801 804 807 810 814 818 822 826 830 837 840 844 850 1663 1671 1672 1753 1814 1828 1832 1836 1841 1847 1853 1865 1871 1877 mlsys_data_$person_id 000160 external static varying char(24) dcl 4-70 ref 427 474 526 mlsys_data_$project_id 000162 external static varying char(12) dcl 4-71 ref 427 474 526 mlsys_data_$subsystem_area_ptr 000154 external static pointer dcl 4-62 ref 793 795 801 804 807 810 814 818 822 826 830 837 840 844 850 1663 1671 1672 1753 1814 1828 1832 1836 1841 1847 1853 1865 1871 1877 mlsys_data_$user_default_mailbox_address 000144 external static pointer dcl 3-12 ref 344 359 359 359 mlsys_data_$user_is_anonymous 000156 external static bit(1) dcl 4-68 ref 427 474 526 mlsys_data_$user_logbox_address 000150 external static pointer dcl 3-15 ref 348 mlsys_data_$user_mail_table_address 000146 external static pointer dcl 3-14 ref 346 364 364 364 mlsys_data_$valid_segments 000152 external static bit(1) array unaligned dcl 4-56 ref 1080 1704 mlsys_et_$circular_mtes 000030 external static fixed bin(35,0) dcl 109 ref 1529 mlsys_et_$incorrect_suffix 000032 external static fixed bin(35,0) dcl 109 ref 598 1795 mlsys_et_$mte_not_found 000034 external static fixed bin(35,0) dcl 109 ref 1514 mlsys_et_$no_address_pathname 000036 external static fixed bin(35,0) dcl 109 ref 964 1003 1015 mlsys_et_$no_address_route 000040 external static fixed bin(35,0) dcl 109 ref 1038 1112 mlsys_et_$no_address_string 000042 external static fixed bin(35,0) dcl 109 ref 935 948 mlsys_et_$no_mailing_list 000044 external static fixed bin(35,0) dcl 109 ref 1577 mlsys_et_$not_address 000046 external static fixed bin(35,0) dcl 109 ref 1702 1704 1707 mlsys_et_$not_foreign_address 000050 external static fixed bin(35,0) dcl 109 ref 1040 1060 1089 1114 mlsys_et_$not_list_address 000052 external static fixed bin(35,0) dcl 109 ref 1548 mlsys_et_$not_mail_table_address 000054 external static fixed bin(35,0) dcl 109 ref 1480 mlsys_et_$not_named_group_address 000056 external static fixed bin(35,0) dcl 109 ref 1132 mlsys_et_$null_foreign_address 000060 external static fixed bin(35,0) dcl 109 ref 621 mlsys_et_$null_named_group_name 000062 external static fixed bin(35,0) dcl 109 ref 751 mlsys_et_$unknown_system 000064 external static fixed bin(35,0) dcl 109 ref 626 mlsys_nit_interface_$get_fully_qualified_name 000124 constant entry external dcl 134 ref 648 mlsys_parse_text_$parse_address_text 000126 constant entry external dcl 135 ref 1644 mlsys_parse_text_$parse_mailing_list_text 000130 constant entry external dcl 136 ref 1581 mlsys_psp_$forum_not_available 000132 constant entry external dcl 137 ref 591 1307 mlsys_user_mte_syntax_$validate_mte_name 000134 constant entry external dcl 138 ref 681 mlsys_user_mte_syntax_$validate_person_id 000136 constant entry external dcl 139 ref 421 468 520 mlsys_user_mte_syntax_$validate_user_id 000140 constant entry external dcl 140 ref 409 456 502 mte_name 14 based varying char(32) level 2 dcl 299 set ref 688* 944 1208 1208 1485* 1520 1868* mtle based structure level 1 dcl 1505 mtle_ptr 000100 automatic pointer dcl 1508 set ref 1527* 1527* 1528* 1532 n_addresses 6 based fixed bin(17,0) level 2 dcl 6-6 ref 1249 1253 1389 1389 1392 1392 1398 1400 1407 1409 n_relays 6 based fixed bin(17,0) level 3 dcl 5-6 ref 655 1082 1339 1339 1342 name 2 000102 automatic varying char(32) level 2 in structure "local_mtle" dcl 1510 in procedure "lookup_mail_table_entry" set ref 1523* name 4 based structure level 4 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" set ref 530* name 2 based varying char(32) level 2 in structure "mtle" dcl 1505 in procedure "lookup_mail_table_entry" ref 1528 name 4 based structure level 3 in structure "mail_table_address" dcl 299 in procedure "mlsys_address_mgr_" set ref 364* 689* name 4 based structure level 3 in structure "mailing_list_address" dcl 308 in procedure "mlsys_address_mgr_" set ref 734* name 4 based structure level 3 in structure "mailbox_address" dcl 264 in procedure "mlsys_address_mgr_" set ref 563* name 4 based structure level 3 in structure "named_group_address" dcl 318 in procedure "mlsys_address_mgr_" set ref 769* name 4 based structure level 3 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" set ref 387* name 4 based structure level 3 in structure "forum_address" dcl 272 in procedure "mlsys_address_mgr_" set ref 606* name 4 based structure level 2 in structure "address_header" dcl 161 in procedure "mlsys_address_mgr_" set ref 1675* 1675 name 4 based structure level 4 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" set ref 478* name 4 based structure level 3 in structure "foreign_address" dcl 280 in procedure "mlsys_address_mgr_" set ref 659* name 4 based structure level 4 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" set ref 359* 431* name_lth 6 based fixed bin(21,0) level 5 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" set ref 359 name_lth 6 based fixed bin(21,0) level 3 in structure "address_header" dcl 161 in procedure "mlsys_address_mgr_" set ref 793 793 1151 1151 1152 1152 1671 1671 1898* name_lth 6 based fixed bin(21,0) level 4 in structure "mail_table_address" dcl 299 in procedure "mlsys_address_mgr_" set ref 364 name_ptr 4 based pointer level 3 dcl 161 set ref 793 1151 1152 1671 1897* named_group_address based structure level 1 dcl 318 set ref 850 1877 never_free 13 based bit(1) level 3 packed unaligned dcl 161 set ref 332* 790 873 new_address_comment based char unaligned dcl 1629 ref 1672 new_address_name based char unaligned dcl 1627 ref 1671 new_address_ptr 000102 automatic pointer dcl 1631 set ref 1644* 1645* 1648 1650* 1651 1654 1656* 1657* 1667 1668* 1671 1671 1671 1671 1672 1672 1672 1672 1675 1676 1677 1677 new_new_address_ptr 000104 automatic pointer dcl 1631 set ref 1654* 1655* 1657 1659* 1661* 1668 next_mte_name 000115 automatic varying char(32) dcl 1511 set ref 1520* 1528 1534* null builtin function dcl 146 ref 376 380 400 404 447 451 493 497 544 548 576 580 630 636 640 648 652 672 676 704 708 755 759 786 833 835 876 889 1030 1078 1104 1185 1447 1448 1450 1456 1457 1459 1460 1461 1463 1464 1484 1527 1557 1570 1573 1584 1585 1636 1639 1640 1659 1661 1668 1702 1860 1880 old_address_ptr 000100 automatic pointer dcl 1631 set ref 1634* 1637* 1644 1644 1644 1645 1645 1663 1663 1663 1663 1665 1667 1675 1676 p_actual_ename parameter char unaligned dcl 1790 ref 1787 1798 p_address_ptr parameter pointer dcl 1623 in procedure "check_if_actually_local" set ref 1620 1634* p_address_ptr parameter pointer dcl 1599 in procedure "is_list_address" ref 1596 1601 1601 p_address_ptr parameter pointer dcl 1699 in procedure "verify_address" ref 1696 1702 1704 1707 p_address_type parameter fixed bin(17,0) dcl 1810 ref 1807 1812 1893 p_address_variable parameter structure level 1 dcl 1738 set ref 1734 p_code parameter fixed bin(35,0) dcl 1700 in procedure "verify_address" set ref 1696 1702* 1704* 1707* 1710* 1712 p_code parameter fixed bin(35,0) dcl 1791 in procedure "validate_entryname" set ref 1787 1793* 1795* 1798 1798* 1801 p_code parameter fixed bin(35,0) dcl 1771 in procedure "set_output_variable" set ref 1766 1773* 1778* p_ename parameter char unaligned dcl 1790 ref 1787 1795 1798 p_free_address_variable parameter bit(1) unaligned dcl 1741 set ref 1734 1748* 1755* p_input_value parameter varying char dcl 1737 ref 1734 1745 1752 1754 p_mte_name parameter varying char(32) dcl 1503 set ref 1500 1513* 1523 p_output_parameter parameter varying char dcl 1770 set ref 1766 1773 1777* p_output_value parameter char unaligned dcl 1769 ref 1766 1773 1777 p_pointer parameter pointer dcl 2-13 ref 2-10 2-16 p_result parameter bit(1) dcl 1427 ref 1424 1431 p_suffix parameter char unaligned dcl 1790 ref 1787 1795 1795 partial_comparison_result 000312 automatic bit(1) dcl 93 set ref 1399* 1400 1401* 1405 1408* 1409 1410* 1414 person_id 14 based varying char(32) level 2 in structure "user_address_template" dcl 231 in procedure "mlsys_address_mgr_" set ref 931 1147 1824* person_id 14 based varying char(32) level 3 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" set ref 409* 418 423* 427 968 970 person_id 14 based varying char(32) level 3 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" set ref 456* 465 470* 474 975 977 person_id 14 based varying char(32) level 3 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" set ref 502* 517 522* 526 previous_mtle_ptr based pointer level 2 in structure "mtle" dcl 1505 in procedure "lookup_mail_table_entry" ref 1532 previous_mtle_ptr 000102 automatic pointer level 2 in structure "local_mtle" dcl 1510 in procedure "lookup_mail_table_entry" set ref 1524* project_id 25 based varying char(32) level 3 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" set ref 502* 526 project_id 25 based varying char(32) level 3 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" set ref 456* 474 975 project_id 25 based varying char(32) level 2 in structure "user_address_template" dcl 231 in procedure "mlsys_address_mgr_" set ref 925 931 1824* project_id 25 based varying char(32) level 3 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" set ref 409* 427 968 reference_count 3 based fixed bin(17,0) level 2 dcl 161 set ref 790 859* 859 871* 871 873 887* 887 1895* relays 7 based varying char(256) array level 2 dcl 5-6 set ref 655* 1082* 1343 1343 return_value 000100 automatic pointer dcl 2-14 set ref 2-16* 2-18 reverse builtin function dcl 146 ref 1795 1795 rtrim builtin function dcl 146 ref 1795 1798 savebox_address based structure level 1 dcl 256 set ref 818 1836 size builtin function dcl 146 ref 801 801 801 string builtin function dcl 146 set ref 1819* 1825* 1862* 1881* 1903* suffixless_forum_ename 000261 automatic char(26) unaligned dcl 87 set ref 591* 598* terminate_file_ 000142 constant entry external dcl 142 ref 1459 1460 1573 1585 text 14 based structure level 2 dcl 217 set ref 385* text_lth 16 based fixed bin(21,0) level 3 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" set ref 804 804 921 921 1275 1275 1818* text_lth 2 parameter fixed bin(21,0) level 2 in structure "p_address_variable" dcl 1738 in procedure "set_address_variable_string" set ref 1747* 1752* 1753 1753 1754 text_ptr 14 based pointer level 3 in structure "invalid_address" dcl 217 in procedure "mlsys_address_mgr_" set ref 804 921 1275 1275 1817* text_ptr parameter pointer level 2 in structure "p_address_variable" dcl 1738 in procedure "set_address_variable_string" set ref 1746* 1753* 1754 translate builtin function dcl 146 ref 650 1343 1343 type 2 based fixed bin(17,0) level 2 dcl 161 set ref 797 902 919 962 1030 1055 1075 1104 1127 1147 1147 1147 1193 1195 1199 1200 1208 1208 1213 1217 1219 1223 1227 1229 1264 1264 1479 1517 1557 1601 1601 1612 1648 1651 1665* 1725 1893* user based structure level 2 in structure "savebox_address" dcl 256 in procedure "mlsys_address_mgr_" user based structure level 2 in structure "user_mailbox_address" dcl 243 in procedure "mlsys_address_mgr_" user based structure level 2 in structure "logbox_address" dcl 250 in procedure "mlsys_address_mgr_" user_address_template based structure level 1 dcl 231 user_mailbox_address based structure level 1 dcl 243 set ref 810 1828 version based char(8) level 3 in structure "address_route" packed unaligned dcl 5-6 in procedure "mlsys_address_mgr_" ref 630 1075 version based char(8) level 2 in structure "address_header" packed unaligned dcl 161 in procedure "mlsys_address_mgr_" set ref 1707 1891* was_foreign_address based structure level 1 dcl 207 set ref 801 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 7-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 7-33 E_ACCESS internal static bit(3) initial unaligned dcl 7-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 M_ACCESS internal static bit(3) initial unaligned dcl 7-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 N_ACCESS internal static bit(3) initial unaligned dcl 7-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 REW_ACCESS internal static bit(3) initial unaligned dcl 7-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 RE_ACCESS internal static bit(3) initial unaligned dcl 7-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 RW_ACCESS internal static bit(3) initial unaligned dcl 7-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 SA_ACCESS internal static bit(3) initial unaligned dcl 7-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 7-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 7-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 SM_ACCESS internal static bit(3) initial unaligned dcl 7-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 S_ACCESS internal static bit(3) initial unaligned dcl 7-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 TERM_FILE_BC internal static bit(2) initial unaligned dcl 8-12 TERM_FILE_DELETE internal static bit(5) initial unaligned dcl 8-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial unaligned dcl 8-16 TERM_FILE_TRUNC internal static bit(1) initial unaligned dcl 8-11 TERM_FILE_TRUNC_BC internal static bit(2) initial unaligned dcl 8-13 TERM_FILE_TRUNC_BC_TERM internal static bit(3) initial unaligned dcl 8-15 W_ACCESS internal static bit(3) initial unaligned dcl 7-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 7-36 address_list_n_addresses automatic fixed bin(17,0) dcl 6-16 address_route_n_relays automatic fixed bin(17,0) dcl 5-18 mlsys_data_$address_list_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$domains_available external static fixed bin(1,0) dcl 4-44 mlsys_data_$forum_not_available external static fixed bin(1,0) dcl 4-44 mlsys_data_$hash_tables_segment_ptr external static pointer dcl 4-64 mlsys_data_$highest_usable_ring external static fixed bin(3,0) dcl 4-49 mlsys_data_$ism_not_available external static fixed bin(1,0) dcl 4-44 mlsys_data_$lowest_forum_ring external static fixed bin(3,0) dcl 4-49 mlsys_data_$mailbox_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$max_lock_wait_retries external static fixed bin(17,0) dcl 4-19 mlsys_data_$max_opening_retries external static fixed bin(17,0) dcl 4-16 mlsys_data_$message_body_sections_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$message_redistributions_list_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$message_references_list_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$message_user_fields_allocation external static fixed bin(17,0) dcl 4-33 mlsys_data_$subsystem_ring external static fixed bin(3,0) dcl 4-49 mlsys_data_$system_directory external static char(168) unaligned dcl 3-7 mlsys_data_$temp_segment_list_ptr external static pointer dcl 4-54 mlsys_data_$transmit_cache_ptr external static pointer dcl 4-66 mlsys_data_$user_id external static varying char(32) dcl 4-72 terminate_file_switches based structure level 1 packed unaligned dcl 8-4 NAMES DECLARED BY EXPLICIT CONTEXT. BAD_FORUM_ADDRESS 003061 constant label dcl 600 ref 591 BAD_LOGBOX_ADDRESS 001425 constant label dcl 459 ref 469 BAD_MAILING_LIST_ADDRESS 004213 constant label dcl 719 ref 731 BAD_SAVEBOX_ADDRESS 001760 constant label dcl 505 ref 513 521 BAD_USER_MAILBOX_ADDRESS 001106 constant label dcl 412 ref 422 COMPARE_ADDRESSES 000037 constant label array(-1:5) dcl 1267 ref 1264 FREE_ADDRESS 000000 constant label array(-1:9) dcl 799 ref 797 GET_ADDRESS_PATHNAME 000025 constant label array(0:9) dcl 964 set ref 962 GET_ADDRESS_STRING 000013 constant label array(0:9) dcl 921 ref 919 INITIALIZE_ADDRESS 000046 constant label array(0:9) dcl 1814 ref 1812 INITIALIZE_USER_MAILBOX_COMMON 014444 constant label dcl 1822 ref 1830 1834 1839 RETURN_FROM_COMPARE_ADDRESSES 012161 constant label dcl 1437 ref 1433 RETURN_FROM_GET_MAIL_TABLE_ADDRESS 012270 constant label dcl 1490 ref 1515 1530 check_if_actually_local 012670 constant entry external dcl 1609 check_if_actually_local 013473 constant entry internal dcl 1620 in procedure "mlsys_address_mgr_" ref 1193 1199 1217 1227 1612 1650 cleanup_address_comparison 013005 constant entry internal dcl 1444 ref 1190 1429 compare_addresses 010224 constant entry external dcl 1174 ref 1254 1401 1410 copy_ptr 014775 constant entry internal dcl 2-10 ref 653 764 785 1077 1192 1198 1634 1723 create_foreign_address 003170 constant entry external dcl 616 create_forum_address 002521 constant entry external dcl 573 create_invalid_address 000572 constant entry external dcl 373 ref 1645 create_logbox_address 001305 constant entry external dcl 444 create_mail_table_address 003570 constant entry external dcl 669 create_mailbox_address 002241 constant entry external dcl 541 create_mailing_list_address 004021 constant entry external dcl 700 create_named_group_address 004442 constant entry external dcl 745 create_savebox_address 001630 constant entry external dcl 489 create_user_mailbox_address 000766 constant entry external dcl 397 decrement_reference_count 005575 constant entry external dcl 868 ref 799 decrement_reference_count_no_free 005644 constant entry external dcl 884 expand_list_address 012303 constant entry external dcl 1540 ref 1240 1243 1382 1384 free_address 004711 constant entry external dcl 780 ref 380 404 412 451 459 497 505 548 558 580 600 640 676 683 708 719 759 873 1447 1448 1521 1656 get_address_comment 010116 constant entry external dcl 1160 get_address_explicit_route 007113 constant entry external dcl 1023 get_address_implicit_route 007520 constant entry external dcl 1097 get_address_name 007723 constant entry external dcl 1140 get_address_pathname 006334 constant entry external dcl 955 ref 1281 1283 1300 1302 get_address_string 005760 constant entry external dcl 912 get_address_system 007226 constant entry external dcl 1048 get_address_type 005677 constant entry external dcl 895 get_mail_table_address 012175 constant entry external dcl 1472 ref 1214 1224 get_named_group_display_flag 007633 constant entry external dcl 1120 get_users_addresses 000427 constant entry external dcl 341 increment_reference_count 005547 constant entry external dcl 856 ref 1655 1668 initialize_address 014412 constant entry internal dcl 1807 ref 383 407 454 500 551 583 643 679 711 762 initialize_header 014751 constant entry internal dcl 1888 ref 1816 1822 1843 1849 1855 1867 1873 1879 is_list_address 013455 constant entry internal dcl 1596 ref 1237 1237 1237 1237 1240 1547 lookup_mail_table_entry 013304 constant entry internal dcl 1500 ref 1485 1534 mlsys_address_mgr_ 000356 constant entry external dcl 26 protect_address 000376 constant entry external dcl 329 return_comparison_result 012771 constant entry internal dcl 1424 ref 1208 1215 1225 1246 1258 1267 1275 1285 1295 1304 1307 1310 1320 1331 1351 1357 1375 1386 1418 set_address_implicit_route 007322 constant entry external dcl 1068 set_address_ptr 014123 constant entry internal dcl 1720 ref 900 917 960 1028 1053 1073 1102 1125 1145 1165 1477 1545 set_address_variable_string 014143 constant entry internal dcl 1734 ref 359 364 385 387 388 431 434 478 480 530 532 563 564 606 607 645 659 660 689 690 734 735 769 770 set_output_variable 014240 constant entry internal dcl 1766 ref 921 925 931 940 944 1147 1151 1152 1167 set_users_full_name 000463 constant entry external dcl 356 validate_entryname 014303 constant entry internal dcl 1787 ref 513 555 587 587 591 598 715 726 728 verify_address 014057 constant entry internal dcl 1696 in procedure "mlsys_address_mgr_" ref 783 898 915 958 1026 1051 1071 1100 1123 1143 1163 1177 1178 1475 1543 1690 verify_address 012730 constant entry external dcl 1687 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 17126 17312 15361 17136 Length 20214 15361 164 665 1545 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mlsys_address_mgr_ 498 external procedure is an external procedure. on unit on line 378 72 on unit on unit on line 402 72 on unit on unit on line 449 72 on unit on unit on line 495 72 on unit on unit on line 546 72 on unit on unit on line 578 72 on unit on unit on line 638 72 on unit on unit on line 674 72 on unit on unit on line 706 72 on unit on unit on line 757 72 on unit on unit on line 1190 64 on unit begin block on line 1271 begin block shares stack frame of external procedure mlsys_address_mgr_. begin block on line 1325 begin block shares stack frame of external procedure mlsys_address_mgr_. return_comparison_result internal procedure shares stack frame of external procedure mlsys_address_mgr_. cleanup_address_comparison 92 internal procedure is called by several nonquick procedures. lookup_mail_table_entry 147 internal procedure calls itself recursively. on unit on line 1571 84 on unit is_list_address internal procedure shares stack frame of external procedure mlsys_address_mgr_. check_if_actually_local 124 internal procedure calls itself recursively. verify_address internal procedure shares stack frame of external procedure mlsys_address_mgr_. set_address_ptr internal procedure shares stack frame of external procedure mlsys_address_mgr_. set_address_variable_string internal procedure shares stack frame of external procedure mlsys_address_mgr_. set_output_variable 66 internal procedure is called during a stack extension. validate_entryname internal procedure shares stack frame of external procedure mlsys_address_mgr_. initialize_address internal procedure shares stack frame of external procedure mlsys_address_mgr_. initialize_header internal procedure shares stack frame of external procedure mlsys_address_mgr_. copy_ptr 65 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME check_if_actually_local 000100 old_address_ptr check_if_actually_local 000102 new_address_ptr check_if_actually_local 000104 new_new_address_ptr check_if_actually_local copy_ptr 000100 return_value copy_ptr lookup_mail_table_entry 000100 mtle_ptr lookup_mail_table_entry 000102 local_mtle lookup_mail_table_entry 000115 next_mte_name lookup_mail_table_entry mlsys_address_mgr_ 000100 code mlsys_address_mgr_ 000102 address_1_ptr mlsys_address_mgr_ 000104 address_2_ptr mlsys_address_mgr_ 000106 mail_table_address_ptr mlsys_address_mgr_ 000110 mls_ptr mlsys_address_mgr_ 000112 mls_bitcount mlsys_address_mgr_ 000113 mls_lth mlsys_address_mgr_ 000114 comparison_result mlsys_address_mgr_ 000115 address_1_dirname mlsys_address_mgr_ 000167 address_2_dirname mlsys_address_mgr_ 000241 address_1_ename mlsys_address_mgr_ 000251 address_2_ename mlsys_address_mgr_ 000261 suffixless_forum_ename mlsys_address_mgr_ 000270 address_1_mte_address_ptr mlsys_address_mgr_ 000272 address_2_mte_address_ptr mlsys_address_mgr_ 000274 address_1_route_ptr mlsys_address_mgr_ 000276 address_2_route_ptr mlsys_address_mgr_ 000300 address_1_mls_ptr mlsys_address_mgr_ 000302 address_2_mls_ptr mlsys_address_mgr_ 000304 address_list_1_ptr mlsys_address_mgr_ 000306 address_list_2_ptr mlsys_address_mgr_ 000310 mailbox_1_uid mlsys_address_mgr_ 000311 mailbox_2_uid mlsys_address_mgr_ 000312 partial_comparison_result mlsys_address_mgr_ 000313 code_1 mlsys_address_mgr_ 000314 code_2 mlsys_address_mgr_ 000315 forum_1_index mlsys_address_mgr_ 000316 forum_2_index mlsys_address_mgr_ 000317 idx mlsys_address_mgr_ 000320 jdx mlsys_address_mgr_ 000322 current_mtle_ptr mlsys_address_mgr_ 000332 address_ptr mlsys_address_mgr_ 000334 address_route_ptr mlsys_address_mgr_ 000336 address_list_ptr mlsys_address_mgr_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_cs cat_realloc_cs call_ext_in_desc call_ext_in call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return tra_ext signal enable shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_cs_eis index_reverse_cs THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. forum_$close_forum forum_$open_forum freen_ initiate_file_$component mail_table_$get mailbox_$get_uid_file mlsys_address_list_mgr_$create_user_freeable_address_list mlsys_address_list_mgr_$decrement_reference_count mlsys_address_list_mgr_$free_address_list mlsys_address_list_mgr_$increment_reference_count mlsys_address_list_mgr_$verify_address_list mlsys_address_route_mgr_$compute_optimum_route mlsys_address_route_mgr_$create_address_route mlsys_address_route_mgr_$decrement_reference_count mlsys_address_route_mgr_$free_address_route mlsys_address_route_mgr_$increment_reference_count mlsys_nit_interface_$get_fully_qualified_name mlsys_parse_text_$parse_address_text mlsys_parse_text_$parse_mailing_list_text mlsys_psp_$forum_not_available mlsys_storage_mgr_$allocate mlsys_user_mte_syntax_$validate_mte_name mlsys_user_mte_syntax_$validate_person_id mlsys_user_mte_syntax_$validate_user_id terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$entlong error_table_$id_not_found error_table_$no_component error_table_$noentry error_table_$smallarg error_table_$unimplemented_version mlsys_data_$person_id mlsys_data_$project_id mlsys_data_$subsystem_area_ptr mlsys_data_$user_default_mailbox_address mlsys_data_$user_is_anonymous mlsys_data_$user_logbox_address mlsys_data_$user_mail_table_address mlsys_data_$valid_segments mlsys_et_$circular_mtes mlsys_et_$incorrect_suffix mlsys_et_$mte_not_found mlsys_et_$no_address_pathname mlsys_et_$no_address_route mlsys_et_$no_address_string mlsys_et_$no_mailing_list mlsys_et_$not_address mlsys_et_$not_foreign_address mlsys_et_$not_list_address mlsys_et_$not_mail_table_address mlsys_et_$not_named_group_address mlsys_et_$null_foreign_address mlsys_et_$null_named_group_name mlsys_et_$unknown_system LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 26 000355 29 000365 329 000373 332 000410 334 000414 341 000423 344 000436 346 000443 348 000446 350 000451 356 000460 359 000500 364 000527 369 000556 373 000565 376 000624 378 000626 380 000642 381 000660 383 000661 385 000663 387 000704 388 000727 390 000752 391 000754 393 000755 397 000764 400 001020 402 001022 404 001036 405 001054 407 001055 409 001057 411 001104 412 001106 414 001117 415 001121 418 001130 419 001136 420 001140 421 001146 422 001163 423 001165 425 001177 427 001200 431 001224 434 001246 437 001271 438 001273 440 001274 444 001303 447 001337 449 001341 451 001355 452 001373 454 001374 456 001376 458 001423 459 001425 461 001436 462 001440 465 001447 466 001455 467 001457 468 001465 469 001502 470 001504 472 001516 474 001517 478 001543 480 001565 482 001610 483 001612 485 001613 489 001622 493 001672 495 001674 497 001710 498 001726 500 001727 502 001731 504 001756 505 001760 507 001771 508 001773 511 002002 513 002013 517 002061 518 002066 519 002070 520 002076 521 002113 522 002115 524 002127 526 002130 530 002154 532 002176 534 002221 535 002223 537 002224 541 002233 544 002277 546 002301 548 002315 549 002333 551 002334 553 002336 555 002347 558 002416 559 002427 560 002431 563 002440 564 002462 566 002505 567 002507 569 002510 573 002517 576 002557 578 002561 580 002575 581 002613 583 002614 585 002616 587 002627 591 002735 598 003023 600 003061 602 003072 603 003074 606 003103 607 003125 609 003150 610 003152 612 003153 616 003162 620 003224 621 003232 622 003235 625 003244 626 003253 627 003256 630 003265 632 003277 633 003302 636 003311 638 003313 640 003327 641 003345 643 003346 645 003350 648 003371 650 003411 652 003432 653 003437 655 003447 656 003476 659 003506 660 003531 662 003554 663 003556 665 003557 669 003566 672 003622 674 003624 676 003640 677 003656 679 003657 681 003661 682 003676 683 003700 684 003711 685 003713 688 003722 689 003734 690 003756 693 004001 694 004003 696 004004 700 004013 704 004063 706 004065 708 004101 709 004117 711 004120 713 004122 715 004133 719 004213 721 004224 722 004226 723 004235 726 004236 727 004273 728 004304 731 004352 734 004354 735 004377 738 004422 739 004424 741 004425 745 004434 748 004474 750 004521 751 004527 752 004532 755 004541 757 004543 759 004557 760 004575 762 004576 764 004600 765 004611 767 004621 769 004626 770 004650 773 004673 774 004675 776 004676 780 004705 783 004725 785 004751 786 004761 788 004763 790 004764 793 005001 795 005026 797 005054 799 005057 801 005065 802 005103 804 005112 807 005137 808 005155 810 005164 812 005202 814 005211 816 005227 818 005236 820 005254 822 005263 824 005301 826 005310 828 005326 830 005335 833 005362 835 005376 837 005412 838 005430 840 005437 842 005455 844 005464 846 005502 848 005511 850 005520 851 005536 856 005545 859 005561 861 005564 868 005573 871 005607 873 005613 876 005631 878 005633 884 005642 887 005656 889 005662 891 005664 895 005673 898 005713 900 005737 902 005740 903 005744 905 005745 912 005754 915 006001 917 006025 919 006026 921 006031 923 006054 925 006063 931 006131 933 006201 935 006211 938 006214 940 006223 942 006246 944 006255 946 006305 948 006315 951 006320 955 006327 958 006366 960 006412 962 006413 964 006416 966 006421 968 006430 970 006476 971 006524 972 006535 973 006536 975 006545 977 006613 978 006641 979 006652 980 006653 982 006662 984 006672 985 006702 986 006712 987 006713 989 006722 991 006732 992 006742 993 006752 994 006753 996 006762 998 006772 999 007002 1000 007012 1001 007013 1003 007022 1006 007025 1008 007034 1010 007044 1011 007054 1012 007064 1013 007065 1015 007074 1017 007077 1023 007106 1026 007131 1028 007155 1030 007156 1033 007174 1034 007176 1035 007177 1036 007200 1038 007204 1040 007210 1042 007213 1048 007222 1051 007242 1053 007266 1055 007267 1056 007273 1057 007302 1058 007303 1060 007304 1062 007307 1068 007316 1071 007340 1073 007364 1075 007365 1077 007377 1078 007407 1080 007423 1082 007440 1084 007466 1085 007476 1086 007477 1087 007500 1089 007504 1091 007507 1097 007516 1100 007536 1102 007562 1104 007563 1107 007601 1108 007603 1109 007604 1110 007605 1112 007611 1114 007615 1116 007620 1120 007627 1123 007651 1125 007675 1127 007676 1128 007702 1129 007705 1130 007706 1132 007707 1134 007712 1140 007721 1143 007744 1145 007770 1147 007771 1151 010035 1152 010062 1154 010105 1160 010114 1163 010137 1165 010163 1167 010164 1169 010210 1174 010217 1177 010237 1178 010265 1180 010313 1182 010314 1185 010332 1188 010344 1190 010346 1192 010370 1193 010401 1195 010413 1198 010421 1199 010432 1200 010444 1208 010452 1213 010474 1214 010500 1215 010512 1216 010520 1217 010522 1219 010534 1223 010542 1224 010546 1225 010560 1226 010566 1227 010570 1229 010602 1237 010610 1240 010641 1243 010663 1244 010677 1246 010701 1249 010707 1252 010714 1253 010716 1254 010730 1255 010747 1258 010751 1264 010753 1267 010762 1275 010766 1281 011003 1283 011037 1285 011073 1288 011107 1289 011134 1291 011161 1293 011172 1295 011173 1300 011175 1302 011231 1304 011265 1307 011301 1310 011317 1313 011333 1314 011360 1316 011405 1318 011416 1320 011417 1331 011421 1335 011437 1336 011452 1339 011465 1341 011476 1342 011500 1343 011512 1346 011546 1347 011551 1348 011552 1349 011554 1351 011555 1357 011557 1364 011601 1367 011643 1371 011705 1373 011717 1375 011720 1382 011727 1384 011743 1386 011757 1389 011767 1392 012005 1397 012013 1398 012015 1399 012026 1400 012027 1401 012042 1404 012066 1405 012070 1406 012073 1407 012075 1408 012110 1409 012111 1410 012124 1413 012150 1414 012152 1415 012155 1418 012157 1437 012161 1472 012173 1475 012211 1477 012235 1479 012236 1480 012242 1481 012245 1484 012254 1485 012256 1487 012264 1488 012267 1490 012270 1493 012272 1540 012301 1543 012321 1545 012345 1547 012346 1548 012353 1549 012356 1552 012365 1553 012373 1554 012376 1557 012405 1563 012431 1564 012433 1565 012434 1570 012435 1571 012437 1573 012453 1574 012506 1575 012507 1577 012550 1579 012560 1580 012562 1581 012566 1583 012615 1584 012616 1585 012620 1586 012653 1587 012655 1590 012657 1609 012666 1612 012702 1614 012715 1687 012724 1690 012745 1424 012771 1429 012773 1431 012777 1433 013003 1444 013004 1447 013012 1448 013030 1450 013046 1452 013065 1453 013102 1454 013117 1456 013122 1457 013135 1459 013151 1460 013205 1461 013241 1463 013245 1464 013263 1466 013302 1500 013303 1513 013311 1514 013342 1515 013351 1517 013356 1520 013363 1521 013370 1523 013401 1524 013410 1525 013413 1527 013416 1528 013424 1529 013433 1530 013437 1532 013442 1534 013445 1536 013454 1596 013455 1601 013457 1620 013472 1634 013500 1636 013512 1637 013515 1639 013530 1640 013537 1641 013552 1644 013553 1645 013600 1648 013646 1650 013653 1651 013662 1654 013666 1655 013670 1656 013676 1657 013707 1658 013711 1659 013712 1660 013714 1661 013715 1663 013717 1665 013745 1667 013750 1668 013752 1671 013764 1672 014012 1675 014040 1676 014046 1677 014052 1681 014056 1696 014057 1702 014061 1704 014071 1707 014107 1710 014116 1712 014117 1720 014123 1723 014124 1725 014134 1728 014142 1734 014143 1745 014154 1746 014163 1747 014165 1748 014167 1749 014173 1752 014174 1753 014177 1754 014220 1755 014232 1758 014236 1766 014237 1773 014260 1777 014266 1778 014301 1781 014302 1787 014303 1793 014326 1795 014330 1798 014364 1801 014406 1807 014412 1812 014414 1814 014416 1816 014434 1817 014435 1818 014440 1819 014442 1820 014443 1822 014444 1824 014445 1825 014450 1826 014451 1828 014452 1830 014470 1832 014471 1834 014507 1836 014510 1838 014526 1839 014535 1841 014536 1843 014554 1844 014555 1845 014564 1847 014565 1849 014603 1850 014604 1851 014613 1853 014614 1855 014632 1856 014633 1858 014636 1859 014640 1860 014641 1862 014645 1863 014647 1865 014650 1867 014666 1868 014667 1869 014671 1871 014672 1873 014710 1874 014711 1875 014723 1877 014724 1879 014742 1880 014743 1881 014746 1882 014750 1888 014751 1891 014752 1893 014756 1895 014761 1897 014762 1898 014764 1900 014766 1901 014770 1903 014772 1905 014773 2 10 014774 2 16 015002 2 18 015006 ----------------------------------------------------------- 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