COMPILATION LISTING OF SEGMENT mlsys_parse_control_args_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1108.85_Tue_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 11 /****^ HISTORY COMMENTS: 12* 1) change(88-01-13,Blair), approve(88-03-22,MCR7842), 13* audit(88-07-08,Lippard), install(88-07-26,MR12.2-1069): 14* Make the parse use the mlsys search list to resolve pathnames for 15* saveboxes, mailboxes and mailing lists (free standing). SCP 6349. 16* 2) change(89-05-11,Lee), approve(89-05-30,MCR8111), 17* audit(89-07-12,LZimmerman), install(89-10-02,MR12.3-1079): 18* phx21283 (Mail 534) - Modified internal procedure get_mailbox_pathname to 19* fix a problem when the entry parse_mailbox_control_args is called; it was 20* aborting when the -mbx arg contains a .mbx suffix. 21* END HISTORY COMMENTS */ 22 23 24 /* format: off */ 25 26 /* Mail System Utilities which parse the control argument representations of addresses, address lists, and mailboxes */ 27 28 /* Created: June 1983 by G. Palter */ 29 /* Modified: March 1984 by G. Palter to fix the following mail system errors: 30* #0415 -- read_mail, print_mail, and have_mail do not reject starnames as invalid mailbox specifications 31* #0430 -- when parsing command/request line control arguments, use of "-log", "-save", or "-mailbox" followed by 32* "-at" should create a foreign address whose address string is "{mbx PATH}". Otherwise, when the message reaches 33* the foreign Multics, the address could be incorrectly interpreted as a savebox belonging to the mailer daemon 34* #0433 -- the send_mail command and all send_mail/read_mail requests which accept multiple addresses as arguments do 35* not properly parse "-log -at HOST" 36* #0435 -- the error message displayed by send_mail when the target address of a mail table entry is invalid only 37* includes the name of the mail table entry. The actual invalid address (eg: mailbox pathname) is not included 38* #0436 -- if a forum meeting is not found in the "forum" search list, the mail system will treat it as a version 1 39* forum in the working directory */ 40 41 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen */ 42 43 44 mlsys_parse_control_args_: 45 procedure (); 46 47 return; /* not an entrypoint */ 48 49 50 /* Common parameters */ 51 52 dcl P_sci_ptr pointer parameter; /* -> definition of subsystem for whom we are parsing */ 53 dcl P_argument_idx fixed binary parameter; /* identifies first command/request argument to be parsed; 54* set to identify first argument we didn't use in parsing */ 55 dcl P_parse_ca_options_ptr pointer parameter; /* -> options describing how to parse */ 56 dcl P_code fixed binary (35) parameter; 57 58 59 /* parse_address_control_args Parameters */ 60 61 dcl P_address_ptr pointer parameter; /* set -> the address parsed from the command/request line */ 62 63 64 /* parse_address_list_control_args Parameters */ 65 66 dcl P_address_list_version character (8) parameter; /* version of address_list structures desired */ 67 dcl P_normal_address_list_ptr pointer parameter; /* -> list where all but logbox/savebox addresses are added */ 68 dcl P_logsave_address_list_ptr pointer parameter; /* -> list where logbox/savebox addresses are added */ 69 70 71 /* parse_mailbox_control_args and parse_mailbox_text Parameters */ 72 73 dcl P_mailbox_dirname character (*) parameter; /* set to the mailbox pathname found on the command line */ 74 dcl P_mailbox_ename character (*) parameter; /* ... */ 75 76 77 /* parse_mailbox_text Parameters */ 78 79 dcl P_mailbox_text character (*) parameter; /* the text to be converted to a pathname */ 80 81 82 /* Local copies of parameters */ 83 84 dcl sci_ptr pointer; 85 dcl argument_idx fixed binary; 86 dcl code fixed binary (35); 87 88 dcl creation_mode fixed binary; /* extracted from parse_ca_options ... */ 89 90 dcl address_ptr pointer; 91 92 dcl mbx_dirname character (168); 93 dcl mbx_ename character (32); 94 95 96 /* Remaining declarations */ 97 98 dcl argument character (argument_lth) unaligned based (argument_ptr); 99 dcl argument_ptr pointer; 100 dcl argument_lth fixed binary (21); 101 dcl n_arguments fixed binary; 102 103 dcl system_area area based (system_area_ptr); 104 dcl system_area_ptr pointer; 105 106 dcl abort_the_parse label variable; /* used by abort_parse internal procedure */ 107 108 dcl address_type fixed binary; 109 110 dcl (mailbox_type, mailbox_idx) fixed binary; 111 112 dcl (person_id, project_id) character (32) varying; 113 dcl (mte_address_ptr, target_address_ptr) pointer; 114 dcl (errors_detected, is_mte_name) bit (1) aligned; 115 dcl try_to_create bit (1) unaligned; 116 117 dcl forum_search_list_ptr pointer; 118 119 dcl STACK_EXTENSION fixed binary (18) static options (constant) initial (128); 120 121 dcl NULL_STRING character (1) static options (constant) initial (" "); 122 123 /* format: off */ 124 dcl (USER_OR_MTE_ADDRESS initial (-1), /* either a User_id or a mail-table entry name */ 125 MBX_USER_OR_MTE_ADDRESS initial (-2)) /* either a mailbox pathname, User_id, or mail-table name */ 126 fixed binary static options (constant); 127 128 dcl (OTHER_MAILBOX initial (1), /* not a logbox or savebox */ 129 USER_LOGBOX initial (2), 130 SAVEBOX initial (3)) 131 fixed binary static options (constant); 132 133 dcl (error_table_$bad_subr_arg, error_table_$badopt, error_table_$entlong, error_table_$moderr, error_table_$noarg, 134 error_table_$noentry, error_table_$nostars, error_table_$no_dir, error_table_$unimplemented_version, 135 error_table_$smallarg, mlsys_et_$ca_parse_failed, mlsys_et_$mailbox_exists, mlsys_et_$mte_not_found, 136 mlsys_et_$mte_not_mailbox, mlsys_et_$no_mailbox) 137 fixed binary (35) external; 138 /* format: on */ 139 140 dcl check_star_name_$entry entry (character (*), fixed binary (35)); 141 dcl command_query_$yes_no entry () options (variable); 142 dcl cu_$arg_list_ptr entry () returns (pointer); 143 dcl cu_$arg_ptr entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 144 dcl cu_$generate_call entry (entry, pointer); 145 dcl cu_$grow_stack_frame entry (fixed binary (18), pointer, fixed binary (35)); 146 dcl cu_$shrink_stack_frame entry (pointer, fixed binary (35)); 147 dcl expand_pathname_ entry (character (*), character (*), character (*), fixed binary (35)); 148 dcl expand_pathname_$add_suffix entry (character (*), character (*), character (*), character (*), fixed binary (35)); 149 dcl expand_pathname_$component_add_suffix 150 entry (character (*), character (*), character (*), character (*), character (*), fixed binary (35)); 151 dcl forum_$get_forum_path entry (character (*), character (*), character (*), character (*), fixed binary (35)); 152 dcl get_system_free_area_ entry () returns (pointer); 153 dcl mail_system_$add_address entry (pointer, pointer, character (8), fixed binary (35)); 154 dcl mail_system_$create_foreign_address 155 entry (character (*) varying, character (256) varying, pointer, character (*) varying, character (*) varying, 156 pointer, fixed binary (35)); 157 dcl mail_system_$create_forum_address 158 entry (character (*), character (*), character (*) varying, character (*) varying, pointer, fixed binary (35)); 159 dcl mail_system_$create_logbox_address 160 entry (character (*) varying, character (*) varying, character (*) varying, pointer, fixed binary (35)); 161 dcl mail_system_$create_mail_table_address 162 entry (character (*) varying, character (*) varying, character (*) varying, pointer, fixed binary (35)); 163 dcl mail_system_$create_mailbox_address 164 entry (character (*), character (*), character (*) varying, character (*) varying, pointer, fixed binary (35)); 165 dcl mail_system_$create_mailing_list_address 166 entry (character (*), character (*), character (*), character (*) varying, character (*) varying, pointer, 167 fixed binary (35)); 168 dcl mail_system_$create_savebox_address 169 entry (character (*) varying, character (*), character (*), character (*) varying, character (*) varying, 170 pointer, fixed binary (35)); 171 dcl mail_system_$create_user_mailbox_address 172 entry (character (*) varying, character (*) varying, character (*) varying, pointer, fixed binary (35)); 173 dcl mail_system_$free_address entry (pointer, fixed binary (35)); 174 dcl mail_system_$get_address_pathname entry (pointer, character (*), character (*), character (*), fixed binary (35)); 175 dcl mail_system_$get_address_type entry (pointer, fixed binary, fixed binary (35)); 176 dcl mail_system_$get_mail_table_address entry (pointer, pointer, fixed binary (35)); 177 dcl mail_system_$validate_address entry (pointer, bit (1) aligned, fixed binary (35)); 178 dcl mailbox_$close entry (fixed binary, fixed binary (35)); 179 dcl mailbox_$open entry (character (*), character (*), fixed binary, fixed binary (35)); 180 dcl mlsys_psp_$forum_not_available entry () returns (bit (1) aligned); 181 dcl mlsys_user_mte_syntax_$classify_and_validate 182 entry (character (*) varying, bit (1) aligned, character (*) varying, character (*) varying, fixed binary (35)); 183 dcl mlsys_utils_$create_logbox entry (fixed binary (35)); 184 dcl mlsys_utils_$create_savebox entry (character (*), character (*), fixed binary (35)); 185 dcl mlsys_utils_$format_address_field 186 entry (character (*) varying, pointer, fixed binary, pointer, fixed binary (21), fixed binary (21), 187 fixed binary (35)); 188 dcl mlsys_utils_$print_validate_results entry (pointer, pointer, fixed binary (35)); 189 dcl pathname_ entry (character (*), character (*)) returns (character (168)); 190 dcl pathname_$component entry (character (*), character (*), character (*)) returns (character (194)); 191 dcl search_paths_$find_dir 192 entry (char(*), ptr, char(*), char(*), char(*), fixed bin(35)); 193 dcl search_paths_$get 194 entry (character (*), bit (36), character (*), pointer, pointer, fixed binary, pointer, fixed binary (35)); 195 dcl ssu_$abort_line entry () options (variable); 196 dcl ssu_$arg_ptr entry (pointer, fixed binary, pointer, fixed binary (21)); 197 dcl ssu_$get_subsystem_and_request_name entry (pointer) returns (character (72) var); 198 dcl ssu_$print_message entry () options (variable); 199 dcl ssu_$return_arg entry (pointer, fixed binary, bit (1) aligned, pointer, fixed binary (21)); 200 dcl suffixed_name_$make entry (char(*), char(*), char(32), fixed bin(35)); 201 202 203 dcl (addr, index, length, min, null, reverse, rtrim, search) builtin; 204 205 dcl cleanup condition; 206 207 /* Converts the control argument representation of an address into its internal form */ 208 209 parse_address_control_args: 210 entry (P_sci_ptr, P_argument_idx, P_parse_ca_options_ptr, P_address_ptr, P_code); 211 212 sci_ptr = P_sci_ptr; 213 argument_idx = P_argument_idx; 214 215 parse_ca_options_ptr = P_parse_ca_options_ptr; 216 if parse_ca_options.version ^= PARSE_CA_OPTIONS_VERSION_1 then do; 217 P_code = error_table_$unimplemented_version; 218 return; 219 end; 220 221 if (parse_ca_options.logbox_creation_mode < DONT_CREATE_MAILBOX) 222 | (parse_ca_options.logbox_creation_mode > SILENTLY_CREATE_MAILBOX) 223 | (parse_ca_options.savebox_creation_mode < DONT_CREATE_MAILBOX) 224 | (parse_ca_options.savebox_creation_mode > SILENTLY_CREATE_MAILBOX) | (parse_ca_options.mbz ^= ""b) 225 then do; 226 P_code = error_table_$bad_subr_arg; 227 return; 228 end; 229 230 address_ptr, forum_search_list_ptr = null (); /* for cleanup handler */ 231 system_area_ptr = get_system_free_area_ (); 232 233 on condition (cleanup) 234 begin; 235 if address_ptr ^= null () then call mail_system_$free_address (address_ptr, (0)); 236 if forum_search_list_ptr ^= null () then free forum_search_list_ptr -> sl_info in (system_area); 237 forum_search_list_ptr = null (); 238 end; 239 240 abort_the_parse = RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS_WITH_ERRORS; 241 242 call ssu_$return_arg (sci_ptr, n_arguments, ("0"b), (null ()), (0)); 243 244 begin; /* need a list of possible address modifiers */ 245 246 dcl host_indeces (n_arguments) fixed binary; 247 248 call parse_single_address (addr (host_indeces), RETURN_BADOPT_FROM_PARSE_ADDRESS_CONTROL_ARGS); 249 end; 250 251 code = 0; /* success */ 252 253 254 RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS: 255 if forum_search_list_ptr ^= null () then free forum_search_list_ptr -> sl_info in (system_area); 256 forum_search_list_ptr = null (); 257 258 P_address_ptr = address_ptr; /* might have an address even after error (^abort&validate) */ 259 P_argument_idx = argument_idx + 1; /* to whatever's after the address (or error) */ 260 P_code = code; 261 262 return; 263 264 265 /* Control arrives here after printing error messages when unable to parse an address control argument representation */ 266 267 RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS_WITH_ERRORS: 268 code = mlsys_et_$ca_parse_failed; 269 go to RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS; 270 271 272 /* Control arrives here if an unrecognized control argument is encountered while parsing the address representation */ 273 274 RETURN_BADOPT_FROM_PARSE_ADDRESS_CONTROL_ARGS: 275 call abort_parse (sci_ptr, error_table_$badopt, """^a""", argument); 276 277 /* Converts the control argument representation of an address list into its internal form */ 278 279 parse_address_list_control_args: 280 entry (P_sci_ptr, P_argument_idx, P_parse_ca_options_ptr, P_address_list_version, P_normal_address_list_ptr, 281 P_logsave_address_list_ptr, P_code); 282 283 sci_ptr = P_sci_ptr; 284 argument_idx = P_argument_idx; 285 286 parse_ca_options_ptr = P_parse_ca_options_ptr; 287 if parse_ca_options.version ^= PARSE_CA_OPTIONS_VERSION_1 then do; 288 P_code = error_table_$unimplemented_version; 289 return; 290 end; 291 292 if (parse_ca_options.logbox_creation_mode < DONT_CREATE_MAILBOX) 293 | (parse_ca_options.logbox_creation_mode > SILENTLY_CREATE_MAILBOX) 294 | (parse_ca_options.savebox_creation_mode < DONT_CREATE_MAILBOX) 295 | (parse_ca_options.savebox_creation_mode > SILENTLY_CREATE_MAILBOX) | (parse_ca_options.mbz ^= ""b) 296 then do; 297 P_code = error_table_$bad_subr_arg; 298 return; 299 end; 300 301 if addr (P_normal_address_list_ptr) ^= addr (P_logsave_address_list_ptr) then 302 if (P_normal_address_list_ptr = P_logsave_address_list_ptr) & (P_normal_address_list_ptr ^= null ()) 303 then do; 304 /*** The two lists can't be the same list unless the actual parameters are identical; otherwise, when 305* the list is expanded, only one of the two parameters will be properly updated */ 306 P_code = error_table_$bad_subr_arg; 307 return; 308 end; 309 310 address_ptr, forum_search_list_ptr = null (); /* for cleanup handler */ 311 system_area_ptr = get_system_free_area_ (); 312 313 on condition (cleanup) 314 begin; 315 if address_ptr ^= null () then call mail_system_$free_address (address_ptr, (0)); 316 if forum_search_list_ptr ^= null () then free forum_search_list_ptr -> sl_info in (system_area); 317 forum_search_list_ptr = null (); 318 end; 319 320 abort_the_parse = RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS_WITH_ERRORS; 321 322 errors_detected = "0"b; /* everything's OK so far */ 323 code = 0; 324 325 call ssu_$return_arg (sci_ptr, n_arguments, ("0"b), (null ()), (0)); 326 327 CONTINUE_ADDRESS_LIST_PARSE: 328 begin; 329 330 dcl host_indeces (n_arguments) fixed binary; 331 332 do while (argument_idx <= n_arguments); /* while there's something left on the command/request line */ 333 call parse_single_address (addr (host_indeces), RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS); 334 argument_idx = argument_idx + 1; /* ... to first argument after the address */ 335 336 call mail_system_$get_address_type (address_ptr, address_type, (0)); 337 if (address_type = LOGBOX_ADDRESS) | (address_type = SAVEBOX_ADDRESS) then 338 call mail_system_$add_address (P_logsave_address_list_ptr, address_ptr, P_address_list_version, 339 code); 340 else call mail_system_$add_address (P_normal_address_list_ptr, address_ptr, P_address_list_version, 341 code); 342 if code ^= 0 then do; /* ... can't add the address */ 343 call mail_system_$free_address (address_ptr, (0)); 344 go to RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS; 345 end; 346 end; 347 end; 348 349 350 RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS: 351 if forum_search_list_ptr ^= null () then free forum_search_list_ptr -> sl_info in (system_area); 352 forum_search_list_ptr = null (); 353 354 P_argument_idx = argument_idx; /* to whatever's after the address (or error) */ 355 356 if code ^= 0 then /* some fatal error that the caller should hear about */ 357 P_code = code; 358 else if errors_detected then /* let the caller know something wasn't quite right ... */ 359 P_code = mlsys_et_$ca_parse_failed; 360 else P_code = 0; /* success */ 361 362 return; 363 364 365 /* Control arrives here after printing error messages when unable to parse an address control argument representation */ 366 367 RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS_WITH_ERRORS: 368 errors_detected = "1"b; /* remember to set appropriate error code on return ... */ 369 code = 0; /* ... and don't return this one if its the last address */ 370 371 argument_idx = argument_idx + 1; /* to first argument after the error */ 372 373 if parse_ca_options.abort_on_errors then /* give up right now (shouldn't ever actually get here) */ 374 go to RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS; 375 376 else do; /* otherwise, keep looking */ 377 if address_ptr ^= null () then do; 378 call mail_system_$get_address_type (address_ptr, address_type, (0)); 379 if (address_type = LOGBOX_ADDRESS) | (address_type = SAVEBOX_ADDRESS) then 380 call mail_system_$add_address (P_logsave_address_list_ptr, address_ptr, P_address_list_version, 381 (0)); 382 else call mail_system_$add_address (P_normal_address_list_ptr, address_ptr, P_address_list_version, 383 (0)); 384 call mail_system_$free_address (address_ptr, (0)); 385 end; /* ... above free is a no-op if the add_address succeeds */ 386 go to CONTINUE_ADDRESS_LIST_PARSE; 387 end; 388 389 /* Actually converts the control argument representation of a single address into its internal representation */ 390 391 parse_single_address: 392 procedure (p_host_indeces_ptr, p_badopt_handler); 393 394 dcl p_host_indeces_ptr pointer parameter; 395 dcl p_badopt_handler label variable parameter; 396 397 dcl host_indeces (n_arguments) fixed binary based (p_host_indeces_ptr); 398 dcl n_hosts fixed binary; 399 400 dcl address_string character (address_string_lth) unaligned based (address_string_ptr); 401 dcl address_name character (address_name_lth) unaligned based (address_name_ptr); 402 dcl address_comment character (address_comment_lth) unaligned based (address_comment_ptr); 403 dcl (address_string_ptr, address_name_ptr, address_comment_ptr) pointer; 404 dcl (address_string_lth, address_name_lth, address_comment_lth) fixed binary (21); 405 406 dcl address_buffer_ptr pointer; 407 dcl (address_buffer_lth, address_buffer_used) fixed binary (21); 408 409 dcl foreign_system_name character (256) varying; 410 dcl address_dirname character (168); 411 dcl (address_ename, address_component) character (32); 412 dcl trimmed_address_ename character (32) varying; 413 414 dcl (continue_to_peek, include_name_and_comment) bit (1) aligned; 415 dcl try_to_create bit (1) unaligned; 416 417 dcl (preliminary_type, address_type, idx) fixed binary; 418 419 420 /**** format: ^indcomtxt */ 421 /* Determine the probable type of address: The true type can not be determined until after a check is made for host name 422* qualification. By first determining the probably type, sequences such as 423* -save PATH -at HOST 424* are permitted */ 425 /**** format: indcomtxt */ 426 427 call ssu_$arg_ptr (sci_ptr, argument_idx, argument_ptr, argument_lth); 428 429 if index (argument, "-") = 1 then /* control argument representations ... */ 430 if argument = "-user" then do; 431 call get_next_argument ("A user name"); 432 preliminary_type = USER_OR_MTE_ADDRESS; 433 address_string_ptr = argument_ptr; 434 address_string_lth = argument_lth; 435 end; 436 437 else if argument = "-log" then do; 438 preliminary_type = LOGBOX_ADDRESS; 439 address_string_ptr = null (); /* no explicit string associated with this type of address */ 440 address_string_lth = 0; 441 end; 442 443 else if (argument = "-save") | (argument = "-sv") then do; 444 call get_next_argument ("A savebox pathname"); 445 preliminary_type = SAVEBOX_ADDRESS; 446 address_string_ptr = argument_ptr; 447 address_string_lth = argument_lth; 448 end; 449 450 else if (argument = "-mailbox") | (argument = "-mbx") then do; 451 call get_next_argument ("A mailbox pathname"); 452 preliminary_type = MAILBOX_ADDRESS; 453 address_string_ptr = argument_ptr; 454 address_string_lth = argument_lth; 455 end; 456 457 else if (argument = "-meeting") | (argument = "-mtg") then do; 458 call get_next_argument ("A forum meeting pathname"); 459 preliminary_type = FORUM_ADDRESS; 460 address_string_ptr = argument_ptr; 461 address_string_lth = argument_lth; 462 end; 463 464 else if (argument = "-mailing_list") | (argument = "-mls") then do; 465 call get_next_argument ("A mailing list pathname"); 466 preliminary_type = MAILING_LIST_ADDRESS; 467 address_string_ptr = argument_ptr; 468 address_string_lth = argument_lth; 469 end; 470 471 else go to p_badopt_handler; /* no other control arguments are legal at this point */ 472 473 else do; /* non-control argument */ 474 preliminary_type = MBX_USER_OR_MTE_ADDRESS; 475 address_string_ptr = argument_ptr; 476 address_string_lth = argument_lth; 477 end; 478 479 480 /* Preliminary address type has been determined: check for qualifiers such as host names, address names, and address 481* comments. If multiple names or comments appear after an address, the last one provided will be used */ 482 483 n_hosts = 0; /* no host names yet */ 484 485 address_name_ptr, /* no address name or comment yet */ 486 address_comment_ptr = addr (NULL_STRING); 487 address_comment_lth, address_name_lth = 0; 488 489 continue_to_peek = (argument_idx < n_arguments); /* don't bother if there's nothing after the address */ 490 491 do while (continue_to_peek); 492 493 call ssu_$arg_ptr (sci_ptr, (argument_idx + 1), argument_ptr, argument_lth); 494 495 if (argument = "-at") | (argument = "-via") | (argument = "-name") | (argument = "-nm") 496 | (argument = "-comment") | (argument = "-com") then do; 497 498 /*** A recognized qualifier */ 499 argument_idx = argument_idx + 1; /* we hereby claim this argument */ 500 501 if (argument = "-at") | (argument = "-via") then do; 502 call get_next_argument ("A host name"); 503 n_hosts = n_hosts + 1; 504 host_indeces (n_hosts) = argument_idx; 505 end; 506 507 else if (argument = "-name") | (argument = "-nm") then do; 508 call get_next_argument ("A character string"); 509 address_name_ptr = argument_ptr; 510 address_name_lth = argument_lth; 511 end; 512 513 else if (argument = "-comment") | (argument = "-com") then do; 514 call get_next_argument ("A character string"); 515 address_comment_ptr = argument_ptr; 516 address_comment_lth = argument_lth; 517 end; 518 519 continue_to_peek = (argument_idx < n_arguments); 520 end; 521 522 else continue_to_peek = "0"b; /* either the next address or something ... */ 523 end; 524 525 526 /* Have all address qualifiers: determine the actual address type assuming that the address were local ... */ 527 528 if n_hosts = 0 then /* truly local */ 529 if preliminary_type = USER_OR_MTE_ADDRESS then do; 530 call mlsys_user_mte_syntax_$classify_and_validate ((address_string), is_mte_name, (""), (""), code); 531 if code ^= 0 then /* ... bad syntax */ 532 call abort_parse (sci_ptr, code, "-user ^a", address_string); 533 if is_mte_name then 534 preliminary_type = MAIL_TABLE_ADDRESS; 535 else preliminary_type = USER_MAILBOX_ADDRESS; 536 end; 537 538 else if preliminary_type = MBX_USER_OR_MTE_ADDRESS then 539 if search (address_string, "<>") ^= 0 then 540 preliminary_type = MAILBOX_ADDRESS; 541 else do; 542 call mlsys_user_mte_syntax_$classify_and_validate ((address_string), is_mte_name, (""), (""), 543 code); 544 if code ^= 0 then /* ... bad syntax */ 545 call abort_parse (sci_ptr, code, "^a", address_string); 546 if is_mte_name then 547 preliminary_type = MAIL_TABLE_ADDRESS; 548 else preliminary_type = USER_MAILBOX_ADDRESS; 549 end; 550 551 else ; /* a known type of local address */ 552 553 else /*** if n_hosts > 0 then */ 554 if (preliminary_type = USER_OR_MTE_ADDRESS) | (preliminary_type = MBX_USER_OR_MTE_ADDRESS) then 555 preliminary_type = FOREIGN_ADDRESS; 556 557 558 /* Construct the address assuming that it's local: If it's actually foreign, the address name and comment will be 559* ommitted as they'll be included later in the actual foreign address */ 560 561 if (preliminary_type ^= FOREIGN_ADDRESS) then do; 562 563 include_name_and_comment = (n_hosts = 0); /* don't include these unless this is the real address */ 564 565 if preliminary_type = USER_MAILBOX_ADDRESS then do; 566 if include_name_and_comment then 567 call mail_system_$create_user_mailbox_address ((address_string), (address_name), 568 (address_comment), address_ptr, code); 569 else call mail_system_$create_user_mailbox_address ((address_string), "", "", address_ptr, code); 570 if code ^= 0 then call abort_parse (sci_ptr, code, "-user ^a", address_string); 571 end; 572 573 else if preliminary_type = LOGBOX_ADDRESS then do; 574 if include_name_and_comment then 575 call mail_system_$create_logbox_address (mlsys_data_$user_id, (address_name), (address_comment), 576 address_ptr, code); 577 else call mail_system_$create_logbox_address (mlsys_data_$user_id, "", "", address_ptr, code); 578 if code ^= 0 then call abort_parse (sci_ptr, code, "-log"); 579 end; 580 581 else if preliminary_type = SAVEBOX_ADDRESS then do; 582 if has_suffix (address_string, ".sv") then address_string_lth = address_string_lth - length (".sv"); 583 if search (address_string, "<>") = 0 then do; 584 call suffixed_name_$make (address_string, "sv.mbx", address_ename, code); 585 call search_paths_$find_dir ("mlsys", null(), address_ename, "", address_dirname, code); 586 if code = error_table_$noentry then 587 call expand_pathname_$add_suffix (address_string, "sv.mbx", address_dirname, address_ename, code); 588 if code ^= 0 then call abort_parse (sci_ptr, code, "Searching the ""mlsys"" search list for ^a", address_ename); 589 end; 590 else do; 591 call expand_pathname_$add_suffix (address_string, "sv.mbx", address_dirname, address_ename, code); 592 if code ^= 0 then call abort_parse (sci_ptr, code, "-save ^a", address_string); 593 end; 594 595 call reject_starnames ("-save", address_dirname, address_ename, ""); 596 if include_name_and_comment then 597 call mail_system_$create_savebox_address (mlsys_data_$user_id, address_dirname, address_ename, 598 (address_name), (address_comment), address_ptr, code); 599 else call mail_system_$create_savebox_address (mlsys_data_$user_id, address_dirname, address_ename, 600 "", "", address_ptr, code); 601 if code ^= 0 then 602 call abort_parse (sci_ptr, code, "-save ^a", pathname_ (address_dirname, address_ename)); 603 end; 604 605 else if preliminary_type = MAILBOX_ADDRESS then do; 606 if search (address_string, "<>") = 0 then do; 607 call suffixed_name_$make (address_string, "mbx", address_ename, code); 608 if code ^= 0 then call abort_parse (sci_ptr, code, "^a", address_string); 609 call search_paths_$find_dir ("mlsys", null(), address_ename, "", address_dirname, code); 610 if code = error_table_$noentry then 611 call expand_pathname_$add_suffix (address_string, "mbx", address_dirname, address_ename, code); 612 if code ^= 0 then call abort_parse (sci_ptr, code, "Searching the ""mlsys"" search list for ^a", address_ename); 613 end; 614 else do; 615 call expand_pathname_$add_suffix (address_string, "mbx", address_dirname, address_ename, code); 616 if code ^= 0 then call abort_parse (sci_ptr, code, "-mailbox ^a", address_string); 617 end; 618 call reject_starnames ("-mailbox", address_dirname, address_ename, ""); 619 if include_name_and_comment then 620 call mail_system_$create_mailbox_address (address_dirname, address_ename, (address_name), 621 (address_comment), address_ptr, code); 622 else call mail_system_$create_mailbox_address (address_dirname, address_ename, "", "", address_ptr, 623 code); 624 if code ^= 0 then 625 call abort_parse (sci_ptr, code, "-mailbox ^a", pathname_ (address_dirname, address_ename)); 626 end; 627 628 else if preliminary_type = FORUM_ADDRESS then do; 629 if search (address_string, "<>") = 0 then do; 630 /*** ... not a pathname: must find the meeting by search list */ 631 if length (rtrim (address_string)) > length (address_ename) then 632 call abort_parse (sci_ptr, error_table_$entlong, "-meeting ^a", address_string); 633 address_ename = address_string; 634 if ^(has_suffix (address_ename, ".forum") | has_suffix (address_ename, ".control")) then 635 if length (rtrim (address_ename)) > (length (address_ename) - length (".forum")) then 636 call abort_parse (sci_ptr, error_table_$entlong, "-meeting ^a", address_ename); 637 call reject_starnames ("-meeting", "", address_ename, ""); 638 if mlsys_psp_$forum_not_available () then 639 /*** ... Forum PSP not here: we've done all we can; mlsys_transmit_ will do the rest */ 640 address_dirname = ""; 641 else do; 642 /*** ... time to scan the search list */ 643 if forum_search_list_ptr = null () then do; 644 call search_paths_$get ("forum", sl_control_default, "", null (), system_area_ptr, 645 sl_info_version_1, forum_search_list_ptr, code); 646 if code ^= 0 then 647 call abort_parse (sci_ptr, code, "Listing the ""forum"" search list."); 648 end; 649 if has_suffix (address_ename, ".forum") | has_suffix (address_ename, ".control") then 650 call search_forum_list (address_ename, address_dirname, code); 651 else do; /* ... try version 2 then version 1 meetings ... */ 652 trimmed_address_ename = rtrim (address_ename); 653 call search_forum_list ((trimmed_address_ename || ".forum"), address_dirname, code); 654 if code = 0 then 655 address_ename = trimmed_address_ename || ".forum"; 656 else do; 657 call search_forum_list ((trimmed_address_ename || ".control"), address_dirname, 658 code); 659 if code = 0 then address_ename = trimmed_address_ename || ".control"; 660 end; 661 end; 662 if code ^= 0 then /* ... couldn't be found */ 663 address_dirname = ""; 664 end; 665 end; 666 else do; 667 /*** ... user has supplied a pathname */ 668 call expand_pathname_ (address_string, address_dirname, address_ename, code); 669 if code ^= 0 then call abort_parse (sci_ptr, code, "-meeting ^a", address_string); 670 if ^(has_suffix (address_ename, ".forum") | has_suffix (address_ename, ".control")) then 671 if length (rtrim (address_ename)) > (length (address_ename) - length (".forum")) then 672 call abort_parse (sci_ptr, error_table_$entlong, "-meeting ^a", 673 pathname_ (address_dirname, address_ename)); 674 call reject_starnames ("-meeting", address_dirname, address_ename, ""); 675 if mlsys_psp_$forum_not_available () then 676 ; /* ... no Forum PSP: we've done all we can */ 677 else do; 678 if ^(has_suffix (address_ename, ".forum") | has_suffix (address_ename, ".control")) then do; 679 /*** ... must determine the meeting version */ 680 trimmed_address_ename = rtrim (address_ename); 681 address_ename = trimmed_address_ename || ".forum"; 682 call forum_$get_forum_path (address_dirname, address_ename, ((168)" "), ((32)" "), 683 code); 684 if code ^= 0 then /* ... not version 2 */ 685 if (length (trimmed_address_ename) + length (".control")) 686 <= length (address_ename) then 687 address_ename = trimmed_address_ename || ".control"; 688 end; 689 end; 690 end; 691 if include_name_and_comment then 692 call mail_system_$create_forum_address (address_dirname, address_ename, (address_name), 693 (address_comment), address_ptr, code); 694 else call mail_system_$create_forum_address (address_dirname, address_ename, "", "", address_ptr, 695 code); 696 if code ^= 0 then 697 call abort_parse (sci_ptr, code, "-meeting ^[^a^s^;^s^a^]", (address_dirname = ""), 698 address_ename, pathname_ (address_dirname, address_ename)); 699 end; 700 701 else if preliminary_type = MAIL_TABLE_ADDRESS then do; 702 if include_name_and_comment then 703 call mail_system_$create_mail_table_address ((address_string), (address_name), (address_comment), 704 address_ptr, code); 705 else call mail_system_$create_mail_table_address ((address_string), "", "", address_ptr, code); 706 if code ^= 0 then call abort_parse (sci_ptr, code, "-user ^a", address_string); 707 end; 708 709 else /*** if preliminary_type = MAILING_LIST_ADDRESS then */ 710 do; 711 call expand_pathname_$component_add_suffix (address_string, "mls", address_dirname, address_ename, 712 address_component, code); 713 if code ^= 0 then call abort_parse (sci_ptr, code, "-mailing_list ^a", address_string); 714 if search (address_string, "<>") = 0 then do; 715 address_dirname = ""; 716 call search_paths_$find_dir ("mlsys", null(), address_ename, "", address_dirname, code); 717 if code = error_table_$noentry then 718 call expand_pathname_$component_add_suffix (address_string, "mls", address_dirname, address_ename, 719 address_component, code); 720 if code ^= 0 then call abort_parse (sci_ptr, code, "Searching the ""mlsys"" search list for ^a", address_ename); 721 end; 722 call reject_starnames ("-mailing_list", address_dirname, address_ename, address_component); 723 if include_name_and_comment then 724 call mail_system_$create_mailing_list_address (address_dirname, address_ename, address_component, 725 (address_name), (address_comment), address_ptr, code); 726 else call mail_system_$create_mailing_list_address (address_dirname, address_ename, address_component, 727 "", "", address_ptr, code); 728 if code ^= 0 then 729 call abort_parse (sci_ptr, code, "-mailing_list ^a", 730 pathname_$component (address_dirname, address_ename, address_component)); 731 end; 732 end; 733 734 735 /* Construct the foreign "mailbox" name of the address from the printed representation of the above local address ... */ 736 737 address_buffer_ptr = null (); 738 739 if n_hosts > 0 then do; /* only if it's foreign ... */ 740 if (preliminary_type = LOGBOX_ADDRESS) | (preliminary_type = SAVEBOX_ADDRESS) then do; 741 call mail_system_$get_address_pathname (address_ptr, address_dirname, address_ename, ((32)" "), (0)); 742 call mail_system_$free_address (address_ptr, (0)); 743 call mail_system_$create_mailbox_address (address_dirname, address_ename, "", "", address_ptr, code); 744 if code ^= 0 then 745 call abort_parse (sci_ptr, code, "Converting ^[-log^s^;-save ^a^] into a mailbox address.", 746 (preliminary_type = LOGBOX_ADDRESS), pathname_ (address_dirname, address_ename)); 747 end; 748 749 if preliminary_type ^= FOREIGN_ADDRESS then do; 750 call cu_$grow_stack_frame (STACK_EXTENSION, address_buffer_ptr, (0)); 751 address_buffer_lth = 4 * STACK_EXTENSION; 752 /* get an initial buffer */ 753 code = error_table_$smallarg; /* need do until ... */ 754 do while (code = error_table_$smallarg);/* ... until the buffer's large enough to hold it */ 755 address_buffer_used = 0; 756 call mlsys_utils_$format_address_field ("", address_ptr, -1, address_buffer_ptr, 757 address_buffer_lth, address_buffer_used, code); 758 if code = error_table_$smallarg then do; 759 /* ... not large enough yet */ 760 call cu_$grow_stack_frame (STACK_EXTENSION, (null ()), (0)); 761 address_buffer_lth = address_buffer_lth + (4 * STACK_EXTENSION); 762 end; 763 end; 764 address_string_ptr = address_buffer_ptr;/* have the "real" mailbox name now */ 765 address_string_lth = address_buffer_used; 766 call mail_system_$free_address (address_ptr, (0)); 767 end; /* ... no longer need the local address */ 768 end; 769 770 771 /* Construct the true address if it's a foreign address */ 772 773 if (preliminary_type = FOREIGN_ADDRESS) | (n_hosts > 0) then do; 774 775 call ssu_$arg_ptr (sci_ptr, host_indeces (1), argument_ptr, argument_lth); 776 foreign_system_name = argument; /* first host name is where the address resides */ 777 778 begin; /* build the explicit route (if any) */ 779 780 dcl 1 local_address_route aligned, 781 2 header like address_route.header, 782 2 relays (min (1, (n_hosts - 1))) character (256) varying; 783 784 local_address_route.version = ADDRESS_ROUTE_VERSION_1; 785 local_address_route.n_relays = n_hosts - 1; 786 do idx = 1 to local_address_route.n_relays; 787 call ssu_$arg_ptr (sci_ptr, host_indeces (idx + 1), argument_ptr, argument_lth); 788 local_address_route.relays (idx) = argument; 789 end; 790 791 if n_hosts > 1 then 792 call mail_system_$create_foreign_address ((address_string), foreign_system_name, 793 addr (local_address_route), (address_name), (address_comment), address_ptr, code); 794 else call mail_system_$create_foreign_address ((address_string), foreign_system_name, null (), 795 (address_name), (address_comment), address_ptr, code); 796 end; 797 798 if code ^= 0 then call abort_parse (sci_ptr, code, "^a -at ^a", address_string, foreign_system_name); 799 end; 800 801 if address_buffer_ptr ^= null () then call cu_$shrink_stack_frame (address_buffer_ptr, (0)); 802 803 804 /* Finally, if requested, verify that mail can be sent to the given address */ 805 806 if parse_ca_options.validate_addresses then do; 807 808 call mail_system_$validate_address (address_ptr, "0"b, code); 809 810 if code = mlsys_et_$no_mailbox then do; 811 /*** Mailbox not found: check if logbox/savebox and create if necessary */ 812 call mail_system_$get_address_type (address_ptr, address_type, (0)); 813 if address_type = LOGBOX_ADDRESS then creation_mode = parse_ca_options.logbox_creation_mode; 814 else if address_type = SAVEBOX_ADDRESS then creation_mode = parse_ca_options.savebox_creation_mode; 815 else creation_mode = DONT_CREATE_MAILBOX; 816 if creation_mode ^= DONT_CREATE_MAILBOX then do; 817 call mail_system_$get_address_pathname (address_ptr, address_dirname, address_ename, ((32)" "), 818 (0)); 819 if creation_mode = QUERY_TO_CREATE_MAILBOX then do; 820 call command_query_$yes_no (try_to_create, 0, ssu_$get_subsystem_and_request_name (sci_ptr), 821 "", "Do you wish to create ^[your logbox^;the savebox ^a^]?", 822 (address_type = LOGBOX_ADDRESS), pathname_ (address_dirname, address_ename)); 823 if ^try_to_create then call abort_parse (sci_ptr, 0); 824 end; 825 if address_type = LOGBOX_ADDRESS then 826 call mlsys_utils_$create_logbox (code); 827 else /*** if address_type = SAVEBOX_ADDRESS then */ 828 call mlsys_utils_$create_savebox (address_dirname, address_ename, code); 829 if code = 0 then 830 if creation_mode = CREATE_AND_ANNOUNCE_MAILBOX then 831 call ssu_$print_message (sci_ptr, 0, "Created ^a.", 832 pathname_ (address_dirname, address_ename)); 833 if code = mlsys_et_$mailbox_exists then code = 0; 834 end; 835 end; 836 837 if code ^= 0 then do; /* the address is invalid ... */ 838 call mlsys_utils_$print_validate_results (sci_ptr, address_ptr, code); 839 call abort_parse (sci_ptr, 0); 840 end; 841 end; 842 843 return; 844 845 846 847 /* Internal to parse_single_address: rejects pathnames containing starnames */ 848 849 reject_starnames: 850 procedure (p_control_argument, p_dirname, p_ename, p_component); 851 852 dcl p_control_argument character (*) parameter; 853 dcl p_dirname character (168); 854 dcl (p_ename, p_component) character (32) parameter; 855 dcl code fixed binary (35); 856 857 call check_star_name_$entry (p_ename, code); /* first check the entryname */ 858 if code = 0 then /* ... entryname OK: check the component name (if present) */ 859 if p_component ^= "" then call check_star_name_$entry (p_component, code); 860 861 if (code = 1) | (code = 2) then code = error_table_$nostars; 862 863 if code ^= 0 then /* either a starname or invalid syntax */ 864 if p_dirname = "" then /* ... no directory: pathname_ does the wrong thing here */ 865 call abort_parse (sci_ptr, code, "^a ^a", p_control_argument, p_ename); 866 else call abort_parse (sci_ptr, code, "^a ^a", p_control_argument, 867 pathname_$component (p_dirname, p_ename, p_component)); 868 869 return; 870 871 end reject_starnames; 872 873 874 875 /* Internal to parse_single_address: scans the forum search list (already obtained above) for the given entryname */ 876 877 search_forum_list: 878 procedure (p_ename, p_dirname, p_code); 879 880 dcl (p_ename, p_dirname) character (*) parameter; 881 dcl p_code fixed binary (35) parameter; 882 883 dcl ename character (32) initial (""); 884 dcl idx fixed binary; 885 886 if length (rtrim (p_ename)) > length (ename) then do; 887 p_code = error_table_$entlong; /* ... constructed entry name is too long */ 888 return; 889 end; 890 891 p_code = 1; /* need do until ... */ 892 893 do idx = 1 to forum_search_list_ptr -> sl_info.num_paths while (p_code ^= 0); 894 if forum_search_list_ptr -> sl_info.paths (idx).code = 0 then 895 call forum_$get_forum_path (forum_search_list_ptr -> sl_info.paths (idx).pathname, p_ename, 896 ((168)" "), ((32)" "), p_code); 897 if p_code = 0 then p_dirname = forum_search_list_ptr -> sl_info.paths (idx).pathname; 898 end; 899 900 return; 901 902 end search_forum_list; 903 904 end parse_single_address; 905 906 /* Converts the control argument representation of a mailbox into the pathname of the mailbox */ 907 908 parse_mailbox_control_args: 909 entry (P_sci_ptr, P_argument_idx, P_parse_ca_options_ptr, P_mailbox_dirname, P_mailbox_ename, P_code); 910 911 sci_ptr = P_sci_ptr; 912 argument_idx = P_argument_idx; 913 914 parse_ca_options_ptr = P_parse_ca_options_ptr; 915 if parse_ca_options.version ^= PARSE_CA_OPTIONS_VERSION_1 then do; 916 P_code = error_table_$unimplemented_version; 917 return; 918 end; 919 920 if (parse_ca_options.logbox_creation_mode < DONT_CREATE_MAILBOX) 921 | (parse_ca_options.logbox_creation_mode > SILENTLY_CREATE_MAILBOX) 922 | (parse_ca_options.savebox_creation_mode < DONT_CREATE_MAILBOX) 923 | (parse_ca_options.savebox_creation_mode > SILENTLY_CREATE_MAILBOX) | (parse_ca_options.mbz ^= ""b) 924 then do; 925 P_code = error_table_$bad_subr_arg; 926 return; 927 end; 928 929 mte_address_ptr, target_address_ptr = null (); /* for cleanup handler */ 930 mailbox_idx = 0; 931 932 mbx_ename = ""; /* indicates that we have no pathname */ 933 934 on condition (cleanup) 935 begin; 936 if mte_address_ptr ^= null () then call mail_system_$free_address (mte_address_ptr, (0)); 937 if target_address_ptr ^= null () then call mail_system_$free_address (target_address_ptr, (0)); 938 if mailbox_idx ^= 0 then call mailbox_$close (mailbox_idx, (0)); 939 mailbox_idx = 0; 940 end; 941 942 abort_the_parse = RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS_WITH_ERRORS; 943 944 call ssu_$return_arg (sci_ptr, n_arguments, ("0"b), (null ()), (0)); 945 946 call ssu_$arg_ptr (sci_ptr, argument_idx, argument_ptr, argument_lth); 947 948 949 if index (argument, "-") = 1 then /* control argument representations ... */ 950 if (argument = "-mailbox") | (argument = "-mbx") then do; 951 call get_next_argument ("A mailbox pathname"); 952 call get_mailbox_pathname (argument); 953 end; 954 955 else if argument = "-user" then do; 956 call get_next_argument ("A user name"); 957 call get_user_mailbox_pathname (argument, "0"b, ("0"b)); 958 end; /* ... non-null sci_ptr causes above to not return on error */ 959 960 else if argument = "-log" then do; 961 mailbox_type = USER_LOGBOX; 962 /*** following call must work as the "constant" address is always correct */ 963 call mail_system_$get_address_pathname (mlsys_data_$user_logbox_address, mbx_dirname, mbx_ename, 964 ((32)" "), (0)); 965 end; 966 967 else if (argument = "-save") | (argument = "-sv") then do; 968 call get_next_argument ("A savebox pathname"); 969 call get_savebox_pathname (argument); 970 end; /* ... non-null sci_ptr causes above to not return on error */ 971 972 else call abort_parse (sci_ptr, error_table_$badopt, """^a""", argument); 973 /* unrecognized control argument */ 974 975 else call parse_mailbox_text_internal (argument); /* not a control argument: specifies pathname somehow */ 976 977 978 /* Here iff we have a mailbox pathname: verify its existence if requested by the caller */ 979 980 if mailbox_type = OTHER_MAILBOX then creation_mode = DONT_CREATE_MAILBOX; 981 else if mailbox_type = USER_LOGBOX then creation_mode = parse_ca_options.logbox_creation_mode; 982 else /*** if mailbox_type = SAVEBOX then */ 983 creation_mode = parse_ca_options.savebox_creation_mode; 984 985 if parse_ca_options.validate_addresses then do; 986 call mailbox_$open (mbx_dirname, mbx_ename, mailbox_idx, code); 987 if code = error_table_$moderr then code = 0; /* ... it's there although we can't access it */ 988 989 if (code = error_table_$noentry) & (creation_mode ^= DONT_CREATE_MAILBOX) then do; 990 if creation_mode = QUERY_TO_CREATE_MAILBOX then do; 991 call command_query_$yes_no (try_to_create, 0, ssu_$get_subsystem_and_request_name (sci_ptr), "", 992 "Do you wish to create ^[your logbox^;the savebox ^a^]?", (mailbox_type = USER_LOGBOX), 993 pathname_ (mbx_dirname, mbx_ename)); 994 if ^try_to_create then call abort_parse (sci_ptr, 0); 995 end; 996 if mailbox_type = USER_LOGBOX then 997 call mlsys_utils_$create_logbox (code); 998 else /*** if mailbox_type = SAVEBOX then */ 999 call mlsys_utils_$create_savebox (mbx_dirname, mbx_ename, code); 1000 if code = 0 then /* ... just created it ... */ 1001 if creation_mode = CREATE_AND_ANNOUNCE_MAILBOX then 1002 call ssu_$print_message (sci_ptr, 0, "Created ^a.", pathname_ (mbx_dirname, mbx_ename)); 1003 if code = mlsys_et_$mailbox_exists then code = 0; 1004 end; 1005 1006 if code ^= 0 then /* ... can't find or create it */ 1007 call abort_parse (sci_ptr, code, "^a", pathname_ (mbx_dirname, mbx_ename)); 1008 end; 1009 1010 code = 0; /* success! */ 1011 1012 1013 RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS: /* ... error case will transfer here */ 1014 if mte_address_ptr ^= null () then call mail_system_$free_address (mte_address_ptr, (0)); 1015 if target_address_ptr ^= null () then call mail_system_$free_address (target_address_ptr, (0)); 1016 if mailbox_idx ^= 0 then call mailbox_$close (mailbox_idx, (0)); 1017 mailbox_idx = 0; 1018 1019 if mbx_ename ^= "" then do; /* got a pathname (even after an error (^abort&validate)) */ 1020 P_mailbox_dirname = mbx_dirname; 1021 P_mailbox_ename = mbx_ename; 1022 end; 1023 1024 P_argument_idx = argument_idx + 1; /* to first argument after the mailbox argument(s) */ 1025 P_code = code; 1026 1027 return; 1028 1029 1030 /* Control arrives here after printing error messages when unable to parse a mailbox control argument representation */ 1031 1032 RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS_WITH_ERRORS: 1033 code = mlsys_et_$ca_parse_failed; 1034 go to RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS; 1035 1036 /* Converts the printed representation of a mailbox pathname into the actual pathname: This printed representation is 1037* equivalent to the non-control argument case of the control argument representation. If the text contains either a "<" 1038* or ">", it is interpreted as a pathname. If it ends in either ".sv.mbx" or ".mbx", it is interpreted as a savebox or 1039* mailbox pathname, respectively. Otherwise, the text is an entryname, and a check is made for a mailbox in the working 1040* directory with that name; if no mailbox is found, a check is made for a savebox; if no savebox is found, the text is 1041* interpreted as a user name and the corresponding default mailbox or mail table entry is used */ 1042 1043 parse_mailbox_text: 1044 entry (P_mailbox_text, P_mailbox_dirname, P_mailbox_ename, P_code); 1045 1046 sci_ptr = null (); /* don't print anything: just return a code */ 1047 1048 mte_address_ptr, target_address_ptr = null (); /* for cleanup handler */ 1049 mailbox_idx = 0; 1050 1051 on condition (cleanup) 1052 begin; 1053 if mte_address_ptr ^= null () then call mail_system_$free_address (mte_address_ptr, (0)); 1054 if target_address_ptr ^= null () then call mail_system_$free_address (target_address_ptr, (0)); 1055 if mailbox_idx ^= 0 then call mailbox_$close (mailbox_idx, (0)); 1056 mailbox_idx = 0; 1057 end; 1058 1059 abort_the_parse = RETURN_FROM_PARSE_MAILBOX_TEXT; 1060 1061 call parse_mailbox_text_internal (P_mailbox_text);/* do it */ 1062 1063 P_mailbox_dirname = mbx_dirname; /* here iff all was OK */ 1064 P_mailbox_ename = mbx_ename; 1065 P_code = 0; 1066 1067 RETURN_FROM_PARSE_MAILBOX_TEXT: 1068 if mte_address_ptr ^= null () then call mail_system_$free_address (mte_address_ptr, (0)); 1069 if target_address_ptr ^= null () then call mail_system_$free_address (target_address_ptr, (0)); 1070 if mailbox_idx ^= 0 then call mailbox_$close (mailbox_idx, (0)); 1071 mailbox_idx = 0; 1072 1073 return; 1074 1075 1076 1077 /* Actually parses the printed representation of a mailbox pathname: called by several entrypoints */ 1078 1079 parse_mailbox_text_internal: 1080 procedure (p_text); 1081 1082 dcl p_text character (*) parameter; 1083 1084 dcl saved_mbx_dirname character (168); 1085 dcl saved_mbx_ename character (32); 1086 dcl saved_code fixed binary (35); 1087 1088 dcl trimmed_ename character (32) varying; 1089 dcl not_user_name bit (1) aligned; 1090 dcl use_search_paths bit (1) aligned; 1091 dcl search_paths_$get entry (char(*), bit(36), char(*), ptr, ptr, fixed bin, ptr, fixed bin(35)); 1092 dcl loop_idx fixed bin; 1093 dcl idx fixed bin; 1094 dcl mlsys_search_list_ptr ptr; 1095 1096 use_search_paths = "0"b; 1097 system_area_ptr = get_system_free_area_ (); 1098 if search (p_text, "<>") = 0 then do; 1099 call search_paths_$get ("mlsys", sl_control_default, "", null(), system_area_ptr, sl_info_version_1, mlsys_search_list_ptr, code); 1100 loop_idx = mlsys_search_list_ptr -> sl_info.num_paths; 1101 use_search_paths = "1"b; 1102 mbx_ename = p_text; 1103 end; 1104 else do; 1105 loop_idx = 1; 1106 call expand_pathname_ (p_text, mbx_dirname, mbx_ename, code); 1107 if code ^= 0 then do; /* bad pathname ... */ 1108 saved_code = code; 1109 call get_user_mailbox_pathname (p_text, "1"b, not_user_name); 1110 if not_user_name then call abort_parse (sci_ptr, saved_code, "^a", p_text); 1111 else if mailbox_exists () then return; /* ... but it was a valid User_id/MTE name */ 1112 else if ^is_mte_name & (code = error_table_$no_dir) then 1113 call abort_parse (sci_ptr, saved_code, "^a", p_text); 1114 else call abort_parse (sci_ptr, code, "^a", pathname_ (mbx_dirname, mbx_ename)); 1115 end; 1116 end; /* looked like a pathname */ 1117 saved_mbx_ename = mbx_ename; 1118 if code = 0 then do; 1119 code =1; 1120 do idx = 1 to loop_idx while (code ^= 0); 1121 if use_search_paths then mbx_dirname = mlsys_search_list_ptr -> sl_info.paths(idx).pathname; 1122 1123 1124 1125 saved_mbx_dirname = mbx_dirname; /* needed in case nothing works */ 1126 saved_code = 0; /* this will be set later to describe first failure */ 1127 1128 trimmed_ename = rtrim (mbx_ename); /* needed for suffix checking */ 1129 1130 call check_star_name_$entry (mbx_ename, code); 1131 if (code = 1) | (code = 2) then code = error_table_$nostars; 1132 if code ^= 0 then do; /* bad entry name ... */ 1133 saved_code = code; 1134 go to TRY_USER_NAME_OR_MTE_HUERISTIC; /* ... is OK for now: might be an MTE name */ 1135 end; 1136 1137 if has_suffix (trimmed_ename, ".sv.mbx") | has_suffix (trimmed_ename, ".sv") then go to TRY_SAVEBOX_HUERISTIC; 1138 /* ends with ".sv" or ".sv.mbx": try first as a savebox */ 1139 1140 1141 /* Try it as an ordinary mailbox */ 1142 1143 mailbox_type = OTHER_MAILBOX; 1144 1145 if ^has_suffix (trimmed_ename, ".mbx") then do; /* need to add "mbx" suffix */ 1146 if (length (trimmed_ename) + length (".mbx")) > length (mbx_ename) then do; 1147 saved_code = error_table_$entlong; 1148 go to TRY_USER_NAME_OR_MTE_HUERISTIC; 1149 end; 1150 else mbx_ename = trimmed_ename || ".mbx"; 1151 end; 1152 1153 if mailbox_exists () then 1154 return; /* found it! */ 1155 else do; /* something went wrong */ 1156 saved_code = code; 1157 if trimmed_ename = mbx_ename then /* ... ends with ".mbx": don't try as a savebox */ 1158 go to TRY_USER_NAME_OR_MTE_HUERISTIC; 1159 end; 1160 1161 1162 /* Try it as a savebox */ 1163 1164 TRY_SAVEBOX_HUERISTIC: 1165 mailbox_type = SAVEBOX; 1166 1167 if has_suffix (trimmed_ename, ".sv.mbx") then ; 1168 else if has_suffix (trimmed_ename, ".sv") then do;/* need to add just ".mbx" suffix */ 1169 if (length (trimmed_ename) + length (".mbx")) > length (mbx_ename) then do; 1170 saved_code = error_table_$entlong; 1171 go to TRY_USER_NAME_OR_MTE_HUERISTIC; 1172 end; 1173 else mbx_ename = trimmed_ename || ".mbx"; 1174 end; 1175 else do; /* no suffix: have already tried it as a mailbox */ 1176 if (length (trimmed_ename) + length (".sv.mbx")) > length (mbx_ename) then 1177 go to TRY_USER_NAME_OR_MTE_HUERISTIC; 1178 mbx_ename = trimmed_ename || ".sv.mbx"; 1179 end; 1180 1181 if mailbox_exists () then 1182 return; /* found it! */ 1183 else do; /* something went wrong */ 1184 if saved_code = 0 then saved_code = code; 1185 end; 1186 1187 1188 /* Try it as a User_id or mail table entry (MTE) name */ 1189 1190 TRY_USER_NAME_OR_MTE_HUERISTIC: 1191 call get_user_mailbox_pathname (p_text, "1"b, not_user_name); 1192 if not_user_name & (idx = loop_idx) then do; /* doesn't look like a User_id or MTE name */ 1193 if use_search_paths then 1194 call abort_parse (sci_ptr, saved_code, "Looking in mlsys search paths for ^a^[.mbx^]", 1195 saved_mbx_ename, ^has_suffix (saved_mbx_ename, ".mbx")); 1196 else call abort_parse (sci_ptr, saved_code, "^a^[.mbx^]", pathname_ (saved_mbx_dirname, saved_mbx_ename), 1197 ^has_suffix (saved_mbx_ename, ".mbx")); 1198 end; 1199 1200 1201 if mailbox_exists () then return; /* found it! */ 1202 else if idx = loop_idx then 1203 if ^is_mte_name & (code = error_table_$no_dir) then 1204 call abort_parse (sci_ptr, saved_code, "^a^[.mbx^]", pathname_ (saved_mbx_dirname, saved_mbx_ename), 1205 ^has_suffix (saved_mbx_ename, ".mbx")); 1206 else call abort_parse (sci_ptr, code, "^a", pathname_ (mbx_dirname, mbx_ename)); 1207 mbx_ename = saved_mbx_ename; /* In case we go round again */ 1208 end; 1209 end; 1210 1211 1212 /* Internal to parse_mailbox_text_internal: checks if a given mailbox exists */ 1213 1214 mailbox_exists: 1215 procedure () returns (bit (1) aligned); 1216 1217 call mailbox_$open (mbx_dirname, mbx_ename, mailbox_idx, code); 1218 if code = error_table_$moderr then code = 0; 1219 1220 if mailbox_idx ^= 0 then call mailbox_$close (mailbox_idx, (0)); 1221 1222 return ((code = 0)); 1223 1224 end mailbox_exists; 1225 1226 end parse_mailbox_text_internal; 1227 1228 /* Get the pathname of an ordinary mailbox */ 1229 1230 get_mailbox_pathname: 1231 procedure (p_text); 1232 1233 dcl p_text character (*) parameter; 1234 1235 if search (p_text, "<>") > 0 then do; 1236 call expand_pathname_$add_suffix (p_text, "mbx", mbx_dirname, mbx_ename, code); 1237 if code ^= 0 then call abort_parse (sci_ptr, code, "^a", p_text); 1238 end; 1239 else do; 1240 /* phx21283, RL - modified following if/else statement to handle .mbx suffix correctly */ 1241 if ^has_suffix (p_text, ".mbx") then do; 1242 call suffixed_name_$make (p_text, "mbx", mbx_ename, code); 1243 if code ^= 0 then call abort_parse (sci_ptr, code, "^a", p_text); 1244 end; 1245 else 1246 mbx_ename = p_text; 1247 call search_paths_$find_dir ("mlsys", null(), mbx_ename, "", mbx_dirname, code); 1248 if code = error_table_$noentry then 1249 call expand_pathname_$add_suffix (p_text, "mbx", mbx_dirname, mbx_ename, code); 1250 if code ^= 0 then call abort_parse (sci_ptr, code, "Searching the ""mlsys"" searchlist for ^a.", mbx_ename); 1251 end; 1252 call check_star_name_$entry (mbx_ename, code); 1253 if code ^= 0 then 1254 if (code = 1) | (code = 2) then 1255 call abort_parse (sci_ptr, error_table_$nostars, "^a", pathname_ (mbx_dirname, mbx_ename)); 1256 else call abort_parse (sci_ptr, code, "^a", pathname_ (mbx_dirname, mbx_ename)); 1257 1258 mailbox_type = OTHER_MAILBOX; /* success */ 1259 1260 return; 1261 1262 end get_mailbox_pathname; 1263 1264 1265 1266 1267 /* Get the pathname of a savebox */ 1268 1269 get_savebox_pathname: 1270 procedure (p_text); 1271 1272 dcl p_text character (*) parameter; 1273 1274 if has_suffix (p_text, ".sv") then 1275 call expand_pathname_$add_suffix (p_text, "mbx", mbx_dirname, mbx_ename, code); 1276 else call expand_pathname_$add_suffix (p_text, "sv.mbx", mbx_dirname, mbx_ename, code); 1277 if code ^= 0 then call abort_parse (sci_ptr, code, "^a", p_text); 1278 1279 if search (p_text, "<>") = 0 then do; /* ... we were given a pathname */ 1280 mbx_dirname = ""; 1281 call search_paths_$find_dir ("mlsys", null(), mbx_ename, "", mbx_dirname, code); 1282 if code = error_table_$noentry then 1283 if has_suffix (p_text, ".sv") then 1284 call expand_pathname_$add_suffix (p_text, "mbx", mbx_dirname, mbx_ename, code); 1285 else call expand_pathname_$add_suffix (p_text, "sv.mbx", mbx_dirname, mbx_ename, code); 1286 if code ^= 0 then call abort_parse (sci_ptr, code, "Searching the ""mlsys"" searchlist for ^a.", mbx_ename); 1287 end; 1288 1289 call check_star_name_$entry (mbx_ename, code); 1290 if code ^= 0 then 1291 if (code = 1) | (code = 2) then 1292 call abort_parse (sci_ptr, error_table_$nostars, "^a", pathname_ (mbx_dirname, mbx_ename)); 1293 else call abort_parse (sci_ptr, code, "^a", pathname_ (mbx_dirname, mbx_ename)); 1294 1295 mailbox_type = SAVEBOX; /* success */ 1296 1297 return; 1298 1299 end get_savebox_pathname; 1300 1301 /* Get the pathname of the mailbox for the given user name which might be a mail table entry (MTE) name */ 1302 1303 get_user_mailbox_pathname: 1304 procedure (p_name, p_ok_if_not_user_name, p_not_user_name); 1305 1306 dcl p_name character (*) parameter; 1307 dcl p_ok_if_not_user_name bit (1) aligned parameter; /* ON => don't abort if given name isn't a User_id/MTE name */ 1308 dcl p_not_user_name bit (1) aligned parameter; /* set ON => supplied name isn't User_id/MTE name */ 1309 1310 call mlsys_user_mte_syntax_$classify_and_validate ((p_name), is_mte_name, person_id, project_id, code); 1311 if code ^= 0 then /* bad syntax ... */ 1312 if p_ok_if_not_user_name then do; /* ... is OK when doing pathname hueristic */ 1313 p_not_user_name = "1"b; 1314 return; 1315 end; 1316 else call abort_parse (sci_ptr, code, "^a", p_name); 1317 1318 if is_mte_name then do; /* a mail table entry */ 1319 /*** following call won't fail because the syntax has already been verified */ 1320 call mail_system_$create_mail_table_address ((p_name), "", "", mte_address_ptr, (0)); 1321 call mail_system_$get_mail_table_address (mte_address_ptr, target_address_ptr, code); 1322 if code = mlsys_et_$mte_not_found then /* ... no entry in the mail table ... */ 1323 if p_ok_if_not_user_name then do; /* ... is OK when doing pathname hueristic */ 1324 p_not_user_name = "1"b; 1325 return; 1326 end; 1327 if code ^= 0 then call abort_parse (sci_ptr, code, "^a", p_name); 1328 call mail_system_$get_address_type (target_address_ptr, address_type, (0)); 1329 if (address_type ^= USER_MAILBOX_ADDRESS) & (address_type ^= LOGBOX_ADDRESS) 1330 & (address_type ^= SAVEBOX_ADDRESS) & (address_type ^= MAILBOX_ADDRESS) then 1331 call abort_parse (sci_ptr, mlsys_et_$mte_not_mailbox, "^a", p_name); 1332 call mail_system_$get_address_pathname (target_address_ptr, mbx_dirname, mbx_ename, ((32)" "), (0)); 1333 if (address_type = USER_MAILBOX_ADDRESS) | (address_type = MAILBOX_ADDRESS) then 1334 mailbox_type = OTHER_MAILBOX; 1335 else if address_type = LOGBOX_ADDRESS then mailbox_type = USER_LOGBOX; 1336 else /*** if address_type = SAVEBOX_ADDRESS then */ 1337 mailbox_type = SAVEBOX; 1338 end; 1339 1340 else do; /* a User_id (Person_id.Project_id) */ 1341 mailbox_type = OTHER_MAILBOX; /* ... don't try to create it */ 1342 mbx_dirname = ">udd>" || rtrim (project_id) || ">" || person_id; 1343 mbx_ename = rtrim (person_id) || ".mbx"; 1344 end; 1345 1346 p_not_user_name = "0"b; /* get here iff all is OK */ 1347 1348 return; 1349 1350 end get_user_mailbox_pathname; 1351 1352 /* Aborts the parse: For the parse_mailbox_text entrypoint, it sets the return code; for all other entrpyoints, it prints 1353* the given message */ 1354 1355 abort_parse: 1356 procedure () options (variable); 1357 1358 dcl code fixed binary (35) based (code_ptr); 1359 dcl code_ptr pointer; 1360 1361 if sci_ptr = null () then do; /* return the error code to the caller */ 1362 call cu_$arg_ptr (2, code_ptr, (0), (0)); 1363 P_code = code; 1364 end; 1365 1366 else do; /* print the error message */ 1367 if parse_ca_options.abort_on_errors then 1368 call cu_$generate_call (ssu_$abort_line, cu_$arg_list_ptr ()); 1369 else call cu_$generate_call (ssu_$print_message, cu_$arg_list_ptr ()); 1370 end; 1371 1372 go to abort_the_parse; /* go perform appropriate cleanup */ 1373 1374 end abort_parse; 1375 1376 1377 1378 /* Fetch the next argument */ 1379 1380 get_next_argument: 1381 procedure (p_string); 1382 1383 dcl p_string character (*) parameter; /* for error messages if not present */ 1384 1385 if (argument_idx = n_arguments) then 1386 call abort_parse (sci_ptr, error_table_$noarg, "^a must be given after ""^a"".", p_string, argument); 1387 1388 argument_idx = argument_idx + 1; 1389 1390 call ssu_$arg_ptr (sci_ptr, argument_idx, argument_ptr, argument_lth); 1391 1392 return; 1393 1394 end get_next_argument; 1395 1396 /* Returns "1"b if the given suffix is present on the supplied name */ 1397 1398 dcl has_suffix 1399 generic (has_suffix_varying when (character (*) varying, character (*)), 1400 has_suffix_nonvarying when (character (*), character (*))); 1401 1402 1403 has_suffix_nonvarying: 1404 procedure (p_name, p_suffix) returns (bit (1) aligned); 1405 1406 dcl (p_name, p_suffix) character (*) parameter; 1407 1408 return ((index (reverse (rtrim (p_name)), reverse (p_suffix)) = 1)); 1409 1410 end has_suffix_nonvarying; 1411 1412 1413 has_suffix_varying: 1414 procedure (p_name, p_suffix) returns (bit (1) aligned); 1415 1416 dcl p_name character (*) varying parameter; 1417 dcl p_suffix character (*) parameter; 1418 1419 return ((index (reverse (p_name), reverse (p_suffix)) = 1)); 1420 1421 end has_suffix_varying; 1422 1 1 /* BEGIN INCLUDE FILE ... mlsys_parse_ca_options.incl.pl1 */ 1 2 /* Created: June 1983 by G. Palter */ 1 3 /* Modified: March 1984 by G. Palter to remove ignore_log_save option */ 1 4 1 5 /* Options for the mlsys_utils_$parse_address_control_arguments, mlsys_utils_$parse_address_list_control_arguments, and 1 6* mlsys_utils_$parse_mailbox_control_arguments entrypoints */ 1 7 1 8 dcl 1 parse_ca_options aligned based (parse_ca_options_ptr), 1 9 2 version character (8) unaligned, 1 10 2 logbox_creation_mode fixed binary, /* specifies the action to be taken if the address/mailbox is 1 11* the user's logbox, address/mailbox validation is requested, 1 12* and the logbox does not exist */ 1 13 2 savebox_creation_mode fixed binary, /* ... same as above but for any savebox */ 1 14 2 flags, 1 15 3 abort_on_errors bit (1) unaligned, /* ON => use ssu_$abort_line to report errors (ie: abort on 1 16* the first error); OFF => use ssu_$print_message */ 1 17 3 validate_addresses bit (1) unaligned, /* ON => validate the existence of the address/mailbox; 1 18* OFF => only validate the command/request line syntax */ 1 19 3 mbz bit (34) unaligned; /* must be set to ""b by the caller */ 1 20 1 21 dcl PARSE_CA_OPTIONS_VERSION_1 character (8) static options (constant) initial ("mlspca01"); 1 22 1 23 dcl parse_ca_options_ptr pointer; 1 24 1 25 1 26 /* Defined logbox/savebox creation modes */ 1 27 1 28 dcl (DONT_CREATE_MAILBOX initial (0), /* do not create the mailbox and issue an error message */ 1 29 QUERY_TO_CREATE_MAILBOX initial (1), /* ask the user for permission to create the mailbox */ 1 30 CREATE_AND_ANNOUNCE_MAILBOX initial (2), /* create the mailbox and inform the user of this action */ 1 31 SILENTLY_CREATE_MAILBOX initial (3)) /* create the mailbox but don't inform the user */ 1 32 fixed binary static options (constant); 1 33 1 34 /* END INCLUDE FILE ... mlsys_parse_ca_options.incl.pl1 */ 1423 1424 2 1 /* BEGIN INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 2 2 /* Created: June 1983 by G. Palter */ 2 3 2 4 /* Definition of an address list -- a collection of addresses used as the value of certain message fields, etc. */ 2 5 2 6 dcl 1 address_list aligned based (address_list_ptr), 2 7 2 version character (8) unaligned, 2 8 2 reserved bit (144), /* ... exclusively for use by the mail system */ 2 9 2 n_addresses fixed binary, /* # of address in this list */ 2 10 2 addresses (address_list_n_addresses refer (address_list.n_addresses)) pointer; 2 11 2 12 dcl ADDRESS_LIST_VERSION_2 character (8) static options (constant) initial ("mlsals02"); 2 13 2 14 dcl address_list_ptr pointer; 2 15 2 16 dcl address_list_n_addresses fixed binary; /* reserved exclusively for use by the mail system */ 2 17 2 18 /* END INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 1425 1426 3 1 /* BEGIN INCLUDE FILE ... mlsys_address_types.incl.pl1 */ 3 2 /* Created: June 1983 by G. Palter */ 3 3 3 4 /* Types of addresses supported by the Multics Mail System */ 3 5 3 6 dcl (INVALID_ADDRESS initial (0), /* a syntactically invalid address: used as a place holder 3 7* when parsing printed representations */ 3 8 USER_MAILBOX_ADDRESS initial (1), /* identifies a user's default mailbox */ 3 9 LOGBOX_ADDRESS initial (2), /* identifies a user's logbox */ 3 10 SAVEBOX_ADDRESS initial (3), /* identifies one of a user's saveboxes by pathname */ 3 11 MAILBOX_ADDRESS initial (4), /* identifies some other mailbox by pathname */ 3 12 FORUM_ADDRESS initial (5), /* identifies a forum meeting by pathname */ 3 13 FOREIGN_ADDRESS initial (6), /* identifies a user (or group) on another compute system */ 3 14 MAIL_TABLE_ADDRESS initial (7), /* identifies an entry in the system's mail table */ 3 15 MAILING_LIST_ADDRESS initial (8), /* identifies a mailing list by pathname */ 3 16 NAMED_GROUP_ADDRESS initial (9)) /* identifies a named group of addresses */ 3 17 fixed binary static options (constant); 3 18 3 19 /* END INCLUDE FILE ... mlsys_address_types.incl.pl1 */ 1427 1428 4 1 /* BEGIN INCLUDE FILE ... mlsys_address_route.incl.pl1 */ 4 2 /* Created: June 1983 by G. Palter */ 4 3 4 4 /* Definition of a mail system address route */ 4 5 4 6 dcl 1 address_route aligned based (address_route_ptr), 4 7 2 header, 4 8 3 version character (8) unaligned, 4 9 3 reserved bit (144), /* ... exclusively for use by the mail system */ 4 10 3 n_relays fixed binary, /* # of relay systems in the route */ 4 11 2 relays (address_route_n_relays refer (address_route.n_relays)) character (256) varying; 4 12 /* the relays: relays(1) is closest to the local host */ 4 13 4 14 dcl ADDRESS_ROUTE_VERSION_1 character (8) static options (constant) initial ("mlsrte01"); 4 15 4 16 dcl address_route_ptr pointer; 4 17 4 18 dcl address_route_n_relays fixed binary; /* for allocating above structure (users do on occasion) */ 4 19 4 20 /* END INCLUDE FILE ... mlsys_address_route.incl.pl1 */ 1429 1430 5 1 /* BEGIN INCLUDE FILE ... mlsys_data.incl.pl1 */ 5 2 /* Created: 20 Decembber 1978 by G. Palter */ 5 3 /* Modified: 1 July 1983 by G. Palter to merge with mlsys_internal_data_ */ 5 4 5 5 /* Constants defined by the Multics mail system for external use */ 5 6 5 7 dcl mlsys_data_$system_directory character (168) external; /* directory containing per-system data (mail table/queues) */ 5 8 5 9 5 10 /* Static data defined by the Multics mail system for external use */ 5 11 5 12 dcl mlsys_data_$user_default_mailbox_address pointer external; 5 13 /* -> the address of the user's default mailbox */ 5 14 dcl mlsys_data_$user_mail_table_address pointer external; /* -> the address of the user's entry in the mail table */ 5 15 dcl mlsys_data_$user_logbox_address pointer external; /* -> the address of the user's logbox */ 5 16 5 17 /* END INCLUDE FILE ... mlsys_data.incl.pl1 */ 1431 1432 6 1 /* BEGIN INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 6 2 6 3 6 4 /****^ HISTORY COMMENTS: 6 5* 1) change(86-06-11,Mills), approve(86-06-11,MCR7419), 6 6* audit(86-06-17,Margolin), install(86-06-30,MR12.0-1080): 6 7* Added mlsys_data_$domains_available. 6 8* END HISTORY COMMENTS */ 6 9 6 10 6 11 /* Created: May 1981 by G. Palter */ 6 12 /* Modified: July 1983 by G. Palter to merge with mlsys_data_ */ 6 13 6 14 /* Constants used internally by the Multics mail system */ 6 15 6 16 dcl mlsys_data_$max_opening_retries fixed binary external; /* maximum number of times to reopen a mailbox if it gets 6 17* damaged and salvaged while open */ 6 18 6 19 dcl mlsys_data_$max_lock_wait_retries fixed binary external; 6 20 /* maximum number of times to try to send a message while the 6 21* mailbox is locked (being salvaged?) */ 6 22 6 23 6 24 /* Allocation overhead factors: When allocating those structures with refer extents, insure that the variable portion of 6 25* the structure contains a multiple of the appropriate constant number of slots. These extra slots will be used for 6 26* later additions to the structure; when a new element must be added to a full structure, add this many new slots (rather 6 27* than a single new slot) 6 28* 6 29* The following expression should be used to determine the initial allocation: 6 30* 6 31* n_slots_to_allocate = n_slots_needed + CONSTANT - mod (n_slots_needed, CONSTANT); */ 6 32 6 33 dcl (mlsys_data_$mailbox_allocation, /* mailbox.messages */ 6 34 mlsys_data_$message_body_sections_allocation, /* message.body_sections */ 6 35 mlsys_data_$message_redistributions_list_allocation, /* message_redistributions_list.redistributions */ 6 36 mlsys_data_$message_user_fields_allocation, /* message_user_fields_list.user_fields */ 6 37 mlsys_data_$message_references_list_allocation, /* message_references_list.references */ 6 38 mlsys_data_$address_list_allocation) /* address_list.addresses */ 6 39 fixed binary external; 6 40 6 41 6 42 /* Static data user by the Multics mail system */ 6 43 6 44 dcl (mlsys_data_$forum_not_available, /* 1 => forum isn't available on the system or in this ring */ 6 45 mlsys_data_$ism_not_available, /* 1 => no inter-system mailer on this system */ 6 46 mlsys_data_$domains_available) /* 1 => domain name system software on this sytem */ 6 47 fixed binary (1) external; 6 48 6 49 dcl (mlsys_data_$subsystem_ring, /* ring in which the mail system is secured */ 6 50 mlsys_data_$highest_usable_ring, /* highest ring of execution which may use the mail system */ 6 51 mlsys_data_$lowest_forum_ring) /* lowest ring of execution with access to forum */ 6 52 fixed binary (3) external; 6 53 6 54 dcl mlsys_data_$temp_segment_list_ptr pointer external; /* -> list of all mail system temporary segments */ 6 55 6 56 dcl mlsys_data_$valid_segments (0:4095) bit (1) unaligned external; 6 57 /* indicates which segments have been used by the mail system 6 58* for the allocation of user-visible data in order to 6 59* validate that pointers passed from the user-ring are OK */ 6 60 6 61 dcl mlsys_area area based (mlsys_data_$subsystem_area_ptr);/* area used for all user-visible allocations ... */ 6 62 dcl mlsys_data_$subsystem_area_ptr pointer external; /* ... and the pointer on which it is based */ 6 63 6 64 dcl mlsys_data_$hash_tables_segment_ptr pointer external; /* -> hash tables used by the mail system */ 6 65 6 66 dcl mlsys_data_$transmit_cache_ptr pointer external; /* -> cache of recently used mailboxes for mlsys_transmit_ */ 6 67 6 68 dcl mlsys_data_$user_is_anonymous bit (1) aligned external;/* ON => the user is an anonymous user */ 6 69 6 70 dcl mlsys_data_$person_id character (24) varying external; /* the user's Person_id */ 6 71 dcl mlsys_data_$project_id character (12) varying external;/* the user's Project_id */ 6 72 dcl mlsys_data_$user_id character (32) varying external; /* the user's User_id (Person_id.Project_id) */ 6 73 6 74 /* END INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 1433 1434 7 1 /* BEGIN INCLUDE FILE . . . sl_info.incl.pl1 */ 7 2 7 3 7 4 7 5 /****^ HISTORY COMMENTS: 7 6* 1) change(87-11-16,Lippard), approve(87-12-21,MCR7822), 7 7* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 7 8* Modified to add INITIATED_SEGS type. 7 9* 2) change(87-11-19,Lippard), approve(87-12-21,MCR7822), 7 10* audit(88-02-09,Blair), install(88-02-16,MR12.2-1023): 7 11* Added uid to sl_info structure. 7 12* END HISTORY COMMENTS */ 7 13 7 14 7 15 declare 1 sl_info aligned based (sl_info_p), 7 16 2 version fixed binary, /* Must be 1 */ 7 17 2 num_paths fixed binary, /* Number of search paths */ 7 18 2 change_index_p pointer, /* Pointer to search list's update count */ 7 19 2 change_index fixed binary (71), /* This search list's update count */ 7 20 2 pad1 (6) bit (36), /* Must be zero */ 7 21 2 paths (sl_info_num_paths refer (sl_info.num_paths)), 7 22 3 type fixed binary, /* Type of search path */ 7 23 3 code fixed binary (35), /* Standard status code of search path */ 7 24 3 uid bit (36), /* Unique ID */ 7 25 3 pathname char (168) unaligned; /* Search pathname */ 7 26 7 27 declare sl_info_num_paths fixed binary; 7 28 declare sl_info_p pointer; 7 29 declare sl_info_version_1 fixed binary internal static options (constant) initial (1); 7 30 7 31 /* Keyword Types */ 7 32 7 33 declare ABSOLUTE_PATH fixed binary internal static options (constant) initial (0); 7 34 declare UNEXPANDED_PATH fixed binary internal static options (constant) initial (1); 7 35 declare REFERENCING_DIR fixed binary internal static options (constant) initial (3); 7 36 declare WORKING_DIR fixed binary internal static options (constant) initial (4); 7 37 declare PROCESS_DIR fixed binary internal static options (constant) initial (5); 7 38 declare HOME_DIR fixed binary internal static options (constant) initial (6); 7 39 declare INITIATED_SEGS fixed binary internal static options (constant) initial (7); 7 40 7 41 /* END INCLUDE FILE . . . sl_info.incl.pl1 */ 1435 1436 8 1 /* BEGIN INCLUDE FILE . . . sl_control_s.incl.pl1 */ 8 2 8 3 declare 1 sl_control_s unaligned based (addr (sl_control)), 8 4 2 af_pathname bit (1), /* "1"b => expand active functions */ 8 5 2 pad1 bit (1), /* Must be zero */ 8 6 2 key_ref_dir bit (1), /* "1"b => expand -referencing_dir keyword */ 8 7 2 key_work_dir bit (1), /* "1"b => expand -working_dir keyword */ 8 8 2 key_proc_dir bit (1), /* "1"b => expand -process_dir keyword */ 8 9 2 key_home_dir bit (1), /* "1"b => expand -home_dir keyword */ 8 10 2 pad2 bit (30); /* Must be zero */ 8 11 8 12 declare sl_control bit (36); 8 13 declare sl_control_default bit (36) internal static options (constant) initial ("101111"b); 8 14 8 15 /* END INCLUDE FILE . . . sl_control_s.incl.pl1 */ 1437 1438 1439 end mlsys_parse_control_args_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1108.8 mlsys_parse_control_args_.pl1 >udd>sm>ds>w>ml>mlsys_parse_control_args_.pl1 1423 1 06/18/84 1424.1 mlsys_parse_ca_options.incl.pl1 >ldd>incl>mlsys_parse_ca_options.incl.pl1 1425 2 10/27/83 2204.2 mlsys_address_list.incl.pl1 >ldd>incl>mlsys_address_list.incl.pl1 1427 3 10/27/83 2204.2 mlsys_address_types.incl.pl1 >ldd>incl>mlsys_address_types.incl.pl1 1429 4 10/27/83 2204.2 mlsys_address_route.incl.pl1 >ldd>incl>mlsys_address_route.incl.pl1 1431 5 10/27/83 2204.2 mlsys_data.incl.pl1 >ldd>incl>mlsys_data.incl.pl1 1433 6 06/30/86 2123.8 mlsys_internal_data.incl.pl1 >ldd>incl>mlsys_internal_data.incl.pl1 1435 7 02/18/88 2123.8 sl_info.incl.pl1 >ldd>incl>sl_info.incl.pl1 1437 8 01/09/79 1717.9 sl_control_s.incl.pl1 >ldd>incl>sl_control_s.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_ROUTE_VERSION_1 000002 constant char(8) initial packed unaligned dcl 4-14 ref 784 CREATE_AND_ANNOUNCE_MAILBOX constant fixed bin(17,0) initial dcl 1-28 ref 829 1000 DONT_CREATE_MAILBOX constant fixed bin(17,0) initial dcl 1-28 ref 221 221 292 292 815 816 920 920 980 989 FOREIGN_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 553 561 749 773 FORUM_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 459 628 LOGBOX_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 337 379 438 573 740 744 813 820 825 1329 1335 MAILBOX_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 452 538 605 1329 1333 MAILING_LIST_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 466 MAIL_TABLE_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 533 546 701 MBX_USER_OR_MTE_ADDRESS 017027 constant fixed bin(17,0) initial dcl 124 ref 474 538 553 NULL_STRING 000026 constant char(1) initial packed unaligned dcl 121 set ref 485 OTHER_MAILBOX constant fixed bin(17,0) initial dcl 128 ref 980 1143 1258 1333 1341 PARSE_CA_OPTIONS_VERSION_1 000004 constant char(8) initial packed unaligned dcl 1-21 ref 216 287 915 P_address_list_version parameter char(8) packed unaligned dcl 66 set ref 279 337* 340* 379* 382* P_address_ptr parameter pointer dcl 61 set ref 209 258* P_argument_idx parameter fixed bin(17,0) dcl 53 set ref 209 213 259* 279 284 354* 908 912 1024* P_code parameter fixed bin(35,0) dcl 56 set ref 209 217* 226* 260* 279 288* 297* 306* 356* 358* 360* 908 916* 925* 1025* 1043 1065* 1363* P_logsave_address_list_ptr parameter pointer dcl 68 set ref 279 301 301 337* 379* P_mailbox_dirname parameter char packed unaligned dcl 73 set ref 908 1020* 1043 1063* P_mailbox_ename parameter char packed unaligned dcl 74 set ref 908 1021* 1043 1064* P_mailbox_text parameter char packed unaligned dcl 79 set ref 1043 1061* P_normal_address_list_ptr parameter pointer dcl 67 set ref 279 301 301 301 340* 382* P_parse_ca_options_ptr parameter pointer dcl 55 ref 209 215 279 286 908 914 P_sci_ptr parameter pointer dcl 52 ref 209 212 279 283 908 911 QUERY_TO_CREATE_MAILBOX constant fixed bin(17,0) initial dcl 1-28 ref 819 990 SAVEBOX constant fixed bin(17,0) initial dcl 128 ref 1164 1295 1336 SAVEBOX_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 337 379 445 581 740 814 1329 SILENTLY_CREATE_MAILBOX constant fixed bin(17,0) initial dcl 1-28 ref 221 221 292 292 920 920 STACK_EXTENSION 000006 constant fixed bin(18,0) initial dcl 119 set ref 750* 751 760* 761 USER_LOGBOX constant fixed bin(17,0) initial dcl 128 ref 961 981 991 996 1335 USER_MAILBOX_ADDRESS constant fixed bin(17,0) initial dcl 3-6 ref 535 548 565 1329 1333 USER_OR_MTE_ADDRESS 017030 constant fixed bin(17,0) initial dcl 124 ref 432 528 553 abort_on_errors 4 based bit(1) level 3 packed packed unaligned dcl 1-8 ref 373 1367 abort_the_parse 000200 automatic label variable dcl 106 set ref 240* 320* 942* 1059* 1372 addr builtin function dcl 203 ref 248 248 301 301 333 333 485 791 791 address_buffer_lth 000116 automatic fixed bin(21,0) dcl 407 set ref 751* 756* 761* 761 address_buffer_ptr 000114 automatic pointer dcl 406 set ref 737* 750* 756* 764 801 801* address_buffer_used 000117 automatic fixed bin(21,0) dcl 407 set ref 755* 756* 765 address_comment based char packed unaligned dcl 402 ref 566 574 596 619 691 702 723 791 794 address_comment_lth 000112 automatic fixed bin(21,0) dcl 404 set ref 487* 516* 566 574 596 619 691 702 723 791 794 address_comment_ptr 000106 automatic pointer dcl 403 set ref 485* 515* 566 574 596 619 691 702 723 791 794 address_component 000303 automatic char(32) packed unaligned dcl 411 set ref 711* 717* 722* 723* 726* 728* 728* address_dirname 000221 automatic char(168) packed unaligned dcl 410 set ref 585* 586* 591* 595* 596* 599* 601* 601* 609* 610* 615* 618* 619* 622* 624* 624* 638* 649* 653* 657* 662* 668* 670* 670* 674* 682* 691* 694* 696 696* 696* 711* 715* 716* 717* 722* 723* 726* 728* 728* 741* 743* 744* 744* 817* 820* 820* 827* 829* 829* address_ename 000273 automatic char(32) packed unaligned dcl 411 set ref 584* 585* 586* 588* 591* 595* 596* 599* 601* 601* 607* 609* 610* 612* 615* 618* 619* 622* 624* 624* 631 633* 634* 634* 634 634 634* 637* 649* 649* 649* 652 654* 659* 668* 670* 670* 670 670 670* 670* 674* 678* 678* 680 681* 682* 684 684* 691* 694* 696* 696* 696* 711* 716* 717* 720* 722* 723* 726* 728* 728* 741* 743* 744* 744* 817* 820* 820* 827* 829* 829* address_name based char packed unaligned dcl 401 ref 566 574 596 619 691 702 723 791 794 address_name_lth 000111 automatic fixed bin(21,0) dcl 404 set ref 487* 510* 566 574 596 619 691 702 723 791 794 address_name_ptr 000104 automatic pointer dcl 403 set ref 485* 509* 566 574 596 619 691 702 723 791 794 address_ptr 000106 automatic pointer dcl 90 set ref 230* 235 235* 258 310* 315 315* 336* 337* 340* 343* 377 378* 379* 382* 384* 566* 569* 574* 577* 596* 599* 619* 622* 691* 694* 702* 705* 723* 726* 741* 742* 743* 756* 766* 791* 794* 808* 812* 817* 838* address_route based structure level 1 dcl 4-6 address_string based char packed unaligned dcl 400 set ref 530 531* 538 542 544* 566 569 570* 582* 583 584* 586* 591* 592* 606 607* 608* 610* 615* 616* 629 631 631* 633 668* 669* 702 705 706* 711* 713* 714 717* 791 794 798* address_string_lth 000110 automatic fixed bin(21,0) dcl 404 set ref 434* 440* 447* 454* 461* 468* 476* 530 531 531 538 542 544 544 566 569 570 570 582 582 582* 582 583 584 584 586 586 591 591 592 592 606 607 607 608 608 610 610 615 615 616 616 629 631 631 631 633 668 668 669 669 702 705 706 706 711 711 713 713 714 717 717 765* 791 794 798 798 address_string_ptr 000102 automatic pointer dcl 403 set ref 433* 439* 446* 453* 460* 467* 475* 530 531 538 542 544 566 569 570 582 583 584 586 591 592 606 607 608 610 615 616 629 631 631 633 668 669 702 705 706 711 713 714 717 764* 791 794 798 address_type 000330 automatic fixed bin(17,0) dcl 417 in procedure "parse_single_address" set ref 812* 813 814 820 825 address_type 000204 automatic fixed bin(17,0) dcl 108 in procedure "mlsys_parse_control_args_" set ref 336* 337 337 378* 379 379 1328* 1329 1329 1329 1329 1333 1333 1335 argument based char packed unaligned dcl 98 set ref 274* 429 429 437 443 443 450 450 457 457 464 464 495 495 495 495 495 495 501 501 507 507 513 513 776 788 949 949 949 952* 955 957* 960 967 967 969* 972* 975* 1385* argument_idx 000102 automatic fixed bin(17,0) dcl 85 set ref 213* 259 284* 332 334* 334 354 371* 371 427* 489 493 499* 499 504 519 912* 946* 1024 1385 1388* 1388 1390* argument_lth 000174 automatic fixed bin(21,0) dcl 100 set ref 274 274 427* 429 429 434 437 443 443 447 450 450 454 457 457 461 464 464 468 476 493* 495 495 495 495 495 495 501 501 507 507 510 513 513 516 775* 776 787* 788 946* 949 949 949 952 952 955 957 957 960 967 967 969 969 972 972 975 975 1385 1385 1390* argument_ptr 000172 automatic pointer dcl 99 set ref 274 427* 429 429 433 437 443 443 446 450 450 453 457 457 460 464 464 467 475 493* 495 495 495 495 495 495 501 501 507 507 509 513 513 515 775* 776 787* 788 946* 949 949 949 952 955 957 960 967 967 969 972 975 1385 1390* check_star_name_$entry 000046 constant entry external dcl 140 ref 857 858 1130 1252 1289 cleanup 000244 stack reference condition dcl 205 ref 233 313 934 1051 code 000103 automatic fixed bin(35,0) dcl 86 in procedure "mlsys_parse_control_args_" set ref 251* 260 267* 323* 337* 340* 342 356 356 369* 530* 531 531* 542* 544 544* 566* 569* 570 570* 574* 577* 578 578* 584* 585* 586 586* 588 588* 591* 592 592* 596* 599* 601 601* 607* 608 608* 609* 610 610* 612 612* 615* 616 616* 619* 622* 624 624* 644* 646 646* 649* 653* 654 657* 659 662 668* 669 669* 682* 684 691* 694* 696 696* 702* 705* 706 706* 711* 713 713* 716* 717 717* 720 720* 723* 726* 728 728* 743* 744 744* 753* 754 756* 758 791* 794* 798 798* 808* 810 825* 827* 829 833 833* 837 838* 986* 987 987* 989 996* 998* 1000 1003 1003* 1006 1006* 1010* 1025 1032* 1099* 1106* 1107 1108 1112 1114* 1118 1119* 1120 1130* 1131 1131 1131* 1132 1133 1156 1184 1202 1206* 1217* 1218 1218* 1222 1236* 1237 1237* 1242* 1243 1243* 1247* 1248 1248* 1250 1250* 1252* 1253 1253 1253 1256* 1274* 1276* 1277 1277* 1281* 1282 1282* 1285* 1286 1286* 1289* 1290 1290 1290 1293* 1310* 1311 1316* 1321* 1322 1327 1327* code based fixed bin(35,0) dcl 1358 in procedure "abort_parse" ref 1363 code 15 based fixed bin(35,0) array level 3 in structure "sl_info" dcl 7-15 in procedure "mlsys_parse_control_args_" ref 894 code 000340 automatic fixed bin(35,0) dcl 855 in procedure "reject_starnames" set ref 857* 858 858* 861 861 861* 863 863* 866* code_ptr 000100 automatic pointer dcl 1359 set ref 1362* 1363 command_query_$yes_no 000050 constant entry external dcl 141 ref 820 991 continue_to_peek 000324 automatic bit(1) dcl 414 set ref 489* 491 519* 522* creation_mode 000104 automatic fixed bin(17,0) dcl 88 set ref 813* 814* 815* 816 819 829 980* 981* 982* 989 990 1000 cu_$arg_list_ptr 000052 constant entry external dcl 142 ref 1367 1367 1369 1369 cu_$arg_ptr 000054 constant entry external dcl 143 ref 1362 cu_$generate_call 000056 constant entry external dcl 144 ref 1367 1369 cu_$grow_stack_frame 000060 constant entry external dcl 145 ref 750 760 cu_$shrink_stack_frame 000062 constant entry external dcl 146 ref 801 ename 000100 automatic char(32) initial packed unaligned dcl 883 set ref 883* 886 error_table_$bad_subr_arg 000010 external static fixed bin(35,0) dcl 133 ref 226 297 306 925 error_table_$badopt 000012 external static fixed bin(35,0) dcl 133 set ref 274* 972* error_table_$entlong 000014 external static fixed bin(35,0) dcl 133 set ref 631* 634* 670* 887 1147 1170 error_table_$moderr 000016 external static fixed bin(35,0) dcl 133 ref 987 1218 error_table_$no_dir 000026 external static fixed bin(35,0) dcl 133 ref 1112 1202 error_table_$noarg 000020 external static fixed bin(35,0) dcl 133 set ref 1385* error_table_$noentry 000022 external static fixed bin(35,0) dcl 133 ref 586 610 717 989 1248 1282 error_table_$nostars 000024 external static fixed bin(35,0) dcl 133 set ref 861 1131 1253* 1290* error_table_$smallarg 000032 external static fixed bin(35,0) dcl 133 ref 753 754 758 error_table_$unimplemented_version 000030 external static fixed bin(35,0) dcl 133 ref 217 288 916 errors_detected 000236 automatic bit(1) dcl 114 set ref 322* 358 367* expand_pathname_ 000064 constant entry external dcl 147 ref 668 1106 expand_pathname_$add_suffix 000066 constant entry external dcl 148 ref 586 591 610 615 1236 1248 1274 1276 1282 1285 expand_pathname_$component_add_suffix 000070 constant entry external dcl 149 ref 711 717 flags 4 based structure level 2 dcl 1-8 foreign_system_name 000120 automatic varying char(256) dcl 409 set ref 776* 791* 794* 798* forum_$get_forum_path 000072 constant entry external dcl 151 ref 682 894 forum_search_list_ptr 000242 automatic pointer dcl 117 set ref 230* 236 236 237* 254 254 256* 310* 316 316 317* 350 350 352* 643 644* 893 894 894 897 get_system_free_area_ 000074 constant entry external dcl 152 ref 231 311 1097 has_suffix generic function dcl 1398 ref 582 634 634 649 649 670 670 678 678 1137 1137 1145 1167 1168 1193 1196 1202 1241 1274 1282 header based structure level 2 in structure "address_route" dcl 4-6 in procedure "mlsys_parse_control_args_" header 000100 automatic structure level 2 in structure "local_address_route" dcl 780 in begin block on line 778 host_indeces 000100 automatic fixed bin(17,0) array dcl 330 in begin block on line 327 set ref 333 333 host_indeces 000100 automatic fixed bin(17,0) array dcl 246 in begin block on line 244 set ref 248 248 host_indeces based fixed bin(17,0) array dcl 397 in procedure "parse_single_address" set ref 504* 775* 787* idx 000373 automatic fixed bin(17,0) dcl 1093 in procedure "parse_mailbox_text_internal" set ref 1120* 1121 1192 1202* idx 000331 automatic fixed bin(17,0) dcl 417 in procedure "parse_single_address" set ref 786* 787 788* idx 000110 automatic fixed bin(17,0) dcl 884 in procedure "search_forum_list" set ref 893* 894 894 897* include_name_and_comment 000325 automatic bit(1) dcl 414 set ref 563* 566 574 596 619 691 702 723 index builtin function dcl 203 ref 429 949 1408 1419 is_mte_name 000237 automatic bit(1) dcl 114 set ref 530* 533 542* 546 1112 1202 1310* 1318 length builtin function dcl 203 ref 582 631 631 634 634 634 670 670 670 684 684 684 886 886 1146 1146 1146 1169 1169 1169 1176 1176 1176 local_address_route 000100 automatic structure level 1 dcl 780 set ref 791 791 logbox_creation_mode 2 based fixed bin(17,0) level 2 dcl 1-8 ref 221 221 292 292 813 920 920 981 loop_idx 000372 automatic fixed bin(17,0) dcl 1092 set ref 1100* 1105* 1120 1192 1202 mail_system_$add_address 000076 constant entry external dcl 153 ref 337 340 379 382 mail_system_$create_foreign_address 000100 constant entry external dcl 154 ref 791 794 mail_system_$create_forum_address 000102 constant entry external dcl 157 ref 691 694 mail_system_$create_logbox_address 000104 constant entry external dcl 159 ref 574 577 mail_system_$create_mail_table_address 000106 constant entry external dcl 161 ref 702 705 1320 mail_system_$create_mailbox_address 000110 constant entry external dcl 163 ref 619 622 743 mail_system_$create_mailing_list_address 000112 constant entry external dcl 165 ref 723 726 mail_system_$create_savebox_address 000114 constant entry external dcl 168 ref 596 599 mail_system_$create_user_mailbox_address 000116 constant entry external dcl 171 ref 566 569 mail_system_$free_address 000120 constant entry external dcl 173 ref 235 315 343 384 742 766 936 937 1013 1015 1053 1054 1067 1069 mail_system_$get_address_pathname 000122 constant entry external dcl 174 ref 741 817 963 1332 mail_system_$get_address_type 000124 constant entry external dcl 175 ref 336 378 812 1328 mail_system_$get_mail_table_address 000126 constant entry external dcl 176 ref 1321 mail_system_$validate_address 000130 constant entry external dcl 177 ref 808 mailbox_$close 000132 constant entry external dcl 178 ref 938 1016 1055 1070 1220 mailbox_$open 000134 constant entry external dcl 179 ref 986 1217 mailbox_idx 000206 automatic fixed bin(17,0) dcl 110 set ref 930* 938 938* 939* 986* 1016 1016* 1017* 1049* 1055 1055* 1056* 1070 1070* 1071* 1217* 1220 1220* mailbox_type 000205 automatic fixed bin(17,0) dcl 110 set ref 961* 980 981 991 996 1143* 1164* 1258* 1295* 1333* 1335* 1336* 1341* mbx_dirname 000110 automatic char(168) packed unaligned dcl 92 set ref 963* 986* 991* 991* 998* 1000* 1000* 1006* 1006* 1020 1063 1106* 1114* 1114* 1121* 1125 1206* 1206* 1217* 1236* 1247* 1248* 1253* 1253* 1256* 1256* 1274* 1276* 1280* 1281* 1282* 1285* 1290* 1290* 1293* 1293* 1332* 1342* mbx_ename 000162 automatic char(32) packed unaligned dcl 93 set ref 932* 963* 986* 991* 991* 998* 1000* 1000* 1006* 1006* 1019 1021 1064 1102* 1106* 1114* 1114* 1117 1128 1130* 1146 1150* 1157 1169 1173* 1176 1178* 1206* 1206* 1207* 1217* 1236* 1242* 1245* 1247* 1248* 1250* 1252* 1253* 1253* 1256* 1256* 1274* 1276* 1281* 1282* 1285* 1286* 1289* 1290* 1290* 1293* 1293* 1332* 1343* mbz 4(02) based bit(34) level 3 packed packed unaligned dcl 1-8 ref 221 292 920 min builtin function dcl 203 ref 780 mlsys_data_$user_id 000200 external static varying char(32) dcl 6-72 set ref 574* 577* 596* 599* mlsys_data_$user_logbox_address 000176 external static pointer dcl 5-15 set ref 963* mlsys_et_$ca_parse_failed 000034 external static fixed bin(35,0) dcl 133 ref 267 358 1032 mlsys_et_$mailbox_exists 000036 external static fixed bin(35,0) dcl 133 ref 833 1003 mlsys_et_$mte_not_found 000040 external static fixed bin(35,0) dcl 133 ref 1322 mlsys_et_$mte_not_mailbox 000042 external static fixed bin(35,0) dcl 133 set ref 1329* mlsys_et_$no_mailbox 000044 external static fixed bin(35,0) dcl 133 ref 810 mlsys_psp_$forum_not_available 000136 constant entry external dcl 180 ref 638 675 mlsys_search_list_ptr 000374 automatic pointer dcl 1094 set ref 1099* 1100 1121 mlsys_user_mte_syntax_$classify_and_validate 000140 constant entry external dcl 181 ref 530 542 1310 mlsys_utils_$create_logbox 000142 constant entry external dcl 183 ref 825 996 mlsys_utils_$create_savebox 000144 constant entry external dcl 184 ref 827 998 mlsys_utils_$format_address_field 000146 constant entry external dcl 185 ref 756 mlsys_utils_$print_validate_results 000150 constant entry external dcl 188 ref 838 mte_address_ptr 000232 automatic pointer dcl 113 set ref 929* 936 936* 1013 1013* 1048* 1053 1053* 1067 1067* 1320* 1321* n_arguments 000175 automatic fixed bin(17,0) dcl 101 set ref 242* 246 325* 330 332 489 519 944* 1385 n_hosts 000100 automatic fixed bin(17,0) dcl 398 set ref 483* 503* 503 504 528 563 739 773 780 785 791 n_relays 6 000100 automatic fixed bin(17,0) level 3 dcl 780 set ref 785* 786 not_user_name 000370 automatic bit(1) dcl 1089 set ref 1109* 1110 1190* 1192 null builtin function dcl 203 ref 230 235 236 237 242 254 256 301 310 315 316 317 325 350 352 377 439 585 585 609 609 643 644 644 716 716 737 760 794 794 801 929 936 937 944 1013 1015 1046 1048 1053 1054 1067 1069 1099 1099 1247 1247 1281 1281 1361 num_paths 1 based fixed bin(17,0) level 2 dcl 7-15 ref 236 254 316 350 893 1100 p_badopt_handler parameter label variable dcl 395 ref 391 464 p_code parameter fixed bin(35,0) dcl 881 set ref 877 887* 891* 893 894* 897 p_component parameter char(32) packed unaligned dcl 854 set ref 849 858 858* 866* 866* p_control_argument parameter char packed unaligned dcl 852 set ref 849 863* 866* p_dirname parameter char packed unaligned dcl 880 in procedure "search_forum_list" set ref 877 897* p_dirname parameter char(168) packed unaligned dcl 853 in procedure "reject_starnames" set ref 849 863 866* 866* p_ename parameter char packed unaligned dcl 880 in procedure "search_forum_list" set ref 877 886 894* p_ename parameter char(32) packed unaligned dcl 854 in procedure "reject_starnames" set ref 849 857* 863* 866* 866* p_host_indeces_ptr parameter pointer dcl 394 ref 391 504 775 787 p_name parameter varying char dcl 1416 in procedure "has_suffix_varying" ref 1413 1419 p_name parameter char packed unaligned dcl 1306 in procedure "get_user_mailbox_pathname" set ref 1303 1310 1316* 1320 1327* 1329* p_name parameter char packed unaligned dcl 1406 in procedure "has_suffix_nonvarying" ref 1403 1408 p_not_user_name parameter bit(1) dcl 1308 set ref 1303 1313* 1324* 1346* p_ok_if_not_user_name parameter bit(1) dcl 1307 ref 1303 1311 1322 p_string parameter char packed unaligned dcl 1383 set ref 1380 1385* p_suffix parameter char packed unaligned dcl 1406 in procedure "has_suffix_nonvarying" ref 1403 1408 p_suffix parameter char packed unaligned dcl 1417 in procedure "has_suffix_varying" ref 1413 1419 p_text parameter char packed unaligned dcl 1272 in procedure "get_savebox_pathname" set ref 1269 1274* 1274* 1276* 1277* 1279 1282* 1282* 1285* p_text parameter char packed unaligned dcl 1233 in procedure "get_mailbox_pathname" set ref 1230 1235 1236* 1237* 1241* 1242* 1243* 1245 1248* p_text parameter char packed unaligned dcl 1082 in procedure "parse_mailbox_text_internal" set ref 1079 1098 1102 1106* 1109* 1110* 1112* 1190* parse_ca_options based structure level 1 dcl 1-8 parse_ca_options_ptr 000252 automatic pointer dcl 1-23 set ref 215* 216 221 221 221 221 221 286* 287 292 292 292 292 292 373 806 813 814 914* 915 920 920 920 920 920 981 982 985 1367 pathname 17 based char(168) array level 3 packed packed unaligned dcl 7-15 set ref 894* 897 1121 pathname_ 000152 constant entry external dcl 189 ref 601 601 624 624 670 670 696 696 744 744 820 820 829 829 991 991 1000 1000 1006 1006 1114 1114 1196 1196 1202 1202 1206 1206 1253 1253 1256 1256 1290 1290 1293 1293 pathname_$component 000154 constant entry external dcl 190 ref 728 728 866 866 paths 14 based structure array level 2 dcl 7-15 person_id 000207 automatic varying char(32) dcl 112 set ref 1310* 1342 1343 preliminary_type 000327 automatic fixed bin(17,0) dcl 417 set ref 432* 438* 445* 452* 459* 466* 474* 528 533* 535* 538 538* 546* 548* 553 553 553* 561 565 573 581 605 628 701 740 740 744 749 773 project_id 000220 automatic varying char(32) dcl 112 set ref 1310* 1342 relays 7 000100 automatic varying char(256) array level 2 dcl 780 set ref 788* reverse builtin function dcl 203 ref 1408 1408 1419 1419 rtrim builtin function dcl 203 ref 631 634 652 670 680 886 1128 1342 1343 1408 savebox_creation_mode 3 based fixed bin(17,0) level 2 dcl 1-8 ref 221 221 292 292 814 920 920 982 saved_code 000356 automatic fixed bin(35,0) dcl 1086 set ref 1108* 1110* 1112* 1126* 1133* 1147* 1156* 1170* 1184 1184* 1193* 1196* 1202* saved_mbx_dirname 000274 automatic char(168) packed unaligned dcl 1084 set ref 1125* 1196* 1196* 1202* 1202* saved_mbx_ename 000346 automatic char(32) packed unaligned dcl 1085 set ref 1117* 1193* 1193* 1196* 1196* 1196* 1202* 1202* 1202* 1207 sci_ptr 000100 automatic pointer dcl 84 set ref 212* 242* 274* 283* 325* 427* 493* 531* 544* 570* 578* 588* 592* 601* 608* 612* 616* 624* 631* 634* 646* 669* 670* 696* 706* 713* 720* 728* 744* 775* 787* 798* 820* 823* 829* 838* 839* 863* 866* 911* 944* 946* 972* 991* 994* 1000* 1006* 1046* 1110* 1112* 1114* 1193* 1196* 1202* 1206* 1237* 1243* 1250* 1253* 1256* 1277* 1286* 1290* 1293* 1316* 1327* 1329* 1361 1385* 1390* search builtin function dcl 203 ref 538 583 606 629 714 1098 1235 1279 search_paths_$find_dir 000156 constant entry external dcl 191 ref 585 609 716 1247 1281 search_paths_$get 000160 constant entry external dcl 193 in procedure "mlsys_parse_control_args_" ref 644 search_paths_$get 000202 constant entry external dcl 1091 in procedure "parse_mailbox_text_internal" ref 1099 sl_control_default 000000 constant bit(36) initial packed unaligned dcl 8-13 set ref 644* 1099* sl_info based structure level 1 dcl 7-15 set ref 236 254 316 350 sl_info_version_1 000100 constant fixed bin(17,0) initial dcl 7-29 set ref 644* 1099* ssu_$abort_line 000162 constant entry external dcl 195 ref 1367 1367 ssu_$arg_ptr 000164 constant entry external dcl 196 ref 427 493 775 787 946 1390 ssu_$get_subsystem_and_request_name 000166 constant entry external dcl 197 ref 820 991 ssu_$print_message 000170 constant entry external dcl 198 ref 829 1000 1369 1369 ssu_$return_arg 000172 constant entry external dcl 199 ref 242 325 944 suffixed_name_$make 000174 constant entry external dcl 200 ref 584 607 1242 system_area based area(1024) dcl 103 ref 236 254 316 350 system_area_ptr 000176 automatic pointer dcl 104 set ref 231* 236 254 311* 316 350 644* 1097* 1099* target_address_ptr 000234 automatic pointer dcl 113 set ref 929* 937 937* 1015 1015* 1048* 1054 1054* 1069 1069* 1321* 1328* 1332* trimmed_address_ename 000313 automatic varying char(32) dcl 412 set ref 652* 653 654 657 659 680* 681 684 684 trimmed_ename 000357 automatic varying char(32) dcl 1088 set ref 1128* 1137* 1137* 1145* 1146 1150 1157 1167* 1168* 1169 1173 1176 1178 try_to_create 000326 automatic bit(1) packed unaligned dcl 415 in procedure "parse_single_address" set ref 820* 823 try_to_create 000240 automatic bit(1) packed unaligned dcl 115 in procedure "mlsys_parse_control_args_" set ref 991* 994 use_search_paths 000371 automatic bit(1) dcl 1090 set ref 1096* 1101* 1121 1193 validate_addresses 4(01) based bit(1) level 3 packed packed unaligned dcl 1-8 ref 806 985 version based char(8) level 2 in structure "parse_ca_options" packed packed unaligned dcl 1-8 in procedure "mlsys_parse_control_args_" ref 216 287 915 version 000100 automatic char(8) level 3 in structure "local_address_route" packed packed unaligned dcl 780 in begin block on line 778 set ref 784* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ABSOLUTE_PATH internal static fixed bin(17,0) initial dcl 7-33 ADDRESS_LIST_VERSION_2 internal static char(8) initial packed unaligned dcl 2-12 HOME_DIR internal static fixed bin(17,0) initial dcl 7-38 INITIATED_SEGS internal static fixed bin(17,0) initial dcl 7-39 INVALID_ADDRESS internal static fixed bin(17,0) initial dcl 3-6 NAMED_GROUP_ADDRESS internal static fixed bin(17,0) initial dcl 3-6 PROCESS_DIR internal static fixed bin(17,0) initial dcl 7-37 REFERENCING_DIR internal static fixed bin(17,0) initial dcl 7-35 UNEXPANDED_PATH internal static fixed bin(17,0) initial dcl 7-34 WORKING_DIR internal static fixed bin(17,0) initial dcl 7-36 address_list based structure level 1 dcl 2-6 address_list_n_addresses automatic fixed bin(17,0) dcl 2-16 address_list_ptr automatic pointer dcl 2-14 address_route_n_relays automatic fixed bin(17,0) dcl 4-18 address_route_ptr automatic pointer dcl 4-16 mlsys_area based area(1024) dcl 6-61 mlsys_data_$address_list_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$domains_available external static fixed bin(1,0) dcl 6-44 mlsys_data_$forum_not_available external static fixed bin(1,0) dcl 6-44 mlsys_data_$hash_tables_segment_ptr external static pointer dcl 6-64 mlsys_data_$highest_usable_ring external static fixed bin(3,0) dcl 6-49 mlsys_data_$ism_not_available external static fixed bin(1,0) dcl 6-44 mlsys_data_$lowest_forum_ring external static fixed bin(3,0) dcl 6-49 mlsys_data_$mailbox_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$max_lock_wait_retries external static fixed bin(17,0) dcl 6-19 mlsys_data_$max_opening_retries external static fixed bin(17,0) dcl 6-16 mlsys_data_$message_body_sections_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$message_redistributions_list_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$message_references_list_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$message_user_fields_allocation external static fixed bin(17,0) dcl 6-33 mlsys_data_$person_id external static varying char(24) dcl 6-70 mlsys_data_$project_id external static varying char(12) dcl 6-71 mlsys_data_$subsystem_area_ptr external static pointer dcl 6-62 mlsys_data_$subsystem_ring external static fixed bin(3,0) dcl 6-49 mlsys_data_$system_directory external static char(168) packed unaligned dcl 5-7 mlsys_data_$temp_segment_list_ptr external static pointer dcl 6-54 mlsys_data_$transmit_cache_ptr external static pointer dcl 6-66 mlsys_data_$user_default_mailbox_address external static pointer dcl 5-12 mlsys_data_$user_is_anonymous external static bit(1) dcl 6-68 mlsys_data_$user_mail_table_address external static pointer dcl 5-14 mlsys_data_$valid_segments external static bit(1) array packed unaligned dcl 6-56 sl_control automatic bit(36) packed unaligned dcl 8-12 sl_control_s based structure level 1 packed packed unaligned dcl 8-3 sl_info_num_paths automatic fixed bin(17,0) dcl 7-27 sl_info_p automatic pointer dcl 7-28 NAMES DECLARED BY EXPLICIT CONTEXT. CONTINUE_ADDRESS_LIST_PARSE 001110 constant label dcl 327 ref 386 RETURN_BADOPT_FROM_PARSE_ADDRESS_CONTROL_ARGS 000637 constant label dcl 274 ref 248 248 RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS 000606 constant label dcl 254 ref 269 RETURN_FROM_PARSE_ADDRESS_CONTROL_ARGS_WITH_ERRORS 000633 constant label dcl 267 set ref 240 RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS 001247 constant label dcl 350 ref 333 333 344 373 RETURN_FROM_PARSE_ADDRESS_LIST_CONTROL_ARGS_WITH_ERRORS 001302 constant label dcl 367 ref 320 RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS 002537 constant label dcl 1013 ref 1034 RETURN_FROM_PARSE_MAILBOX_CONTROL_ARGS_WITH_ERRORS 002643 constant label dcl 1032 ref 942 RETURN_FROM_PARSE_MAILBOX_TEXT 003037 constant label dcl 1067 ref 1059 TRY_SAVEBOX_HUERISTIC 013267 constant label dcl 1164 ref 1137 TRY_USER_NAME_OR_MTE_HUERISTIC 013374 constant label dcl 1190 ref 1134 1148 1157 1171 1176 abort_parse 016115 constant entry internal dcl 1355 ref 274 531 544 570 578 588 592 601 608 612 616 624 631 634 646 669 670 696 706 713 720 728 744 798 823 839 863 866 972 994 1006 1110 1112 1114 1193 1196 1202 1206 1237 1243 1250 1253 1256 1277 1286 1290 1293 1316 1327 1329 1385 get_mailbox_pathname 014065 constant entry internal dcl 1230 ref 952 get_next_argument 016232 constant entry internal dcl 1380 ref 431 444 451 458 465 502 508 514 951 956 968 get_savebox_pathname 014617 constant entry internal dcl 1269 ref 969 get_user_mailbox_pathname 015410 constant entry internal dcl 1303 ref 957 1109 1190 has_suffix_nonvarying 016332 constant entry internal dcl 1403 ref 582 634 634 649 649 670 670 678 678 1193 1196 1202 1241 1274 1282 has_suffix_varying 016400 constant entry internal dcl 1413 ref 1137 1137 1145 1167 1168 mailbox_exists 014011 constant entry internal dcl 1214 ref 1111 1153 1181 1201 mlsys_parse_control_args_ 000357 constant entry external dcl 44 parse_address_control_args 000372 constant entry external dcl 209 parse_address_list_control_args 000700 constant entry external dcl 279 parse_mailbox_control_args 001417 constant entry external dcl 908 parse_mailbox_text 002654 constant entry external dcl 1043 parse_mailbox_text_internal 012513 constant entry internal dcl 1079 ref 975 1061 parse_single_address 003112 constant entry internal dcl 391 ref 248 333 reject_starnames 012116 constant entry internal dcl 849 ref 595 618 637 674 722 search_forum_list 012334 constant entry internal dcl 877 ref 649 653 657 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 20176 20402 17032 20206 Length 21232 17032 204 613 1143 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mlsys_parse_control_args_ 812 external procedure is an external procedure. on unit on line 233 72 on unit begin block on line 244 82 begin block uses auto adjustable storage. on unit on line 313 72 on unit begin block on line 327 94 begin block uses auto adjustable storage. parse_single_address 509 internal procedure is called by several nonquick procedures. begin block on line 778 118 begin block uses auto adjustable storage. reject_starnames internal procedure shares stack frame of internal procedure parse_single_address. search_forum_list 150 internal procedure is called during a stack extension. on unit on line 934 72 on unit on unit on line 1051 72 on unit parse_mailbox_text_internal internal procedure shares stack frame of external procedure mlsys_parse_control_args_. mailbox_exists internal procedure shares stack frame of external procedure mlsys_parse_control_args_. get_mailbox_pathname internal procedure shares stack frame of external procedure mlsys_parse_control_args_. get_savebox_pathname internal procedure shares stack frame of external procedure mlsys_parse_control_args_. get_user_mailbox_pathname internal procedure shares stack frame of external procedure mlsys_parse_control_args_. abort_parse 92 internal procedure is declared options(variable). get_next_argument 98 internal procedure is called by several nonquick procedures. has_suffix_nonvarying 67 internal procedure is called by several nonquick procedures. has_suffix_varying internal procedure shares stack frame of external procedure mlsys_parse_control_args_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME abort_parse 000100 code_ptr abort_parse begin block on line 244 000100 host_indeces begin block on line 244 begin block on line 327 000100 host_indeces begin block on line 327 begin block on line 778 000100 local_address_route begin block on line 778 mlsys_parse_control_args_ 000100 sci_ptr mlsys_parse_control_args_ 000102 argument_idx mlsys_parse_control_args_ 000103 code mlsys_parse_control_args_ 000104 creation_mode mlsys_parse_control_args_ 000106 address_ptr mlsys_parse_control_args_ 000110 mbx_dirname mlsys_parse_control_args_ 000162 mbx_ename mlsys_parse_control_args_ 000172 argument_ptr mlsys_parse_control_args_ 000174 argument_lth mlsys_parse_control_args_ 000175 n_arguments mlsys_parse_control_args_ 000176 system_area_ptr mlsys_parse_control_args_ 000200 abort_the_parse mlsys_parse_control_args_ 000204 address_type mlsys_parse_control_args_ 000205 mailbox_type mlsys_parse_control_args_ 000206 mailbox_idx mlsys_parse_control_args_ 000207 person_id mlsys_parse_control_args_ 000220 project_id mlsys_parse_control_args_ 000232 mte_address_ptr mlsys_parse_control_args_ 000234 target_address_ptr mlsys_parse_control_args_ 000236 errors_detected mlsys_parse_control_args_ 000237 is_mte_name mlsys_parse_control_args_ 000240 try_to_create mlsys_parse_control_args_ 000242 forum_search_list_ptr mlsys_parse_control_args_ 000252 parse_ca_options_ptr mlsys_parse_control_args_ 000274 saved_mbx_dirname parse_mailbox_text_internal 000346 saved_mbx_ename parse_mailbox_text_internal 000356 saved_code parse_mailbox_text_internal 000357 trimmed_ename parse_mailbox_text_internal 000370 not_user_name parse_mailbox_text_internal 000371 use_search_paths parse_mailbox_text_internal 000372 loop_idx parse_mailbox_text_internal 000373 idx parse_mailbox_text_internal 000374 mlsys_search_list_ptr parse_mailbox_text_internal parse_single_address 000100 n_hosts parse_single_address 000102 address_string_ptr parse_single_address 000104 address_name_ptr parse_single_address 000106 address_comment_ptr parse_single_address 000110 address_string_lth parse_single_address 000111 address_name_lth parse_single_address 000112 address_comment_lth parse_single_address 000114 address_buffer_ptr parse_single_address 000116 address_buffer_lth parse_single_address 000117 address_buffer_used parse_single_address 000120 foreign_system_name parse_single_address 000221 address_dirname parse_single_address 000273 address_ename parse_single_address 000303 address_component parse_single_address 000313 trimmed_address_ename parse_single_address 000324 continue_to_peek parse_single_address 000325 include_name_and_comment parse_single_address 000326 try_to_create parse_single_address 000327 preliminary_type parse_single_address 000330 address_type parse_single_address 000331 idx parse_single_address 000340 code reject_starnames search_forum_list 000100 ename search_forum_list 000110 idx search_forum_list THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_e_as alloc_char_temp cat_realloc_chars enter_begin_block leave_begin_block call_ext_out_desc call_ext_out call_int_this_desc call_int_other_desc call_int_other return_mac move_label_var make_label_var tra_ext_1 tra_ext_2 alloc_auto_adj enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_chars_eis op_freen_ ix_rev_chars THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. check_star_name_$entry command_query_$yes_no cu_$arg_list_ptr cu_$arg_ptr cu_$generate_call cu_$grow_stack_frame cu_$shrink_stack_frame expand_pathname_ expand_pathname_$add_suffix expand_pathname_$component_add_suffix forum_$get_forum_path get_system_free_area_ mail_system_$add_address mail_system_$create_foreign_address mail_system_$create_forum_address mail_system_$create_logbox_address mail_system_$create_mail_table_address mail_system_$create_mailbox_address mail_system_$create_mailing_list_address mail_system_$create_savebox_address mail_system_$create_user_mailbox_address mail_system_$free_address mail_system_$get_address_pathname mail_system_$get_address_type mail_system_$get_mail_table_address mail_system_$validate_address mailbox_$close mailbox_$open mlsys_psp_$forum_not_available mlsys_user_mte_syntax_$classify_and_validate mlsys_utils_$create_logbox mlsys_utils_$create_savebox mlsys_utils_$format_address_field mlsys_utils_$print_validate_results pathname_ pathname_$component search_paths_$find_dir search_paths_$get search_paths_$get ssu_$abort_line ssu_$arg_ptr ssu_$get_subsystem_and_request_name ssu_$print_message ssu_$return_arg suffixed_name_$make THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_subr_arg error_table_$badopt error_table_$entlong error_table_$moderr error_table_$no_dir error_table_$noarg error_table_$noentry error_table_$nostars error_table_$smallarg error_table_$unimplemented_version mlsys_data_$user_id mlsys_data_$user_logbox_address mlsys_et_$ca_parse_failed mlsys_et_$mailbox_exists mlsys_et_$mte_not_found mlsys_et_$mte_not_mailbox mlsys_et_$no_mailbox LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 44 000356 47 000364 209 000365 212 000402 213 000406 215 000410 216 000413 217 000417 218 000422 221 000423 226 000436 227 000441 230 000442 231 000445 233 000454 235 000470 236 000506 237 000521 238 000524 240 000525 242 000530 244 000554 246 000557 248 000564 249 000604 251 000605 254 000606 256 000620 258 000622 259 000625 260 000630 262 000632 267 000633 269 000636 274 000637 279 000671 283 000710 284 000714 286 000716 287 000721 288 000725 289 000730 292 000731 297 000744 298 000747 301 000750 306 000770 307 000773 310 000774 311 000777 313 001006 315 001022 316 001040 317 001053 318 001056 320 001057 322 001062 323 001063 325 001064 327 001110 330 001113 332 001120 333 001124 334 001144 336 001146 337 001162 340 001207 342 001225 343 001230 344 001242 346 001245 347 001246 350 001247 352 001261 354 001263 356 001266 358 001272 360 001300 362 001301 367 001302 369 001304 371 001305 373 001306 377 001312 378 001316 379 001332 382 001357 384 001376 386 001410 908 001411 911 001440 912 001444 914 001446 915 001451 916 001455 917 001460 920 001461 925 001474 926 001477 929 001500 930 001503 932 001504 934 001507 936 001523 937 001541 938 001560 939 001575 940 001577 942 001600 944 001603 946 001627 949 001644 951 001670 952 001703 953 001716 955 001717 956 001723 957 001737 958 001764 960 001765 961 001771 963 001773 965 002030 967 002031 968 002041 969 002057 970 002072 972 002073 975 002126 980 002141 981 002147 982 002155 985 002160 986 002164 987 002211 989 002216 990 002223 991 002225 994 002326 996 002346 998 002361 1000 002402 1003 002462 1006 002467 1010 002536 1013 002537 1015 002555 1016 002573 1017 002607 1019 002610 1020 002614 1021 002624 1024 002634 1025 002640 1027 002642 1032 002643 1034 002646 1043 002647 1046 002702 1048 002704 1049 002707 1051 002710 1053 002724 1054 002742 1055 002761 1056 002776 1057 003000 1059 003001 1061 003004 1063 003016 1064 003026 1065 003036 1067 003037 1069 003055 1070 003073 1071 003107 1073 003110 391 003111 427 003117 429 003134 431 003155 432 003172 433 003174 434 003177 435 003202 437 003203 438 003207 439 003211 440 003213 441 003214 443 003215 444 003225 445 003244 446 003246 447 003251 448 003254 450 003255 451 003265 452 003301 453 003303 454 003306 455 003311 457 003312 458 003322 459 003341 460 003343 461 003346 462 003351 464 003352 465 003365 466 003404 467 003406 468 003411 469 003414 474 003415 475 003417 476 003420 483 003422 485 003423 487 003427 489 003431 491 003436 493 003440 495 003461 499 003535 501 003536 502 003540 503 003555 504 003556 505 003565 507 003566 508 003572 509 003606 510 003611 511 003614 513 003615 514 003621 515 003635 516 003640 519 003643 520 003650 522 003651 523 003652 528 003653 530 003660 531 003723 533 003761 535 003770 536 003772 538 003773 542 004014 544 004056 546 004114 548 004123 551 004125 553 004126 561 004135 563 004137 565 004142 566 004145 569 004232 570 004276 571 004334 573 004335 574 004337 577 004415 578 004452 579 004500 581 004501 582 004503 583 004536 584 004552 585 004605 586 004647 588 004711 589 004744 591 004745 592 005004 595 005041 596 005051 599 005137 601 005204 603 005257 605 005260 606 005262 607 005276 608 005331 609 005366 610 005430 612 005472 613 005525 615 005526 616 005565 618 005625 619 005635 622 005716 624 005756 626 006034 628 006035 629 006037 631 006053 633 006124 634 006131 637 006256 638 006271 643 006307 644 006314 646 006363 649 006412 652 006511 653 006531 654 006570 656 006613 657 006614 659 006652 660 006674 662 006675 665 006703 668 006704 669 006735 670 006774 674 007141 675 007151 678 007164 680 007241 681 007261 682 007277 684 007340 688 007364 691 007365 694 007446 696 007506 699 007602 701 007603 702 007605 705 007672 706 007736 707 007774 711 007775 713 010037 714 010100 715 010114 716 010117 717 010161 720 010226 722 010261 723 010272 726 010356 728 010421 737 010504 739 010506 740 010510 741 010515 742 010553 743 010566 744 010625 749 010711 750 010714 751 010730 753 010732 754 010736 755 010743 756 010744 758 011005 760 011012 761 011027 763 011031 764 011032 765 011034 766 011036 773 011047 775 011054 776 011074 778 011106 780 011111 784 011123 785 011126 786 011131 787 011140 788 011160 789 011200 791 011202 794 011301 796 011375 798 011377 801 011443 806 011461 808 011466 810 011503 812 011510 813 011523 814 011533 815 011542 816 011545 817 011546 819 011603 820 011607 823 011711 825 011733 827 011747 829 011771 833 012053 837 012061 838 012063 839 012076 843 012115 849 012116 857 012127 858 012145 861 012172 863 012202 866 012250 869 012332 877 012333 883 012354 886 012357 887 012375 888 012377 891 012400 893 012402 894 012420 897 012473 898 012510 900 012512 1079 012513 1096 012524 1097 012525 1098 012534 1099 012551 1100 012620 1101 012623 1102 012625 1103 012633 1105 012634 1106 012636 1107 012664 1108 012666 1109 012667 1110 012712 1111 012746 1112 012754 1114 013014 1117 013062 1118 013065 1119 013067 1120 013071 1121 013103 1125 013114 1126 013117 1128 013120 1130 013140 1131 013155 1132 013165 1133 013167 1134 013170 1137 013171 1143 013212 1145 013214 1146 013224 1147 013231 1148 013234 1150 013235 1151 013251 1153 013252 1156 013260 1157 013262 1164 013267 1167 013271 1168 013302 1169 013312 1170 013317 1171 013322 1173 013323 1174 013337 1176 013341 1178 013345 1179 013361 1181 013362 1184 013370 1190 013374 1192 013417 1193 013425 1196 013511 1201 013613 1202 013621 1206 013735 1207 014003 1208 014006 1226 014010 1214 014011 1217 014013 1218 014040 1220 014045 1222 014060 1230 014065 1235 014076 1236 014112 1237 014146 1238 014200 1241 014201 1242 014227 1243 014260 1244 014312 1245 014313 1247 014321 1248 014362 1250 014422 1252 014453 1253 014470 1256 014546 1258 014614 1260 014616 1269 014617 1274 014630 1276 014715 1277 014752 1279 015004 1280 015021 1281 015024 1282 015065 1285 015156 1286 015213 1289 015244 1290 015261 1293 015337 1295 015405 1297 015407 1303 015410 1310 015421 1311 015461 1313 015470 1314 015472 1316 015473 1318 015522 1320 015525 1321 015571 1322 015605 1324 015615 1325 015617 1327 015620 1328 015652 1329 015666 1332 015730 1333 015765 1335 015775 1336 016002 1338 016004 1341 016005 1342 016007 1343 016060 1344 016110 1346 016111 1348 016113 1355 016114 1361 016122 1362 016127 1363 016147 1364 016152 1367 016153 1369 016203 1372 016226 1380 016231 1385 016245 1388 016311 1390 016313 1392 016330 1403 016331 1408 016352 1413 016400 1419 016416 ----------------------------------------------------------- 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