COMPILATION LISTING OF SEGMENT mlsys_message_mgr_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 06/30/86 1356.6 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 4* * * 5* *********************************************************** */ 6 7 /* format: off */ 8 9 /* Message management for the Multics Mail System */ 10 11 /* Created: June 1981 by G. Palter */ 12 /* Recoded: July 1983 by G. Palter to convert to new mail system specification */ 13 /* Modified: April 1984 by G. Palter to fix error #0438 -- the primitives which allow a user to replace the address list 14* portions of a message (eg: mail_system_$replace_from, mail_system_$replace_user_field) should not make the user's 15* copy of the address list read-only. Instead, they should copy the user's list to allow the user to continue to 16* modify the list if desired for later additional use */ 17 18 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen,^indcomtxt */ 19 20 21 mlsys_message_mgr_: 22 procedure () options (rename ((alloc_, mlsys_storage_mgr_$allocate))); 23 24 return; /* not an entrypoint */ 25 26 27 /* Parameters */ 28 29 dcl P_message_ptr pointer parameter; 30 dcl P_code fixed binary (35) parameter; 31 32 dcl P_message_version character (8) parameter; /* create_*_message: version of message structure requested by 33* the caller */ 34 35 dcl P_im_message_info_ptr pointer parameter; /* create_im_message, verify_im_message: -> internal 36* description of the message */ 37 38 dcl P_message_envelope_parameter_ptr pointer parameter; /* replace_message_envelope_*: -> the new envelope */ 39 40 dcl P_address_list_ptr pointer parameter; /* replace_from_*, replace_reply_to_*, replace_to_*, 41* replace_cc_*, replace_bcc_*: -> the new value for the 42* field */ 43 44 dcl P_subject character (*) parameter; /* replace_subject_*: the new subject text */ 45 46 dcl P_access_class bit (72) aligned parameter; /* set_access_class_new: the new AIM access class for the 47* message */ 48 49 dcl P_message_body_section_parameter_ptr pointer parameter;/* add_body_section_*: -> the new section to be added; 50* replace_body_*: -> the new section to replace the body; 51* replace_body_section_*: - > the new section to replace the 52* old body section */ 53 54 dcl P_message_redistribution_parameter_ptr pointer parameter; 55 /* add_redistribution_*: -> the new redistribution; 56* replace_redistribution_*: -> the new redistribution to 57* replace the old redistribution */ 58 59 dcl P_referenced_message_ptr pointer parameter; /* add_reply_reference_new: -> the in-mailbox message for 60* which a reference is to be added to the message; 61* replace_reply_reference_new: -> the in-mailbox message 62* whose reference will replace the old reference */ 63 64 dcl P_message_reference_parameter_ptr pointer parameter; /* add_reply_reference_*: -> the in-mailbox message for which 65* a reference is to be added to the message; 66* replace_reply_reference_*: -> the in-mailbox message 67* whose reference will replace the old reference */ 68 69 dcl P_message_user_field_parameter_ptr pointer parameter; /* add_user_field_*: -> the new user field to be added; 70* replace_user_field_*: -> the new user field to replace the 71* old field */ 72 dcl P_allow_duplicates bit (1) aligned parameter; /* add_user_field_*, replace_user_field_*: ON => allow 73* multiple fields with same ID in the header */ 74 75 dcl P_position fixed binary parameter; /* add_*: where to add the new item; set to actual position 76* where it was added; 77* delete_*, replace_* (except replace_subject_*): identifies 78* which item in the message to delete/replace */ 79 80 dcl P_date_time_created fixed binary (71) parameter; /* verify_message, verify_new_message: set to the date/time 81* the message was created */ 82 /**** format: indcomtxt */ 83 84 85 /* Local copies of parameters */ 86 87 dcl access_class bit (72) aligned; 88 89 dcl position fixed binary; 90 91 dcl code fixed binary (35); 92 93 94 /* Definition of the reserved data in the various parts of a message */ 95 96 dcl 1 message_reserved_data aligned based (addr (message.reserved)), 97 2 info_ptr pointer, /* -> corresponding im_message_info or new_message_info */ 98 2 n_body_sections_allocated, /* actual # of body sections available in the structure */ 99 2 type fixed binary; /* type of message (in-mailbox/new/incoming) */ 100 101 /* format: off */ 102 dcl (IN_MAILBOX_MESSAGE initial (0), /* an in-mailbox message */ 103 NEW_MESSAGE initial (1)) /* a new message created by ordinary mail_system_ gate */ 104 /* INCOMING_MESSAGE initial (2)) /* an incoming message created by mail_system_daemon_ gate */ 105 fixed binary static options (constant); 106 /* format: on */ 107 108 dcl 1 message_references_list_reserved_data aligned based (addr (message_references_list.reserved)), 109 2 message_ptr pointer, /* -> the message of which this is a part */ 110 2 n_references_allocated fixed binary; /* # of reference slots actually present */ 111 112 dcl 1 message_redistributions_list_reserved_data aligned based (addr (message_redistributions_list.reserved)), 113 2 message_ptr pointer, /* -> the message of which this is a part */ 114 2 n_redistributions_allocated fixed binary; /* # of redistribution slots actually present */ 115 116 dcl 1 message_user_fields_list_reserved_data aligned based (addr (message_user_fields_list.reserved)), 117 2 message_ptr pointer, /* -> the message of which this is a part */ 118 2 n_user_fields_allocated fixed binary; /* # of user field slots actually present */ 119 120 dcl 1 message_text_field_reserved_flags unaligned based (addr (message_text_field.flags.reserved)), 121 2 free_text bit (1) unaligned, /* ON => free the text on releasing this field */ 122 2 pad bit (34) unaligned; 123 124 dcl 1 message_preformatted_body_section_reserved_data aligned based (addr (message_preformatted_body_section.reserved)), 125 2 free_text bit (1) unaligned, /* ON => free the text on releasing this section */ 126 2 pad bit (35) unaligned; 127 128 dcl 1 message_bit_string_body_section_reserved_data aligned based (addr (message_bit_string_body_section.reserved)), 129 2 free_bit_string bit (1) unaligned, /* ON => free the bit string on releasing this section */ 130 2 pad bit (35) unaligned; 131 132 133 /* Internal description of a new message */ 134 135 dcl 1 new_message_info aligned based (new_message_info_ptr), 136 2 date_time_created fixed binary (71); /* date/time message body last updated */ 137 138 dcl new_message_info_ptr pointer; 139 140 141 /* Remaining declarations */ 142 143 dcl 1 local_mrfp aligned like message_reference_parameter; 144 145 dcl 1 user_privileges aligned, 146 2 privileges unaligned like aim_template.privileges, 147 2 pad bit (18) unaligned; 148 149 dcl message_type fixed binary; 150 151 dcl (copy_subject, copy_section_content, copy_redistribution_data, copy_reference_data, copy_user_field_content) 152 bit (1) aligned; 153 154 dcl idx fixed binary; 155 156 dcl MAX_STACK_EXTENSION fixed binary (21) static options (constant) initial (16384); 157 158 dcl NULL_STRING character (1) static options (constant) initial (" "); 159 160 /* format: off */ 161 dcl (SPACE initial (" "), 162 HT initial (" "), 163 BS initial (""), 164 NL initial (" 165 "), 166 CR initial (" ")) 167 character (1) static options (constant); 168 /* format: on */ 169 170 dcl SPACE_SPACE character (2) static options (constant) initial (" "); 171 172 dcl TEN_SPACES character (10) static options (constant) initial (" "); 173 174 /* format: off */ 175 dcl (UPPERCASE initial ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), 176 LOWERCASE initial ("abcdefghijklmnopqrstuvwxyz")) 177 character (26) static options (constant); 178 /* format: on */ 179 180 dcl SINGLE_WIDTH_CHARACTERS character (95) static options (constant) 181 initial (" !""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"); 182 183 /* format: off */ 184 185 dcl sys_info$max_seg_size fixed binary (19) external; 186 187 dcl (error_table_$ai_restricted, error_table_$bad_index, error_table_$smallarg, error_table_$unimplemented_version, 188 mlsys_et_$duplicate_reply_reference, mlsys_et_$duplicate_user_field, mlsys_et_$message_too_large, 189 mlsys_et_$not_in_mailbox_message, mlsys_et_$not_message, mlsys_et_$not_new_message, 190 mlsys_et_$unknown_body_section_type, mlsys_et_$unknown_user_field_type) 191 fixed binary (35) external; 192 /* format: on */ 193 194 dcl aim_check_$greater_or_equal entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); 195 dcl cu_$grow_stack_frame entry (fixed binary (18), pointer, fixed binary (35)); 196 dcl get_authorization_ entry () returns (bit (72) aligned); 197 dcl get_privileges_ entry () returns (bit (36) aligned); 198 dcl mlsys_address_list_mgr_$create_read_only_address_list entry (character (8), pointer, fixed binary (35)); 199 dcl mlsys_address_list_mgr_$copy_address_list entry (pointer, pointer, fixed binary (35)); 200 dcl mlsys_address_list_mgr_$decrement_reference_count entry (pointer); 201 dcl mlsys_address_list_mgr_$increment_reference_count entry (pointer); 202 dcl mlsys_address_list_mgr_$set_read_only entry (pointer); 203 dcl mlsys_address_list_mgr_$verify_address_list entry (pointer, fixed binary (35)) returns (bit (1) aligned); 204 dcl mlsys_address_mgr_$decrement_reference_count entry (pointer); 205 dcl mlsys_address_mgr_$increment_reference_count entry (pointer); 206 dcl mlsys_address_mgr_$verify_address entry (pointer, fixed binary (35)) returns (bit (1) aligned); 207 dcl mlsys_address_route_mgr_$create_address_route entry ((*) character (256) varying, pointer); 208 dcl mlsys_address_route_mgr_$decrement_reference_count entry (pointer); 209 dcl mlsys_address_route_mgr_$increment_reference_count entry (pointer); 210 dcl mlsys_field_id_mgr_$get_user_field_name entry (bit (36) aligned, character (*) varying, fixed binary (35)); 211 dcl mlsys_nit_interface_$get_fully_qualified_name entry (character (256) varying) returns (character (256) varying); 212 dcl mlsys_nit_interface_$is_local_system entry (character (256) varying) returns (bit (1) aligned); 213 dcl mlsys_storage_mgr_$get_temp_segment entry (pointer, fixed binary (35)); 214 dcl mlsys_storage_mgr_$release_temp_segment entry (pointer, fixed binary (35)); 215 216 dcl cleanup condition; 217 218 dcl (addr, baseno, binary, clock, divide, index, length, ltrim, max, min, mod, null, rtrim, search, stackframeptr, 219 string, substr, translate, verify) builtin; 220 221 /* Create an empty message */ 222 223 create_im_message: /* ... create an in-mailbox message */ 224 entry (P_message_version, P_im_message_info_ptr, P_message_ptr, P_code); 225 226 message_type = IN_MAILBOX_MESSAGE; 227 go to CREATE_MESSAGE_COMMON; 228 229 230 create_new_message: /* ... create a new message: target of user-ring gate */ 231 entry (P_message_version, P_message_ptr, P_code); 232 233 message_type = NEW_MESSAGE; 234 235 236 CREATE_MESSAGE_COMMON: 237 if P_message_version ^= MESSAGE_VERSION_2 then do; 238 P_code = error_table_$unimplemented_version; 239 return; 240 end; 241 242 message_n_body_sections = mlsys_data_$message_body_sections_allocation; 243 /* allows some room for the body */ 244 245 allocate message in (mlsys_area) set (message_ptr); 246 247 message.version = MESSAGE_VERSION_2; 248 249 message_reserved_data.n_body_sections_allocated = message_n_body_sections; 250 message.n_body_sections = 0; /* the body is empty */ 251 252 message_reserved_data.type = message_type; 253 254 if message_type = IN_MAILBOX_MESSAGE then message_reserved_data.info_ptr = P_im_message_info_ptr; 255 else if message_type = NEW_MESSAGE then do; 256 allocate new_message_info in (mlsys_area) set (new_message_info_ptr); 257 message_reserved_data.info_ptr = new_message_info_ptr; 258 new_message_info.date_time_created = 0; /* hidden copy so that formatting shows nothing */ 259 end; 260 else message_reserved_data.info_ptr = null (); /* incoming messages don't have hidden data */ 261 262 message.n_reply_references, message.n_user_fields, message.n_redistributions = 0; 263 264 string (message.flags) = ""b; 265 266 message.date_time_mailed, message.date_time_delivered = 0; 267 message.sender, message.trace, message.delivered_by, message.acknowledge_to = null (); 268 269 message.message_id = ""b; /* will be set later for in-mailbox/incoming */ 270 271 message.access_class = get_authorization_ (); 272 273 message.date_time_created = 0; 274 275 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, message.from, (0)); 276 call mlsys_address_list_mgr_$increment_reference_count (message.from); 277 278 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, message.reply_to, (0)); 279 call mlsys_address_list_mgr_$increment_reference_count (message.reply_to); 280 281 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, message.to, (0)); 282 call mlsys_address_list_mgr_$increment_reference_count (message.to); 283 284 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, message.cc, (0)); 285 call mlsys_address_list_mgr_$increment_reference_count (message.cc); 286 287 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, message.bcc, (0)); 288 call mlsys_address_list_mgr_$increment_reference_count (message.bcc); 289 290 message.subject.text_ptr = addr (NULL_STRING); /* avoid causing anyone faults */ 291 message.subject.text_lth = 0; 292 string (message.subject.flags) = ""b; /* this turns subject.multiline_text off */ 293 addr (message.subject.flags.reserved) -> message_text_field_reserved_flags.free_text = "0"b; 294 295 message_references_list_n_references = mlsys_data_$message_references_list_allocation; 296 allocate message_references_list in (mlsys_area) set (message_references_list_ptr); 297 message_references_list.version = MESSAGE_REFERENCES_LIST_VERSION_2; 298 message_references_list_reserved_data.n_references_allocated = message_references_list_n_references; 299 message_references_list.n_references = 0; 300 message.reply_references = message_references_list_ptr; 301 message_references_list_reserved_data.message_ptr = message_ptr; 302 303 message_n_user_fields = mlsys_data_$message_user_fields_allocation; 304 allocate message_user_fields_list in (mlsys_area) set (message.user_fields_list); 305 message_user_fields_list.version = MESSAGE_USER_FIELDS_LIST_VERSION_2; 306 message_user_fields_list_reserved_data.n_user_fields_allocated = message_n_user_fields; 307 message_user_fields_list.n_user_fields = 0; 308 message_user_fields_list_reserved_data.message_ptr = message_ptr; 309 310 if message_type = NEW_MESSAGE then /* new messages can't have redistributions ... */ 311 message.redistributions_list = null (); 312 else do; /* ... but in-mailbox and incoming messages do */ 313 message_n_redistributions = mlsys_data_$message_redistributions_list_allocation; 314 allocate message_redistributions_list in (mlsys_area) set (message.redistributions_list); 315 message_redistributions_list.version = MESSAGE_REDISTRIBUTIONS_LIST_VERSION_2; 316 message_redistributions_list_reserved_data.n_redistributions_allocated = message_n_redistributions; 317 message_redistributions_list.n_redistributions = 0; 318 message_redistributions_list_reserved_data.message_ptr = message_ptr; 319 end; 320 321 message.body.total_lines = 0; /* as said above: no body yet */ 322 323 P_message_ptr = message_ptr; 324 P_code = 0; /* success */ 325 326 return; 327 328 /* Free a message */ 329 330 free_message: /* ... any type of message */ 331 entry (P_message_ptr, P_code); 332 333 if ^verify_message_internal (P_message_ptr, P_code) then return; 334 go to FREE_MESSAGE_COMMON; 335 336 337 free_message_new: /* ... a new message only: target of user-ring gate */ 338 entry (P_message_ptr, P_code); 339 340 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 341 342 343 FREE_MESSAGE_COMMON: 344 message_ptr = copy_ptr (P_message_ptr); 345 P_message_ptr = null (); /* insure the caller doesn't use it anymore */ 346 347 do idx = message.n_body_sections to 1 by -1; /* get rid of any body that's present */ 348 call delete_body_section_internal (idx); 349 end; 350 351 do idx = message.n_redistributions to 1 by -1; /* non-zero only if message.redistributions_list non-null */ 352 call delete_redistribution_internal (idx); 353 end; 354 if message.redistributions_list ^= null () then free message_redistributions_list in (mlsys_area); 355 message.redistributions_list = null (); /* handles a cleanup during the free doing another free */ 356 357 do idx = message.n_user_fields to 1 by -1; 358 call delete_user_field_internal (idx); 359 end; 360 free message_user_fields_list in (mlsys_area); 361 message.user_fields_list = null (); 362 363 do idx = message.n_reply_references to 1 by -1; 364 call delete_reference_internal (message.n_reply_references, message.reply_references, idx); 365 end; 366 free message.reply_references -> message_references_list in (mlsys_area); 367 message.reply_references = null (); 368 369 if addr (message.subject.flags.reserved) -> message_text_field_reserved_flags.free_text then 370 if (message.subject.text_ptr ^= null ()) & (message.subject.text_ptr ^= addr (NULL_STRING)) then do; 371 free message_subject in (mlsys_area); 372 message.subject.text_ptr = null (); 373 end; 374 375 if message.bcc ^= null () then call mlsys_address_list_mgr_$decrement_reference_count (message.bcc); 376 if message.cc ^= null () then call mlsys_address_list_mgr_$decrement_reference_count (message.cc); 377 if message.to ^= null () then call mlsys_address_list_mgr_$decrement_reference_count (message.to); 378 if message.reply_to ^= null () then call mlsys_address_list_mgr_$decrement_reference_count (message.reply_to); 379 if message.from ^= null () then call mlsys_address_list_mgr_$decrement_reference_count (message.from); 380 381 call delete_envelope (addr (message.envelope)); 382 383 if message_reserved_data.info_ptr ^= null () then 384 if message_reserved_data.type = NEW_MESSAGE then 385 free message_reserved_data.info_ptr -> new_message_info in (mlsys_area); 386 message_reserved_data.info_ptr = null (); 387 388 free message in (mlsys_area); 389 390 P_code = 0; /* all done */ 391 392 return; 393 394 /* Add a section to the body of a message */ 395 396 add_body_section: /* ... for any type of message */ 397 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_position, P_code); 398 399 if ^verify_message_internal (P_message_ptr, P_code) then return; 400 copy_section_content = "1"b; 401 go to ADD_BODY_SECTION_COMMON; 402 403 404 add_body_section_no_copy: /* ... for any type of message: section content in our ring */ 405 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_position, P_code); 406 407 if ^verify_message_internal (P_message_ptr, P_code) then return; 408 copy_section_content = "0"b; 409 go to ADD_BODY_SECTION_COMMON; 410 411 412 add_body_section_new: /* ... for a new message: target of user-ring gate */ 413 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_position, P_code); 414 415 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 416 copy_section_content = "1"b; 417 418 419 ADD_BODY_SECTION_COMMON: 420 message_ptr = copy_ptr (P_message_ptr); 421 message_body_section_parameter_ptr = P_message_body_section_parameter_ptr; 422 423 if message_body_section_parameter.version ^= MESSAGE_BODY_SECTION_PARAMETER_VERSION_2 then do; 424 P_code = error_table_$unimplemented_version; 425 return; 426 end; 427 428 message_body_section_ptr = addr (message_body_section_parameter.section); 429 if ^verify_body_section (message_body_section_ptr, P_code) then return; 430 431 call compute_position_for_add (P_position, message.n_body_sections, position); 432 433 call add_body_section_internal (); /* do the actual work (also used by replace_body_*) */ 434 435 if message_reserved_data.type = NEW_MESSAGE then /* record date/time of latest change to message body */ 436 message_reserved_data.info_ptr -> new_message_info.date_time_created = clock (); 437 438 P_message_ptr = message_ptr; /* in case we had to expand message.body_sections */ 439 P_position = position; /* let caller know where we put it */ 440 P_code = 0; /* success */ 441 442 return; 443 444 /* Actually adds a section to the message body (called by several entrypoints) */ 445 446 add_body_section_internal: 447 procedure (); 448 449 dcl 1 the_body_section aligned like message_body_section based (the_section_ptr); 450 dcl 1 the_preformatted_body_section aligned like message_preformatted_body_section based (the_section_ptr); 451 dcl 1 the_bit_string_body_section aligned like message_bit_string_body_section based (the_section_ptr); 452 453 dcl (new_message_ptr, the_section_ptr) pointer; 454 dcl idx fixed binary; 455 456 new_message_ptr = null (); /* for cleanup handler */ 457 458 on condition (cleanup) 459 begin; 460 if new_message_ptr ^= null () then free new_message_ptr -> message in (mlsys_area); 461 new_message_ptr = null (); 462 end; 463 464 /*** Expand the message structure if necessary */ 465 if (message.n_body_sections + 1) > message_reserved_data.n_body_sections_allocated then do; 466 message_n_body_sections = 467 message_reserved_data.n_body_sections_allocated + mlsys_data_$message_body_sections_allocation; 468 allocate message in (mlsys_area) set (new_message_ptr); 469 new_message_ptr -> message.version = MESSAGE_VERSION_2; 470 new_message_ptr -> message.reserved = message.reserved; 471 addr (new_message_ptr -> message.reserved) -> message_reserved_data.n_body_sections_allocated = 472 message_n_body_sections; 473 new_message_ptr -> message.n_reply_references = message.n_reply_references; 474 new_message_ptr -> message.n_user_fields = message.n_user_fields; 475 new_message_ptr -> message.n_redistributions = message.n_redistributions; 476 new_message_ptr -> message.n_body_sections = message.n_body_sections; 477 string (new_message_ptr -> message.flags) = string (message.flags); 478 new_message_ptr -> message.envelope = message.envelope; 479 new_message_ptr -> message.header = message.header; 480 new_message_ptr -> message.redistributions_list = message.redistributions_list; 481 new_message_ptr -> message.body.total_lines = message.body.total_lines; 482 do idx = 1 to message.n_body_sections; 483 new_message_ptr -> message.body.body_sections (idx) = message.body.body_sections (idx); 484 end; 485 free message in (mlsys_area); 486 message_ptr = new_message_ptr; 487 new_message_ptr = null (); 488 end; 489 490 /*** Make room for the new section by moving any existing sections behind it up by one */ 491 do idx = message.n_body_sections to position by -1; 492 message.body.body_sections (idx + 1) = message.body.body_sections (idx); 493 end; 494 495 /*** Copy in the new section and, if needed, copy the actual data */ 496 the_section_ptr = addr (message.body.body_sections (position)); 497 the_body_section.header = message_body_section.header; 498 go to ADD_SECTION (message_body_section.section_type); 499 500 ADD_SECTION (1): /* preformatted text */ 501 string (the_preformatted_body_section.reserved) = ""b; 502 if copy_section_content then do; /* ... always copy it */ 503 COPY_PREFORMATTED_TEXT: 504 call normalize_multiline_field (message_preformatted_body_section_text, 505 the_preformatted_body_section.text_ptr, the_preformatted_body_section.text_lth); 506 addr (the_preformatted_body_section.reserved) 507 -> message_preformatted_body_section_reserved_data.free_text = "1"b; 508 end; 509 else /* ... copy caller's text only if it's misformatted ... */ 510 if index (message_preformatted_body_section_text, HT) ^= 0 then go to COPY_PREFORMATTED_TEXT; 511 else /* ... or not in one of our temporary segments ... */ 512 if ^mlsys_data_$valid_segments (binary (baseno (message_preformatted_body_section.text_ptr), 18, 0)) then 513 go to COPY_PREFORMATTED_TEXT; 514 else do; /* ... caller's text is OK */ 515 the_preformatted_body_section.text_ptr = copy_ptr (message_preformatted_body_section.text_ptr); 516 the_preformatted_body_section.text_lth = message_preformatted_body_section.text_lth; 517 end; 518 the_body_section.section_n_lines = 519 count_lines_in_text (the_preformatted_body_section.text_ptr -> message_preformatted_body_section_text); 520 go to END_ADD_SECTION_CASE; 521 522 ADD_SECTION (2): /* bit string */ 523 the_body_section.section_n_lines = -1; 524 the_bit_string_body_section.bit_string_lth = message_bit_string_body_section.bit_string_lth; 525 string (the_bit_string_body_section.reserved) = ""b; 526 /* ... above turns off the free_bit_string flag */ 527 if copy_section_content then do; 528 COPY_BIT_STRING: 529 allocate message_bit_string_body_section_bit_string in (mlsys_area) 530 set (the_bit_string_body_section.bit_string_ptr); 531 the_bit_string_body_section.bit_string_ptr -> message_bit_string_body_section_bit_string = 532 message_bit_string_body_section_bit_string; 533 addr (the_bit_string_body_section.reserved) 534 -> message_bit_string_body_section_reserved_data.free_bit_string = "1"b; 535 end; 536 else /* copy if not in one of our temporary segments */ 537 if ^mlsys_data_$valid_segments (binary (baseno (message_bit_string_body_section.bit_string_ptr), 18, 0)) 538 then go to COPY_BIT_STRING; 539 else the_bit_string_body_section.bit_string_ptr = copy_ptr (message_bit_string_body_section.bit_string_ptr); 540 go to END_ADD_SECTION_CASE; 541 542 END_ADD_SECTION_CASE: 543 message.n_body_sections = message.n_body_sections + 1; 544 545 /*** Recompute the number of lines in the body */ 546 message.body.total_lines = 0; 547 do idx = 1 to message.n_body_sections while (message.body.total_lines ^= -1); 548 if message.body.body_sections (idx).section_n_lines = -1 then 549 message.body.total_lines = -1; 550 else message.body.total_lines = 551 message.body.total_lines + message.body.body_sections (idx).section_n_lines; 552 end; 553 554 if message.body.total_lines ^= -1 then /* take the lines in between sections into account */ 555 message.body.total_lines = message.body.total_lines + message.n_body_sections - 1; 556 557 return; 558 559 end add_body_section_internal; 560 561 /* Add a redistribution to the list of redistributions for a given message */ 562 563 add_redistribution: /* ... for any type of message */ 564 entry (P_message_ptr, P_message_redistribution_parameter_ptr, P_position, P_code); 565 566 if ^verify_message_internal (P_message_ptr, P_code) then return; 567 copy_redistribution_data = "1"b; 568 go to ADD_REDISTRIBUTION_COMMON; 569 570 571 add_redistribution_no_copy: /* ... for any type of message; data already in our ring */ 572 entry (P_message_ptr, P_message_redistribution_parameter_ptr, P_position, P_code); 573 574 if ^verify_message_internal (P_message_ptr, P_code) then return; 575 copy_redistribution_data = "0"b; 576 577 578 ADD_REDISTRIBUTION_COMMON: 579 message_ptr = copy_ptr (P_message_ptr); 580 message_redistribution_parameter_ptr = P_message_redistribution_parameter_ptr; 581 582 if message_redistribution_parameter.version ^= MESSAGE_REDISTRIBUTION_PARAMETER_VERSION_2 then do; 583 P_code = error_table_$unimplemented_version; 584 return; 585 end; 586 587 message_redistribution_ptr = addr (message_redistribution_parameter.redistribution); 588 if ^verify_redistribution (message_redistribution_ptr, P_code) then return; 589 590 call compute_position_for_add (P_position, message.n_redistributions, position); 591 592 call add_redistribution_internal (); /* do the actual work (used by replace_redistribution_*) */ 593 594 P_position = position; /* let caller know where we put it */ 595 P_code = 0; /* success */ 596 597 return; 598 599 600 601 /* Actually adds a redistribution to the message's redistributions lists (called by several entrypoints) */ 602 603 add_redistribution_internal: 604 procedure (); 605 606 dcl 1 the_redistribution aligned based (the_redistribution_ptr) like message_redistribution; 607 608 dcl (new_rl_ptr, the_redistribution_ptr) pointer; 609 dcl idx fixed binary; 610 611 new_rl_ptr = null (); /* for cleanup handler */ 612 613 on condition (cleanup) 614 begin; 615 if new_rl_ptr ^= null () then free new_rl_ptr -> message_redistributions_list in (mlsys_area); 616 new_rl_ptr = null (); 617 end; 618 619 /*** Expand the message_redistributions_list structure if necessary */ 620 if (message.n_redistributions + 1) > message_redistributions_list_reserved_data.n_redistributions_allocated 621 then do; 622 message_n_redistributions = 623 message_redistributions_list_reserved_data.n_redistributions_allocated 624 + mlsys_data_$message_redistributions_list_allocation; 625 allocate message_redistributions_list in (mlsys_area) set (new_rl_ptr); 626 new_rl_ptr -> message_redistributions_list.version = MESSAGE_REDISTRIBUTIONS_LIST_VERSION_2; 627 new_rl_ptr -> message_redistributions_list.reserved = message_redistributions_list.reserved; 628 addr (new_rl_ptr -> message_redistributions_list.reserved) 629 -> message_redistributions_list_reserved_data.n_redistributions_allocated = message_n_redistributions; 630 new_rl_ptr -> message_redistributions_list.n_redistributions = 631 message_redistributions_list.n_redistributions; 632 do idx = 1 to message.n_redistributions; 633 new_rl_ptr -> message_redistributions_list.redistributions (idx) = 634 message_redistributions_list.redistributions (idx); 635 end; 636 free message_redistributions_list in (mlsys_area); 637 message.redistributions_list = new_rl_ptr; 638 new_rl_ptr = null (); 639 end; 640 641 /*** Make room for the new redistribution by moving any existing redistributions behind it up by one */ 642 do idx = message.n_redistributions to position by -1; 643 message_redistributions_list.redistributions (idx + 1) = 644 message_redistributions_list.redistributions (idx); 645 end; 646 647 /*** Copy in the new redistribution */ 648 the_redistribution_ptr = addr (message_redistributions_list.redistributions (position)); 649 call set_envelope (addr (message_redistribution.envelope), addr (the_redistribution.envelope)); 650 the_redistribution.header = message_redistribution.header; 651 if the_redistribution.from ^= null () then do; 652 if copy_redistribution_data then 653 call mlsys_address_list_mgr_$copy_address_list (the_redistribution.from, the_redistribution.from, (0)) 654 ; 655 else the_redistribution.from = copy_ptr (the_redistribution.from); 656 call mlsys_address_list_mgr_$set_read_only (the_redistribution.from); 657 end; 658 else call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, 659 the_redistribution.from, (0)); 660 call mlsys_address_list_mgr_$increment_reference_count (the_redistribution.from); 661 if the_redistribution.to ^= null () then do; 662 if copy_redistribution_data then 663 call mlsys_address_list_mgr_$copy_address_list (the_redistribution.to, the_redistribution.to, (0)); 664 else the_redistribution.to = copy_ptr (the_redistribution.to); 665 call mlsys_address_list_mgr_$set_read_only (the_redistribution.to); 666 end; 667 else call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, the_redistribution.to, 668 (0)); 669 call mlsys_address_list_mgr_$increment_reference_count (the_redistribution.to); 670 671 /*** Copy the comment (if necessary) */ 672 string (the_redistribution.comment.flags) = ""b; /* turns off the "free_text" flag */ 673 the_redistribution.comment.multiline_text = "1"b; /* always treated as multiline */ 674 if (message_redistribution.comment.text_ptr = null ()) | (message_redistribution.comment.text_lth = 0) then do; 675 the_redistribution.comment.text_ptr = addr (NULL_STRING); 676 the_redistribution.comment.text_lth = 0; 677 end; 678 else if copy_redistribution_data then do; /* always copy the comment */ 679 COPY_REDISTRIBUTION_COMMENT: 680 call normalize_multiline_field (message_redistribution_comment, the_redistribution.comment.text_ptr, 681 the_redistribution.comment.text_lth); 682 addr (the_redistribution.comment.flags.reserved) -> message_text_field_reserved_flags.free_text = "1"b; 683 end; 684 else /* copy it only if it's misformatted ... */ 685 if index (message_redistribution_comment, HT) ^= 0 then go to COPY_REDISTRIBUTION_COMMENT; 686 else /* ... or not in one of our temporary segments ... */ 687 if ^mlsys_data_$valid_segments (binary (baseno (message_redistribution.comment.text_ptr), 18, 0)) then 688 go to COPY_REDISTRIBUTION_COMMENT; 689 else do; /* caller's text is OK */ 690 the_redistribution.comment.text_ptr = copy_ptr (message_redistribution.comment.text_ptr); 691 the_redistribution.comment.text_lth = message_redistribution.comment.text_lth; 692 end; 693 694 message_redistributions_list.n_redistributions, message.n_redistributions = message.n_redistributions + 1; 695 696 return; 697 698 end add_redistribution_internal; 699 700 /* Add a reference (as given or to the given message) to the list of messages for which this message is a reply */ 701 702 add_reply_reference: /* ... for any type message */ 703 entry (P_message_ptr, P_message_reference_parameter_ptr, P_position, P_code); 704 705 if ^verify_message_internal (P_message_ptr, P_code) then return; 706 copy_reference_data = "1"b; 707 go to ADD_REPLY_REFERENCE_COMMON; 708 709 710 add_reply_reference_no_copy: /* ... for any type message: data already in our ring */ 711 entry (P_message_ptr, P_message_reference_parameter_ptr, P_position, P_code); 712 713 if ^verify_message_internal (P_message_ptr, P_code) then return; 714 copy_reference_data = "0"b; 715 go to ADD_REPLY_REFERENCE_COMMON; 716 717 718 add_reply_reference_new: /* ... for a new message: target of user-ring gate */ 719 entry (P_message_ptr, P_referenced_message_ptr, P_position, P_code); 720 721 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 722 if ^verify_im_message_internal (P_referenced_message_ptr, P_code) then return; 723 copy_reference_data = "0"b; /* it's already in the right place from in-mailbox message */ 724 725 message_ptr = copy_ptr (P_referenced_message_ptr);/* need to access the original temporarily */ 726 message_reference_parameter_ptr = addr (local_mrfp); 727 message_reference_parameter.reference.message_id = message.message_id; 728 message_reference_parameter.reference.date_time_created = message.date_time_created; 729 message_reference_parameter.reference.from = message.from; 730 message_reference_parameter.reference.subject = message.subject; 731 go to ADD_REPLY_REFERENCE_NO_RP_CHECK; 732 733 734 ADD_REPLY_REFERENCE_COMMON: 735 message_reference_parameter_ptr = P_message_reference_parameter_ptr; 736 if message_reference_parameter.version ^= MESSAGE_REFERENCE_PARAMETER_VERSION_2 then do; 737 P_code = error_table_$unimplemented_version; 738 return; 739 end; 740 if ^verify_reference (addr (message_reference_parameter.reference), P_code) then return; 741 742 ADD_REPLY_REFERENCE_NO_RP_CHECK: 743 message_ptr = copy_ptr (P_message_ptr); 744 message_reference_ptr = addr (message_reference_parameter.reference); 745 746 /*** Check for duplicate reply references */ 747 do idx = 1 to message.n_reply_references; 748 if message.reply_references -> message_references_list.references (idx).message_id 749 = message_reference.message_id then do; 750 P_position = idx; /* let caller know where the duplicate resides */ 751 P_code = mlsys_et_$duplicate_reply_reference; 752 return; 753 end; 754 end; 755 756 call compute_position_for_add (P_position, message.n_reply_references, position); 757 758 call add_reference_internal (message.n_reply_references, message.reply_references); 759 760 P_position = position; /* let caller know where we put it */ 761 P_code = 0; /* success */ 762 763 return; 764 765 766 767 /* Actually adds a reference to the message's references lists (called by several entrypoints) */ 768 769 add_reference_internal: 770 procedure (p_n_references, p_references_list_ptr); 771 772 dcl p_n_references fixed binary parameter; 773 dcl p_references_list_ptr pointer parameter; 774 775 dcl 1 the_reference aligned based (the_reference_ptr) like message_reference; 776 777 dcl (new_rl_ptr, the_reference_ptr) pointer; 778 dcl idx fixed binary; 779 780 message_references_list_ptr = p_references_list_ptr; 781 /* can't use like because it contains a refer extent */ 782 new_rl_ptr = null (); /* for cleanup handler */ 783 784 on condition (cleanup) 785 begin; 786 if new_rl_ptr ^= null () then free new_rl_ptr -> message_references_list in (mlsys_area); 787 new_rl_ptr = null (); 788 end; 789 790 /*** Expand the message_references_list structure if necessary */ 791 if (p_n_references + 1) > message_references_list_reserved_data.n_references_allocated then do; 792 message_references_list_n_references = 793 message_references_list_reserved_data.n_references_allocated 794 + mlsys_data_$message_references_list_allocation; 795 allocate message_references_list in (mlsys_area) set (new_rl_ptr); 796 new_rl_ptr -> message_references_list.version = MESSAGE_REFERENCES_LIST_VERSION_2; 797 new_rl_ptr -> message_references_list.reserved = message_references_list.reserved; 798 addr (new_rl_ptr -> message_references_list.reserved) 799 -> message_references_list_reserved_data.n_references_allocated = 800 message_references_list_n_references; 801 new_rl_ptr -> message_references_list.n_references = message_references_list.n_references; 802 do idx = 1 to message.n_reply_references; 803 new_rl_ptr -> message_references_list.references (idx) = message_references_list.references (idx); 804 end; 805 free message_references_list in (mlsys_area); 806 p_references_list_ptr, message_references_list_ptr = new_rl_ptr; 807 new_rl_ptr = null (); 808 end; 809 810 /*** Make room for the new reference by moving any existing references behind it up by one */ 811 do idx = p_n_references to position by -1; 812 message_references_list.references (idx + 1) = message_references_list.references (idx); 813 end; 814 815 /*** Copy in the new reference */ 816 the_reference_ptr = addr (message_references_list.references (position)); 817 the_reference = message_reference; /* simple copy */ 818 if the_reference.from ^= null () then do; 819 if copy_reference_data then 820 call mlsys_address_list_mgr_$copy_address_list (the_reference.from, the_reference.from, (0)); 821 else the_reference.from = copy_ptr (the_reference.from); 822 call mlsys_address_list_mgr_$set_read_only (the_reference.from); 823 call mlsys_address_list_mgr_$increment_reference_count (the_reference.from); 824 end; 825 826 /*** Copy the subject (if necessary) */ 827 string (the_reference.subject.flags) = ""b; /* turns off both multiline_text & free_text */ 828 if (message_reference.subject.text_ptr = null ()) | (message_reference.subject.text_lth = 0) then do; 829 the_reference.subject.text_ptr = addr (NULL_STRING); 830 the_reference.subject.text_lth = 0; 831 end; 832 else if copy_reference_data then do; /* copy it no matter what */ 833 COPY_REFERENCED_SUBJECT: 834 call normalize_single_line_field (message_reference_subject, the_reference.subject.text_ptr, 835 the_reference.subject.text_lth); 836 addr (the_reference.subject.flags.reserved) -> message_text_field_reserved_flags.free_text = "1"b; 837 end; 838 else do; /* copy it only if it's improperly formatted */ 839 if ^mlsys_data_$valid_segments (binary (baseno (addr (message_reference_subject)), 18, 0)) then 840 go to COPY_REFERENCED_SUBJECT; 841 if search (message_reference_subject, NON_SPACE_WHITESPACE) ^= 0 then go to COPY_REFERENCED_SUBJECT; 842 if verify (message_reference_subject, SPACE) ^= 1 then go to COPY_REFERENCED_SUBJECT; 843 if substr (message_reference_subject, length (message_reference_subject), 1) = SPACE then 844 go to COPY_REFERENCED_SUBJECT; 845 if index (message_reference_subject, SPACE_SPACE) ^= 0 then go to COPY_REFERENCED_SUBJECT; 846 the_reference.subject.text_ptr = copy_ptr (message_reference.subject.text_ptr); 847 the_reference.subject.text_lth = message_reference.subject.text_lth; 848 end; /* ... above is executed iff caller's text is OK */ 849 850 message_references_list.n_references, p_n_references = p_n_references + 1; 851 852 return; 853 854 end add_reference_internal; 855 856 /* Add a user-defined field to the message */ 857 858 add_user_field: /* ... for any type of message */ 859 entry (P_message_ptr, P_message_user_field_parameter_ptr, P_position, P_allow_duplicates, P_code); 860 861 if ^verify_message_internal (P_message_ptr, P_code) then return; 862 copy_user_field_content = "1"b; 863 go to ADD_USER_FIELD_COMMON; 864 865 866 add_user_field_no_copy: /* ... for any type of message: data already in our ring */ 867 entry (P_message_ptr, P_message_user_field_parameter_ptr, P_position, P_allow_duplicates, P_code); 868 869 if ^verify_message_internal (P_message_ptr, P_code) then return; 870 copy_user_field_content = "0"b; 871 go to ADD_USER_FIELD_COMMON; 872 873 874 add_user_field_new: /* ... for a new message: target of user-ring gate */ 875 entry (P_message_ptr, P_message_user_field_parameter_ptr, P_position, P_allow_duplicates, P_code); 876 877 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 878 copy_user_field_content = "1"b; 879 880 881 ADD_USER_FIELD_COMMON: 882 message_ptr = copy_ptr (P_message_ptr); 883 message_user_field_parameter_ptr = P_message_user_field_parameter_ptr; 884 885 if message_user_field_parameter.version ^= MESSAGE_USER_FIELD_PARAMETER_VERSION_2 then do; 886 P_code = error_table_$unimplemented_version; 887 return; 888 end; 889 890 message_user_field_ptr = addr (message_user_field_parameter.user_field); 891 if ^verify_user_field (message_user_field_ptr, P_code) then return; 892 893 /*** Check for duplicate fields if requested */ 894 if ^P_allow_duplicates then do; 895 do idx = 1 to message.n_user_fields; 896 if message_user_fields_list.user_fields (idx).field_id = message_user_field.field_id then do; 897 P_position = idx; /* let caller know where the first duplicate lies */ 898 P_code = mlsys_et_$duplicate_user_field; 899 return; 900 end; 901 end; 902 end; 903 904 call compute_position_for_add (P_position, message.n_user_fields, position); 905 906 call add_user_field_internal (); /* do the actual work (also used by replace_user_field_*) */ 907 908 P_position = position; /* let caller know where we put it */ 909 P_code = 0; /* success */ 910 911 return; 912 913 914 915 /* Actually adds a user-defined field to the message (called by several entrypoints) */ 916 917 add_user_field_internal: 918 procedure (); 919 920 dcl 1 the_user_field aligned like message_user_field based (the_user_field_ptr); 921 dcl 1 the_text_user_field aligned like message_text_user_field based (the_user_field_ptr); 922 dcl 1 the_address_list_user_field aligned like message_address_list_user_field based (the_user_field_ptr); 923 dcl 1 the_date_user_field aligned like message_date_user_field based (the_user_field_ptr); 924 dcl 1 the_integer_user_field aligned like message_integer_user_field based (the_user_field_ptr); 925 926 dcl (new_ufl_ptr, the_user_field_ptr) pointer; 927 dcl idx fixed binary; 928 929 new_ufl_ptr = null (); /* for cleanup handler */ 930 931 on condition (cleanup) 932 begin; 933 if new_ufl_ptr ^= null () then free new_ufl_ptr -> message_user_fields_list in (mlsys_area); 934 new_ufl_ptr = null (); 935 end; 936 937 /*** Expand the message_user_fields structure if necessary */ 938 if (message.n_user_fields + 1) > message_user_fields_list_reserved_data.n_user_fields_allocated then do; 939 message_n_user_fields = 940 message_user_fields_list_reserved_data.n_user_fields_allocated 941 + mlsys_data_$message_user_fields_allocation; 942 allocate message_user_fields_list in (mlsys_area) set (new_ufl_ptr); 943 new_ufl_ptr -> message_user_fields_list.version = MESSAGE_USER_FIELDS_LIST_VERSION_2; 944 new_ufl_ptr -> message_user_fields_list.reserved = message_user_fields_list.reserved; 945 addr (new_ufl_ptr -> message_user_fields_list.reserved) 946 -> message_user_fields_list_reserved_data.n_user_fields_allocated = message_n_user_fields; 947 new_ufl_ptr -> message_user_fields_list.n_user_fields = message_user_fields_list.n_user_fields; 948 do idx = 1 to message.n_user_fields; 949 new_ufl_ptr -> message_user_fields_list.user_fields (idx) = 950 message_user_fields_list.user_fields (idx); 951 end; 952 free message_user_fields_list in (mlsys_area); 953 message.user_fields_list = new_ufl_ptr; 954 new_ufl_ptr = null (); 955 end; 956 957 /*** Make room for the new user-defined field by moving any existing fields behind it up by one */ 958 do idx = message.n_user_fields to position by -1; 959 message_user_fields_list.user_fields (idx + 1) = message_user_fields_list.user_fields (idx); 960 end; 961 962 /*** Copy in the new user-defined field and, if needed, copy the actual data */ 963 the_user_field_ptr = addr (message_user_fields_list.user_fields (position)); 964 the_user_field.header = message_user_field.header; 965 go to ADD_USER_FIELD (message_user_field.field_type); 966 967 ADD_USER_FIELD (1): /* user-defined text field */ 968 the_text_user_field.multiline_text = message_text_user_field.multiline_text; 969 string (the_text_user_field.flags.reserved) = ""b;/* ... turns off the "free_text" flag */ 970 if (message_text_user_field.text_ptr = null ()) | (message_text_user_field.text_lth = 0) then do; 971 the_text_user_field.text_ptr = addr (NULL_STRING); 972 the_text_user_field.text_lth = 0; 973 end; 974 else if copy_user_field_content then do; /* copy it no matter what */ 975 COPY_USER_FIELD_TEXT: 976 if the_text_user_field.multiline_text then /* ... eliminate tabs from multiline text */ 977 call normalize_multiline_field (message_text_user_field_text, the_text_user_field.text_ptr, 978 the_text_user_field.text_lth); 979 else call normalize_single_line_field (message_text_user_field_text, the_text_user_field.text_ptr, 980 the_text_user_field.text_lth); 981 addr (the_text_user_field.flags.reserved) -> message_text_field_reserved_flags.free_text = "1"b; 982 end; 983 else if ^mlsys_data_$valid_segments (binary (baseno (addr (message_text_user_field_text)), 18, 0)) then 984 go to COPY_USER_FIELD_TEXT; 985 else if the_text_user_field.multiline_text then /* copy it only if it's improperly formatted */ 986 if index (message_text_user_field_text, HT) ^= 0 then 987 go to COPY_USER_FIELD_TEXT; /* ... have to "canonicalize" tabs */ 988 else do; /* ... caller's text is OK */ 989 the_text_user_field.text_ptr = copy_ptr (message_text_user_field.text_ptr); 990 the_text_user_field.text_lth = message_text_user_field.text_lth; 991 end; 992 else /*** if ^the_text_user_field.multiline_text then */ 993 do; /* copy it only if it's improperly formatted */ 994 if search (message_text_user_field_text, NON_SPACE_WHITESPACE) ^= 0 then go to COPY_USER_FIELD_TEXT; 995 if verify (message_text_user_field_text, SPACE) ^= 1 then go to COPY_USER_FIELD_TEXT; 996 if substr (message_text_user_field_text, length (message_text_user_field_text), 1) = SPACE then 997 go to COPY_USER_FIELD_TEXT; 998 if index (message_text_user_field_text, SPACE_SPACE) ^= 0 then go to COPY_USER_FIELD_TEXT; 999 the_text_user_field.text_ptr = copy_ptr (message_text_user_field.text_ptr); 1000 the_text_user_field.text_lth = message_text_user_field.text_lth; 1001 end; /* ... above is executed iff caller's text is OK */ 1002 go to END_ADD_USER_FIELD_CASE; 1003 1004 ADD_USER_FIELD (2): /* user-defined address list field */ 1005 the_address_list_user_field.address_list_ptr = copy_ptr (message_address_list_user_field.address_list_ptr); 1006 if the_address_list_user_field.address_list_ptr ^= null () then do; 1007 if copy_user_field_content then 1008 call mlsys_address_list_mgr_$copy_address_list (the_address_list_user_field.address_list_ptr, 1009 the_address_list_user_field.address_list_ptr, (0)); 1010 call mlsys_address_list_mgr_$set_read_only (the_address_list_user_field.address_list_ptr); 1011 call mlsys_address_list_mgr_$increment_reference_count (the_address_list_user_field.address_list_ptr); 1012 end; 1013 go to END_ADD_USER_FIELD_CASE; 1014 1015 ADD_USER_FIELD (3): /* user-defined date field */ 1016 the_date_user_field.date_time = message_date_user_field.date_time; 1017 go to END_ADD_USER_FIELD_CASE; 1018 1019 ADD_USER_FIELD (4): /* user-defined integer field */ 1020 the_integer_user_field.value = message_integer_user_field.value; 1021 go to END_ADD_USER_FIELD_CASE; 1022 1023 END_ADD_USER_FIELD_CASE: 1024 message_user_fields_list.n_user_fields, message.n_user_fields = message.n_user_fields + 1; 1025 1026 return; 1027 1028 end add_user_field_internal; 1029 1030 /* Delete the specified section of the message body */ 1031 1032 delete_body_section: /* ... for any type of message */ 1033 entry (P_message_ptr, P_position, P_code); 1034 1035 if ^verify_message_internal (P_message_ptr, P_code) then return; 1036 go to DELETE_BODY_SECTION_COMMON; 1037 1038 1039 delete_body_section_new: /* ... for a new message: target of user-ring gate */ 1040 entry (P_message_ptr, P_position, P_code); 1041 1042 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1043 1044 1045 DELETE_BODY_SECTION_COMMON: 1046 message_ptr = copy_ptr (P_message_ptr); 1047 position = P_position; 1048 1049 if (position < 1) | (position > message.n_body_sections) then do; 1050 P_code = error_table_$bad_index; 1051 return; 1052 end; 1053 1054 call delete_body_section_internal (position); 1055 1056 if message_reserved_data.type = NEW_MESSAGE then /* record date/time of latest change to message body */ 1057 message_reserved_data.info_ptr -> new_message_info.date_time_created = clock (); 1058 1059 P_code = 0; /* success */ 1060 1061 return; 1062 1063 1064 1065 /* Actually deletes a message body section (called by several entrypoints) */ 1066 1067 delete_body_section_internal: 1068 procedure (p_position); 1069 1070 dcl p_position fixed binary parameter; 1071 dcl idx fixed binary; 1072 1073 message_body_section_ptr = addr (message.body.body_sections (p_position)); 1074 1075 if message_body_section.section_type = MESSAGE_PREFORMATTED_BODY_SECTION then 1076 if message_preformatted_body_section_reserved_data.free_text then 1077 if (message_preformatted_body_section.text_ptr ^= null ()) 1078 & (message_preformatted_body_section.text_ptr ^= addr (NULL_STRING)) then do; 1079 free message_preformatted_body_section_text in (mlsys_area); 1080 message_preformatted_body_section.text_ptr = null (); 1081 end; 1082 else ; 1083 else ; 1084 1085 else if message_body_section.section_type = MESSAGE_BIT_STRING_BODY_SECTION then 1086 if message_bit_string_body_section_reserved_data.free_bit_string then 1087 if (message_bit_string_body_section.bit_string_ptr ^= null ()) 1088 & (message_bit_string_body_section.bit_string_ptr ^= addr (NULL_STRING)) then do; 1089 free message_bit_string_body_section_bit_string in (mlsys_area); 1090 message_bit_string_body_section.bit_string_ptr = null (); 1091 end; 1092 1093 do idx = (p_position + 1) to message.n_body_sections; 1094 message.body.body_sections (idx - 1) = message.body.body_sections (idx); 1095 end; 1096 1097 message.n_body_sections = message.n_body_sections - 1; 1098 1099 /*** Recompute the number of lines in the body */ 1100 message.body.total_lines = 0; 1101 do idx = 1 to message.n_body_sections while (message.body.total_lines ^= -1); 1102 if message.body.body_sections (idx).section_n_lines = -1 then 1103 message.body.total_lines = -1; 1104 else message.body.total_lines = 1105 message.body.total_lines + message.body.body_sections (idx).section_n_lines; 1106 end; 1107 1108 if message.body.total_lines ^= -1 then /* take the lines in between sections into account */ 1109 message.body.total_lines = message.body.total_lines + max (message.n_body_sections, 1) - 1; 1110 1111 return; 1112 1113 end delete_body_section_internal; 1114 1115 /* Delete the specified redistribution from the message's redistributions list */ 1116 1117 delete_redistribution: /* ... for any type of message */ 1118 entry (P_message_ptr, P_position, P_code); 1119 1120 if ^verify_message_internal (P_message_ptr, P_code) then return; 1121 go to DELETE_REDISTRIBUTION_COMMON; 1122 1123 1124 delete_redistribution_no_copy: /* ... for any type of message */ 1125 entry (P_message_ptr, P_position, P_code); 1126 1127 if ^verify_message_internal (P_message_ptr, P_code) then return; 1128 1129 1130 DELETE_REDISTRIBUTION_COMMON: 1131 message_ptr = copy_ptr (P_message_ptr); 1132 position = P_position; 1133 1134 if (position < 1) | (position > message.n_redistributions) then do; 1135 P_code = error_table_$bad_index; 1136 return; 1137 end; 1138 1139 call delete_redistribution_internal (position); 1140 1141 P_code = 0; /* success */ 1142 1143 return; 1144 1145 1146 1147 /* Actually deletes a redistribution (called by several entrypoints) */ 1148 1149 delete_redistribution_internal: 1150 procedure (p_position); 1151 1152 dcl p_position fixed binary parameter; 1153 dcl idx fixed binary; 1154 1155 message_redistribution_ptr = addr (message_redistributions_list.redistributions (p_position)); 1156 1157 call delete_envelope (addr (message_redistribution.envelope)); 1158 /* release all possible data in the envelope */ 1159 1160 if message_redistribution.from ^= null () then 1161 call mlsys_address_list_mgr_$decrement_reference_count (message_redistribution.from); 1162 1163 if message_redistribution.to ^= null () then 1164 call mlsys_address_list_mgr_$decrement_reference_count (message_redistribution.to); 1165 1166 if addr (message_redistribution.comment.flags.reserved) -> message_text_field_reserved_flags.free_text then 1167 if (message_redistribution.comment.text_ptr ^= null ()) 1168 & (message_redistribution.comment.text_ptr ^= addr (NULL_STRING)) then do; 1169 free message_redistribution_comment in (mlsys_area); 1170 message_redistribution.comment.text_ptr = null (); 1171 end; 1172 1173 do idx = (p_position + 1) to message.n_redistributions; 1174 message_redistributions_list.redistributions (idx - 1) = 1175 message_redistributions_list.redistributions (idx); 1176 end; 1177 1178 message_redistributions_list.n_redistributions, message.n_redistributions = message.n_redistributions - 1; 1179 1180 return; 1181 1182 end delete_redistribution_internal; 1183 1184 /* Delete the specified message reference from the message's list of reply references */ 1185 1186 delete_reply_reference: /* ... for any type message */ 1187 entry (P_message_ptr, P_position, P_code); 1188 1189 if ^verify_message_internal (P_message_ptr, P_code) then return; 1190 go to DELETE_REPLY_REFERENCE_COMMON; 1191 1192 1193 delete_reply_reference_new: /* ... for a new message: target of user-ring gate */ 1194 entry (P_message_ptr, P_position, P_code); 1195 1196 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1197 1198 1199 DELETE_REPLY_REFERENCE_COMMON: 1200 message_ptr = copy_ptr (P_message_ptr); 1201 position = P_position; 1202 1203 if (position < 1) | (position > message.n_reply_references) then do; 1204 P_code = error_table_$bad_index; 1205 return; 1206 end; 1207 1208 call delete_reference_internal (message.n_reply_references, message.reply_references, position); 1209 1210 P_code = 0; /* success */ 1211 1212 return; 1213 1214 1215 1216 /* Actually deletes a reference (called by several entrypoints) */ 1217 1218 delete_reference_internal: 1219 procedure (p_n_references, p_references_ptr, p_position); 1220 1221 dcl p_n_references fixed binary parameter; 1222 dcl p_references_ptr pointer parameter; 1223 dcl p_position fixed binary parameter; 1224 dcl idx fixed binary; 1225 1226 message_references_list_ptr = p_references_ptr; 1227 message_reference_ptr = addr (message_references_list.references (p_position)); 1228 1229 if message_reference.from ^= null () then 1230 call mlsys_address_list_mgr_$decrement_reference_count (message_reference.from); 1231 1232 if addr (message_reference.subject.flags.reserved) -> message_text_field_reserved_flags.free_text then 1233 if (message_reference.subject.text_ptr ^= null ()) 1234 & (message_reference.subject.text_ptr ^= addr (NULL_STRING)) then do; 1235 free message_reference_subject in (mlsys_area); 1236 message_reference.subject.text_ptr = null (); 1237 end; 1238 1239 do idx = (p_position + 1) to p_n_references; 1240 message_references_list.references (idx - 1) = message_references_list.references (idx); 1241 end; 1242 1243 message_references_list.n_references, p_n_references = p_n_references - 1; 1244 1245 return; 1246 1247 end delete_reference_internal; 1248 1249 /* Delete the specified user-defined field from the message */ 1250 1251 delete_user_field: /* ... for any type of message */ 1252 entry (P_message_ptr, P_position, P_code); 1253 1254 if ^verify_message_internal (P_message_ptr, P_code) then return; 1255 go to DELETE_USER_FIELD_COMMON; 1256 1257 1258 delete_user_field_new: /* ... for a new message: target of user-ring gate */ 1259 entry (P_message_ptr, P_position, P_code); 1260 1261 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1262 1263 1264 DELETE_USER_FIELD_COMMON: 1265 message_ptr = copy_ptr (P_message_ptr); 1266 position = P_position; 1267 1268 if (position < 1) | (position > message.n_user_fields) then do; 1269 P_code = error_table_$bad_index; 1270 return; 1271 end; 1272 1273 call delete_user_field_internal (position); 1274 1275 P_code = 0; /* success */ 1276 1277 return; 1278 1279 1280 1281 /* Actually deletes a user field (called from several entrypoints) */ 1282 1283 delete_user_field_internal: 1284 procedure (p_position); 1285 1286 dcl p_position fixed binary parameter; 1287 dcl idx fixed binary; 1288 1289 message_user_field_ptr = addr (message_user_fields_list.user_fields (p_position)); 1290 1291 if message_user_field.field_type = MESSAGE_TEXT_USER_FIELD then 1292 if addr (message_text_user_field.flags.reserved) -> message_text_field_reserved_flags.free_text then 1293 if (message_text_user_field.text_ptr ^= null ()) 1294 & (message_text_user_field.text_ptr ^= addr (NULL_STRING)) then do; 1295 free message_text_user_field_text in (mlsys_area); 1296 message_text_user_field.text_ptr = null (); 1297 end; 1298 else ; 1299 else ; 1300 1301 else if message_user_field.field_type = MESSAGE_ADDRESS_LIST_USER_FIELD then 1302 if message_address_list_user_field.address_list_ptr ^= null () then 1303 call mlsys_address_list_mgr_$decrement_reference_count (message_address_list_user_field 1304 .address_list_ptr); 1305 1306 do idx = (p_position + 1) to message.n_user_fields; 1307 message_user_fields_list.user_fields (idx - 1) = message_user_fields_list.user_fields (idx); 1308 end; 1309 1310 message_user_fields_list.n_user_fields, message.n_user_fields = message.n_user_fields - 1; 1311 1312 return; 1313 1314 end delete_user_field_internal; 1315 1316 /* Replace the message envelope (if any) with the new, supplied envelope */ 1317 1318 replace_message_envelope: /* ... for any type of message */ 1319 entry (P_message_ptr, P_message_envelope_parameter_ptr, P_code); 1320 1321 if ^verify_message_internal (P_message_ptr, P_code) then return; 1322 1323 message_ptr = copy_ptr (P_message_ptr); 1324 message_envelope_parameter_ptr = P_message_envelope_parameter_ptr; 1325 1326 if message_envelope_parameter.version ^= MESSAGE_ENVELOPE_PARAMETER_VERSION_2 then do; 1327 P_code = error_table_$unimplemented_version; 1328 return; 1329 end; 1330 1331 message_envelope_ptr = addr (message_envelope_parameter.envelope); 1332 if ^verify_envelope (message_envelope_ptr, P_code) then return; 1333 1334 call delete_envelope (addr (message.envelope)); /* get rid of whatever might be there now */ 1335 call set_envelope (message_envelope_ptr, addr (message.envelope)); 1336 1337 P_code = 0; /* success */ 1338 1339 return; 1340 1341 1342 1343 /* Copy the data from the caller's message envelope into the specified envelope */ 1344 1345 set_envelope: 1346 procedure (p_source_envelope_ptr, p_target_envelope_ptr); 1347 1348 dcl 1 source_envelope aligned based (p_source_envelope_ptr) like message_envelope; 1349 dcl p_source_envelope_ptr pointer parameter; 1350 1351 dcl 1 target_envelope aligned based (p_target_envelope_ptr) like message_envelope; 1352 dcl p_target_envelope_ptr pointer parameter; 1353 1354 target_envelope = source_envelope; /* copy the data exactly as it stands */ 1355 1356 if target_envelope.sender ^= null () then do; 1357 target_envelope.sender = copy_ptr (target_envelope.sender); 1358 call mlsys_address_mgr_$increment_reference_count (target_envelope.sender); 1359 end; 1360 1361 if source_envelope.trace ^= null () then call set_trace (source_envelope.trace, target_envelope.trace); 1362 1363 if target_envelope.delivered_by ^= null () then do; 1364 target_envelope.delivered_by = copy_ptr (target_envelope.delivered_by); 1365 call mlsys_address_mgr_$increment_reference_count (target_envelope.delivered_by); 1366 end; 1367 1368 if target_envelope.acknowledge_to ^= null () then do; 1369 target_envelope.acknowledge_to = copy_ptr (target_envelope.acknowledge_to); 1370 call mlsys_address_mgr_$increment_reference_count (target_envelope.acknowledge_to); 1371 end; 1372 1373 return; 1374 1375 1376 1377 /* Internal to set_envelope: copy the caller's message_trace */ 1378 1379 set_trace: 1380 procedure (p_source_trace_ptr, p_target_trace_ptr); 1381 1382 dcl (p_source_trace_ptr, p_target_trace_ptr) pointer parameter; 1383 dcl idx fixed binary; 1384 1385 message_trace_n_relays = p_source_trace_ptr -> message_trace.n_relays; 1386 1387 allocate message_trace in (mlsys_area) set (p_target_trace_ptr); 1388 1389 p_target_trace_ptr -> message_trace.version = MESSAGE_TRACE_VERSION_2; 1390 p_target_trace_ptr -> message_trace.reserved, p_target_trace_ptr -> message_trace.pad = ""b; 1391 1392 address_route_ptr = copy_ptr (p_source_trace_ptr -> message_trace.implicit_route); 1393 if address_route_ptr ^= null () then /* there's an implicit route */ 1394 if mlsys_data_$valid_segments (binary (baseno (address_route_ptr), 18, 0)) then 1395 p_target_trace_ptr -> message_trace.implicit_route = address_route_ptr; 1396 else call mlsys_address_route_mgr_$create_address_route (address_route.relays, 1397 p_target_trace_ptr -> message_trace.implicit_route); 1398 else p_target_trace_ptr -> message_trace.implicit_route = null (); 1399 if p_target_trace_ptr -> message_trace.implicit_route ^= null () then 1400 call mlsys_address_route_mgr_$increment_reference_count (p_target_trace_ptr 1401 -> message_trace.implicit_route); 1402 1403 do idx = 1 to p_target_trace_ptr -> message_trace.n_relays; 1404 p_target_trace_ptr -> message_trace.relays (idx) = p_source_trace_ptr -> message_trace.relays (idx); 1405 if (idx = p_target_trace_ptr -> message_trace.n_relays) 1406 & 1407 mlsys_nit_interface_$is_local_system (p_target_trace_ptr 1408 -> message_trace.relays (idx).receiving_host) then do; 1409 p_target_trace_ptr -> message_trace.relays (idx).sending_host = 1410 mlsys_nit_interface_$get_fully_qualified_name (p_target_trace_ptr 1411 -> message_trace.relays (idx).sending_host); 1412 p_target_trace_ptr -> message_trace.relays (idx).receiving_host = 1413 mlsys_nit_interface_$get_fully_qualified_name (p_target_trace_ptr 1414 -> message_trace.relays (idx).receiving_host); 1415 end; 1416 else do; 1417 p_target_trace_ptr -> message_trace.relays (idx).sending_host = 1418 translate (p_target_trace_ptr -> message_trace.relays (idx).sending_host, UPPERCASE, 1419 LOWERCASE); 1420 p_target_trace_ptr -> message_trace.relays (idx).receiving_host = 1421 translate (p_target_trace_ptr -> message_trace.relays (idx).receiving_host, UPPERCASE, 1422 LOWERCASE); 1423 end; 1424 if p_target_trace_ptr -> message_trace.relays (idx).relay_recipient ^= null () then do; 1425 p_target_trace_ptr -> message_trace.relays (idx).relay_recipient = 1426 copy_ptr (p_target_trace_ptr -> message_trace.relays (idx).relay_recipient); 1427 call mlsys_address_mgr_$increment_reference_count (p_target_trace_ptr 1428 -> message_trace.relays (idx).relay_recipient); 1429 end; 1430 end; 1431 1432 return; 1433 1434 end set_trace; 1435 1436 end set_envelope; 1437 1438 1439 1440 /* Delete the given message envelope by freeing all data it references */ 1441 1442 delete_envelope: 1443 procedure (p_envelope_ptr); 1444 1445 dcl 1 p_envelope aligned based (p_envelope_ptr) like message_envelope; 1446 dcl p_envelope_ptr pointer parameter; /* might belong to a redistribution */ 1447 1448 if p_envelope.acknowledge_to ^= null () then 1449 call mlsys_address_mgr_$decrement_reference_count (p_envelope.acknowledge_to); 1450 1451 if p_envelope.delivered_by ^= null () then 1452 call mlsys_address_mgr_$decrement_reference_count (p_envelope.delivered_by); 1453 1454 if p_envelope.trace ^= null () then call delete_trace (p_envelope.trace); 1455 1456 if p_envelope.sender ^= null () then call mlsys_address_mgr_$decrement_reference_count (p_envelope.sender); 1457 1458 return; 1459 1460 1461 1462 /* Internal to delete_envelope: delete a message trace and all referenced substructure */ 1463 1464 delete_trace: 1465 procedure (p_trace_ptr); 1466 1467 dcl p_trace_ptr pointer parameter; 1468 dcl idx fixed binary; 1469 1470 message_trace_ptr = p_trace_ptr; /* can't use like because of refer extent */ 1471 1472 do idx = 1 to message_trace.n_relays; 1473 if message_trace.relays (idx).relay_recipient ^= null () then 1474 call mlsys_address_mgr_$decrement_reference_count (message_trace.relays (idx).relay_recipient); 1475 end; 1476 1477 if message_trace.implicit_route ^= null () then 1478 call mlsys_address_route_mgr_$decrement_reference_count (message_trace.implicit_route); 1479 1480 free message_trace in (mlsys_area); 1481 p_trace_ptr = null (); /* it's gone now */ 1482 1483 return; 1484 1485 end delete_trace; 1486 1487 end delete_envelope; 1488 1489 /* Replace the From field of the message with the supplied address list */ 1490 1491 replace_from_no_copy: /* ... for any type of message */ 1492 entry (P_message_ptr, P_address_list_ptr, P_code); 1493 1494 if ^verify_message_internal (P_message_ptr, P_code) then return; 1495 message_ptr = copy_ptr (P_message_ptr); 1496 call replace_address_list_field (message.from, P_address_list_ptr, "0"b, P_code); 1497 return; 1498 1499 1500 replace_from_new: /* ... for a new message: target of user-ring gate */ 1501 entry (P_message_ptr, P_address_list_ptr, P_code); 1502 1503 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1504 message_ptr = copy_ptr (P_message_ptr); 1505 call replace_address_list_field (message.from, P_address_list_ptr, "1"b, P_code); 1506 return; 1507 1508 1509 1510 /* Replace the Reply-To field of the message with the supplied address list */ 1511 1512 replace_reply_to_no_copy: /* ... for any type of message */ 1513 entry (P_message_ptr, P_address_list_ptr, P_code); 1514 1515 if ^verify_message_internal (P_message_ptr, P_code) then return; 1516 message_ptr = copy_ptr (P_message_ptr); 1517 call replace_address_list_field (message.reply_to, P_address_list_ptr, "0"b, P_code); 1518 return; 1519 1520 1521 replace_reply_to_new: /* ... for a new message: target of user-ring gate */ 1522 entry (P_message_ptr, P_address_list_ptr, P_code); 1523 1524 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1525 message_ptr = copy_ptr (P_message_ptr); 1526 call replace_address_list_field (message.reply_to, P_address_list_ptr, "1"b, P_code); 1527 return; 1528 1529 /* Replace the To field of the message with the supplied address list */ 1530 1531 replace_to_no_copy: /* ... for any type of message */ 1532 entry (P_message_ptr, P_address_list_ptr, P_code); 1533 1534 if ^verify_message_internal (P_message_ptr, P_code) then return; 1535 message_ptr = copy_ptr (P_message_ptr); 1536 call replace_address_list_field (message.to, P_address_list_ptr, "0"b, P_code); 1537 return; 1538 1539 1540 replace_to_new: /* ... for a new message: target of user-ring gate */ 1541 entry (P_message_ptr, P_address_list_ptr, P_code); 1542 1543 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1544 message_ptr = copy_ptr (P_message_ptr); 1545 call replace_address_list_field (message.to, P_address_list_ptr, "1"b, P_code); 1546 return; 1547 1548 1549 1550 /* Replace the cc field of the message with the supplied address list */ 1551 1552 replace_cc_no_copy: /* ... for any type of message */ 1553 entry (P_message_ptr, P_address_list_ptr, P_code); 1554 1555 if ^verify_message_internal (P_message_ptr, P_code) then return; 1556 message_ptr = copy_ptr (P_message_ptr); 1557 call replace_address_list_field (message.cc, P_address_list_ptr, "0"b, P_code); 1558 return; 1559 1560 1561 replace_cc_new: /* ... for a new message: target of user-ring gate */ 1562 entry (P_message_ptr, P_address_list_ptr, P_code); 1563 1564 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1565 message_ptr = copy_ptr (P_message_ptr); 1566 call replace_address_list_field (message.cc, P_address_list_ptr, "1"b, P_code); 1567 return; 1568 1569 /* Replace the bcc field of the message with the supplied address list */ 1570 1571 replace_bcc_no_copy: /* ... for any type of message */ 1572 entry (P_message_ptr, P_address_list_ptr, P_code); 1573 1574 if ^verify_message_internal (P_message_ptr, P_code) then return; 1575 message_ptr = copy_ptr (P_message_ptr); 1576 call replace_address_list_field (message.bcc, P_address_list_ptr, "0"b, P_code); 1577 return; 1578 1579 1580 replace_bcc_new: /* ... for a new message: target of user-ring gate */ 1581 entry (P_message_ptr, P_address_list_ptr, P_code); 1582 1583 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1584 message_ptr = copy_ptr (P_message_ptr); 1585 call replace_address_list_field (message.bcc, P_address_list_ptr, "1"b, P_code); 1586 return; 1587 1588 1589 1590 /* Actually replaces the given address list field (From, Reply-To, To, cc, bcc) in the message */ 1591 1592 replace_address_list_field: 1593 procedure (p_field, p_address_list_ptr, p_copy_address_list, p_code); 1594 1595 dcl (p_field, p_address_list_ptr) pointer parameter; 1596 dcl p_copy_address_list bit (1) aligned parameter; /* ON => make a copy of the caller's address list */ 1597 dcl p_code fixed binary (35) parameter; 1598 1599 if p_address_list_ptr = null () then do; /* caller wants the new value of the field to be empty */ 1600 call mlsys_address_list_mgr_$create_read_only_address_list (ADDRESS_LIST_VERSION_2, address_list_ptr, 1601 p_code); 1602 if p_code ^= 0 then return; 1603 end; 1604 else do; 1605 if ^mlsys_address_list_mgr_$verify_address_list (p_address_list_ptr, p_code) then return; 1606 if p_copy_address_list then do; 1607 call mlsys_address_list_mgr_$copy_address_list (p_address_list_ptr, address_list_ptr, p_code); 1608 if p_code ^= 0 then return; 1609 end; 1610 else address_list_ptr = copy_ptr (p_address_list_ptr); 1611 end; 1612 1613 if p_field ^= null () then /* get rid of the old one ... */ 1614 call mlsys_address_list_mgr_$decrement_reference_count (p_field); 1615 1616 p_field = address_list_ptr; 1617 call mlsys_address_list_mgr_$set_read_only (p_field); 1618 call mlsys_address_list_mgr_$increment_reference_count (p_field); 1619 1620 p_code = 0; /* success */ 1621 1622 return; 1623 1624 end replace_address_list_field; 1625 1626 /* Replace the subject of the message with the supplied text */ 1627 1628 replace_subject: /* ... for any type of message */ 1629 entry (P_message_ptr, P_subject, P_code); 1630 1631 if ^verify_message_internal (P_message_ptr, P_code) then return; 1632 copy_subject = "1"b; 1633 go to REPLACE_SUBJECT_COMMON; 1634 1635 1636 replace_subject_no_copy: /* ... for any type of message: subject text in our ring */ 1637 entry (P_message_ptr, P_subject, P_code); 1638 1639 if ^verify_message_internal (P_message_ptr, P_code) then return; 1640 copy_subject = "0"b; 1641 go to REPLACE_SUBJECT_COMMON; 1642 1643 1644 replace_subject_new: /* ... for a new message: target of user-ring gate */ 1645 entry (P_message_ptr, P_subject, P_code); 1646 1647 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1648 copy_subject = "1"b; 1649 go to REPLACE_SUBJECT_COMMON; 1650 1651 1652 REPLACE_SUBJECT_COMMON: 1653 message_ptr = copy_ptr (P_message_ptr); 1654 1655 if addr (message.subject.flags.reserved) -> message_text_field_reserved_flags.free_text then 1656 if (message.subject.text_ptr ^= null ()) & (message.subject.text_ptr ^= addr (NULL_STRING)) then do; 1657 free message_subject in (mlsys_area); 1658 message.subject.text_ptr = null (); 1659 end; 1660 1661 string (message.subject.flags) = ""b; /* turns off both multiline_text & free_text */ 1662 1663 if length (P_subject) = 0 then do; /* new subject is empty */ 1664 message.subject.text_ptr = addr (NULL_STRING); 1665 message.subject.text_lth = 0; 1666 end; 1667 1668 else if copy_subject then do; /* copy the caller's subject */ 1669 COPY_SUBJECT_TEXT: 1670 call normalize_single_line_field (P_subject, message.subject.text_ptr, message.subject.text_lth); 1671 addr (message.subject.flags.reserved) -> message_text_field_reserved_flags.free_text = "1"b; 1672 end; 1673 1674 else do; /* copy it only if it's improperly formatted */ 1675 message.subject.text_ptr = addr (P_subject); 1676 message.subject.text_ptr = copy_ptr (message.subject.text_ptr); 1677 message.subject.text_lth = length (P_subject); 1678 if ^mlsys_data_$valid_segments (binary (baseno (addr (message_subject)), 18, 0)) then 1679 go to COPY_SUBJECT_TEXT; 1680 if search (message_subject, NON_SPACE_WHITESPACE) ^= 0 then go to COPY_SUBJECT_TEXT; 1681 if verify (message_subject, SPACE) ^= 1 then go to COPY_SUBJECT_TEXT; 1682 if substr (message_subject, length (message_subject), 1) = SPACE then go to COPY_SUBJECT_TEXT; 1683 if index (message_subject, SPACE_SPACE) ^= 0 then go to COPY_SUBJECT_TEXT; 1684 end; 1685 1686 P_code = 0; /* success */ 1687 1688 return; 1689 1690 /* Set the AIM access class of the message: If the access class is less than or isolated from the user's process 1691* authorization, this entrypoint will check for ring-1 privilege */ 1692 1693 set_access_class_new: /* ... for a new message: target of user-ring gate */ 1694 entry (P_message_ptr, P_access_class, P_code); 1695 1696 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1697 1698 message_ptr = copy_ptr (P_message_ptr); 1699 access_class = P_access_class; 1700 1701 P_code = 0; /* assume success */ 1702 1703 if aim_check_$greater_or_equal (access_class, get_authorization_ ()) then 1704 message.access_class = access_class; /* access class is OK without privilege */ 1705 1706 else do; /* user will need ring-1 privilege to send this message */ 1707 string (user_privileges) = get_privileges_ (); 1708 if user_privileges.ring1 then 1709 message.access_class = access_class; 1710 else P_code = error_table_$ai_restricted; 1711 end; 1712 1713 return; 1714 1715 /* Replace the entire message body with the single, new, supplied section */ 1716 1717 replace_body: /* ... for any type of message */ 1718 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_code); 1719 1720 if ^verify_message_internal (P_message_ptr, P_code) then return; 1721 copy_section_content = "1"b; 1722 go to REPLACE_BODY_COMMON; 1723 1724 1725 replace_body_no_copy: /* ... for any type of message: section content in our ring */ 1726 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_code); 1727 1728 if ^verify_message_internal (P_message_ptr, P_code) then return; 1729 copy_section_content = "0"b; 1730 go to REPLACE_BODY_COMMON; 1731 1732 1733 replace_body_new: /* ... for a new message: target of user-ring gate */ 1734 entry (P_message_ptr, P_message_body_section_parameter_ptr, P_code); 1735 1736 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1737 copy_section_content = "1"b; 1738 1739 1740 REPLACE_BODY_COMMON: 1741 message_ptr = copy_ptr (P_message_ptr); 1742 message_body_section_parameter_ptr = P_message_body_section_parameter_ptr; 1743 1744 if message_body_section_parameter.version ^= MESSAGE_BODY_SECTION_PARAMETER_VERSION_2 then do; 1745 P_code = error_table_$unimplemented_version; 1746 return; 1747 end; 1748 1749 if ^verify_body_section (addr (message_body_section_parameter.section), P_code) then return; 1750 1751 /*** Delete the entire old body */ 1752 do idx = message.n_body_sections to 1 by -1; 1753 call delete_body_section_internal (idx); 1754 end; 1755 1756 position = 1; /* since there's nothing else left now */ 1757 message_body_section_ptr = addr (message_body_section_parameter.section); 1758 call add_body_section_internal (); 1759 1760 if message_reserved_data.type = NEW_MESSAGE then /* record date/time of latest change to message body */ 1761 message_reserved_data.info_ptr -> new_message_info.date_time_created = clock (); 1762 1763 P_message_ptr = message_ptr; /* in case we had to expand message.body_sections */ 1764 P_code = 0; /* success */ 1765 1766 return; 1767 1768 /* Replace a section of the message body with the new, supplied section */ 1769 1770 replace_body_section: /* ... for any type of message */ 1771 entry (P_message_ptr, P_position, P_message_body_section_parameter_ptr, P_code); 1772 1773 if ^verify_message_internal (P_message_ptr, P_code) then return; 1774 copy_section_content = "1"b; 1775 go to REPLACE_BODY_SECTION_COMMON; 1776 1777 1778 replace_body_section_no_copy: /* ... for any type of message: section content in our ring */ 1779 entry (P_message_ptr, P_position, P_message_body_section_parameter_ptr, P_code); 1780 1781 if ^verify_message_internal (P_message_ptr, P_code) then return; 1782 copy_section_content = "0"b; 1783 go to REPLACE_BODY_SECTION_COMMON; 1784 1785 1786 replace_body_section_new: /* ... for a new message: target of user-ring gate */ 1787 entry (P_message_ptr, P_position, P_message_body_section_parameter_ptr, P_code); 1788 1789 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1790 copy_section_content = "1"b; 1791 1792 1793 REPLACE_BODY_SECTION_COMMON: 1794 message_ptr = copy_ptr (P_message_ptr); 1795 position = P_position; 1796 message_body_section_parameter_ptr = P_message_body_section_parameter_ptr; 1797 1798 if message_body_section_parameter.version ^= MESSAGE_BODY_SECTION_PARAMETER_VERSION_2 then do; 1799 P_code = error_table_$unimplemented_version; 1800 return; 1801 end; 1802 1803 if ^verify_body_section (addr (message_body_section_parameter.section), P_code) then return; 1804 1805 if (position < 1) | (position > message.n_body_sections) then do; 1806 P_code = error_table_$bad_index; 1807 return; 1808 end; 1809 1810 call delete_body_section_internal (position); /* get rid of the old one ... */ 1811 message_body_section_ptr = addr (message_body_section_parameter.section); 1812 call add_body_section_internal (); /* ... and put in the new one */ 1813 1814 if message_reserved_data.type = NEW_MESSAGE then /* record date/time of latest change to message body */ 1815 message_reserved_data.info_ptr -> new_message_info.date_time_created = clock (); 1816 1817 P_message_ptr = message_ptr; /* in case we had to expand message.body_sections */ 1818 P_code = 0; /* success */ 1819 1820 return; 1821 1822 /* Replace a redistribution in the message's redistributions list with the new, supplied redistribution */ 1823 1824 replace_redistribution: /* ... for any type of message */ 1825 entry (P_message_ptr, P_position, P_message_redistribution_parameter_ptr, P_code); 1826 1827 if ^verify_message_internal (P_message_ptr, P_code) then return; 1828 copy_redistribution_data = "1"b; 1829 go to REPLACE_REDISTRIBUTION_COMMON; 1830 1831 1832 replace_redistribution_no_copy: /* ... for any type of message; data already in our ring */ 1833 entry (P_message_ptr, P_position, P_message_redistribution_parameter_ptr, P_code); 1834 1835 if ^verify_message_internal (P_message_ptr, P_code) then return; 1836 copy_redistribution_data = "0"b; 1837 1838 1839 REPLACE_REDISTRIBUTION_COMMON: 1840 message_ptr = copy_ptr (P_message_ptr); 1841 position = P_position; 1842 message_redistribution_parameter_ptr = P_message_redistribution_parameter_ptr; 1843 1844 if message_redistribution_parameter.version ^= MESSAGE_REDISTRIBUTION_PARAMETER_VERSION_2 then do; 1845 P_code = error_table_$unimplemented_version; 1846 return; 1847 end; 1848 1849 if ^verify_redistribution (addr (message_redistribution_parameter.redistribution), P_code) then return; 1850 1851 if (position < 1) | (position > message.n_redistributions) then do; 1852 P_code = error_table_$bad_index; 1853 return; 1854 end; 1855 1856 call delete_redistribution_internal (position); /* get rid of the old one ... */ 1857 message_redistribution_ptr = addr (message_redistribution_parameter.redistribution); 1858 call add_redistribution_internal (); /* ... and add the new one */ 1859 1860 P_code = 0; /* success */ 1861 1862 return; 1863 1864 /* Replace a message reference in the message's list of reply references with the new, supplied message reference */ 1865 1866 replace_reply_reference: /* ... for any type message */ 1867 entry (P_message_ptr, P_position, P_message_reference_parameter_ptr, P_code); 1868 1869 if ^verify_message_internal (P_message_ptr, P_code) then return; 1870 copy_reference_data = "1"b; 1871 go to REPLACE_REPLY_REFERENCE_COMMON; 1872 1873 1874 replace_reply_reference_no_copy: /* ... for any type message: data already in our ring */ 1875 entry (P_message_ptr, P_position, P_message_reference_parameter_ptr, P_code); 1876 1877 if ^verify_message_internal (P_message_ptr, P_code) then return; 1878 copy_reference_data = "0"b; 1879 go to REPLACE_REPLY_REFERENCE_COMMON; 1880 1881 1882 replace_reply_reference_new: /* ... for a new message: target of user-ring gate */ 1883 entry (P_message_ptr, P_position, P_referenced_message_ptr, P_code); 1884 1885 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1886 if ^verify_im_message_internal (P_referenced_message_ptr, P_code) then return; 1887 copy_reference_data = "0"b; /* it's already in the right place from in-mailbox message */ 1888 1889 message_ptr = copy_ptr (P_referenced_message_ptr);/* need to access the original message temporarily */ 1890 message_reference_parameter_ptr = addr (local_mrfp); 1891 message_reference_parameter.reference.message_id = message.message_id; 1892 message_reference_parameter.reference.date_time_created = message.date_time_created; 1893 message_reference_parameter.reference.from = message.from; 1894 message_reference_parameter.reference.subject = message.subject; 1895 go to REPLACE_REPLY_REFERENCE_NO_RP_CHECK; 1896 1897 1898 REPLACE_REPLY_REFERENCE_COMMON: 1899 message_reference_parameter_ptr = P_message_reference_parameter_ptr; 1900 if message_reference_parameter.version ^= MESSAGE_REFERENCE_PARAMETER_VERSION_2 then do; 1901 P_code = error_table_$unimplemented_version; 1902 return; 1903 end; 1904 if ^verify_reference (addr (message_reference_parameter.reference), P_code) then return; 1905 1906 REPLACE_REPLY_REFERENCE_NO_RP_CHECK: 1907 message_ptr = copy_ptr (P_message_ptr); 1908 position = P_position; 1909 1910 if (position < 1) | (position > message.n_reply_references) then do; 1911 P_code = error_table_$bad_index; 1912 return; 1913 end; 1914 1915 /*** Check for duplicate reply references (except, of course, for the one about to be deleted) */ 1916 do idx = 1 to (position - 1), (position + 1) to message.n_reply_references; 1917 if message.reply_references -> message_references_list.references (idx).message_id 1918 = message_reference_parameter.reference.message_id then do; 1919 P_position = idx; /* let caller know where the duplicate resides */ 1920 P_code = mlsys_et_$duplicate_reply_reference; 1921 return; 1922 end; 1923 end; 1924 1925 call delete_reference_internal (message.n_reply_references, message.reply_references, position); 1926 message_reference_ptr = addr (message_reference_parameter.reference); 1927 call add_reference_internal (message.n_reply_references, message.reply_references); 1928 1929 P_code = 0; /* success */ 1930 1931 return; 1932 1933 /* Replace a user-defined field in the message with the new, supplied user-defined field */ 1934 1935 replace_user_field: /* ... for any type of message */ 1936 entry (P_message_ptr, P_position, P_message_user_field_parameter_ptr, P_allow_duplicates, P_code); 1937 1938 if ^verify_message_internal (P_message_ptr, P_code) then return; 1939 copy_user_field_content = "1"b; 1940 go to REPLACE_USER_FIELD_COMMON; 1941 1942 1943 replace_user_field_no_copy: /* ... for any type of message: data already in our ring */ 1944 entry (P_message_ptr, P_position, P_message_user_field_parameter_ptr, P_allow_duplicates, P_code); 1945 1946 if ^verify_message_internal (P_message_ptr, P_code) then return; 1947 copy_user_field_content = "0"b; 1948 go to REPLACE_USER_FIELD_COMMON; 1949 1950 1951 replace_user_field_new: /* ... for a new message: target of user-ring gate */ 1952 entry (P_message_ptr, P_position, P_message_user_field_parameter_ptr, P_allow_duplicates, P_code); 1953 1954 if ^verify_new_message_internal (P_message_ptr, P_code) then return; 1955 copy_user_field_content = "1"b; 1956 1957 1958 REPLACE_USER_FIELD_COMMON: 1959 message_ptr = copy_ptr (P_message_ptr); 1960 position = P_position; 1961 message_user_field_parameter_ptr = P_message_user_field_parameter_ptr; 1962 1963 if message_user_field_parameter.version ^= MESSAGE_USER_FIELD_PARAMETER_VERSION_2 then do; 1964 P_code = error_table_$unimplemented_version; 1965 return; 1966 end; 1967 1968 if ^verify_user_field (addr (message_user_field_parameter.user_field), P_code) then return; 1969 1970 if (position < 1) | (position > message.n_user_fields) then do; 1971 P_code = error_table_$bad_index; 1972 return; 1973 end; 1974 1975 /*** Check for duplicate fields if requested */ 1976 if ^P_allow_duplicates then do; 1977 do idx = 1 to (position - 1), (position + 1) to message.n_user_fields; 1978 if message_user_fields_list.user_fields (idx).field_id 1979 = message_user_field_parameter.user_field.field_id then do; 1980 P_position = idx; /* let caller know where the duplicate resides */ 1981 P_code = mlsys_et_$duplicate_user_field; 1982 return; 1983 end; 1984 end; 1985 end; 1986 1987 call delete_user_field_internal (position); /* delete the old one ... */ 1988 message_user_field_ptr = addr (message_user_field_parameter.user_field); 1989 call add_user_field_internal (); /* ... and add the new one */ 1990 1991 P_code = 0; /* success */ 1992 1993 return; 1994 1995 /* Verify that the caller supplied a message structure */ 1996 1997 verify_message: 1998 entry (P_message_ptr, P_date_time_created, P_code) returns (bit (1) aligned); 1999 2000 if verify_message_internal (P_message_ptr, P_code) then do; 2001 /* this call will set the status code */ 2002 if addr (P_message_ptr -> message.reserved) -> message_reserved_data.type = NEW_MESSAGE then 2003 P_date_time_created = 2004 addr (P_message_ptr -> message.reserved) -> message_reserved_data.info_ptr 2005 -> new_message_info.date_time_created; 2006 else P_date_time_created = P_message_ptr -> message.date_time_created; 2007 return ("1"b); 2008 end; 2009 2010 else return ("0"b); 2011 2012 2013 2014 /* Actually verifies a message */ 2015 2016 verify_message_internal: 2017 procedure (p_message_ptr, p_code) returns (bit (1) aligned); 2018 2019 dcl p_message_ptr pointer parameter; 2020 dcl p_code fixed binary (35) parameter; 2021 2022 if p_message_ptr = null () then p_code = mlsys_et_$not_message; 2023 2024 else if ^mlsys_data_$valid_segments (binary (baseno (p_message_ptr), 18, 0)) then 2025 p_code = mlsys_et_$not_message; /* supplied structure wasn't allocated by us */ 2026 2027 else if p_message_ptr -> message.version ^= MESSAGE_VERSION_2 then p_code = mlsys_et_$not_message; 2028 /* not an message structure */ 2029 2030 else p_code = 0; /* supplied structure passes all tests */ 2031 2032 return ((p_code = 0)); 2033 2034 end verify_message_internal; 2035 2036 /* Verify that the caller supplied a pointer to a properly constructed message structure which is an in-mailbox message */ 2037 2038 verify_im_message: 2039 entry (P_message_ptr, P_im_message_info_ptr, P_code) returns (bit (1) aligned); 2040 2041 if verify_im_message_internal (P_message_ptr, P_code) then do; 2042 /* above call will set the status code */ 2043 P_im_message_info_ptr = 2044 copy_ptr (addr (P_message_ptr -> message.reserved) -> message_reserved_data.info_ptr); 2045 return ("1"b); 2046 end; 2047 2048 else return ("0"b); 2049 2050 2051 2052 /* Actually verifies an in-mailbox message */ 2053 2054 verify_im_message_internal: 2055 procedure (p_message_ptr, p_code) returns (bit (1) aligned); 2056 2057 dcl p_message_ptr pointer parameter; 2058 dcl p_code fixed binary (35) parameter; 2059 2060 if ^verify_message_internal (p_message_ptr, p_code) then ; 2061 /* not a message */ 2062 2063 else if addr (p_message_ptr -> message.reserved) -> message_reserved_data.type ^= IN_MAILBOX_MESSAGE then 2064 p_code = mlsys_et_$not_in_mailbox_message; /* not an in-mailbox message */ 2065 2066 else p_code = 0; /* supplied structure passes all tests */ 2067 2068 return ((p_code = 0)); 2069 2070 end verify_im_message_internal; 2071 2072 /* Verify that the caller supplied a pointer to a properly constructed message structure which may be modified by 2073* user-ring software via the mail_system_ gate */ 2074 2075 verify_new_message: 2076 entry (P_message_ptr, P_date_time_created, P_code) returns (bit (1) aligned); 2077 2078 if verify_new_message_internal (P_message_ptr, P_code) then do; 2079 /* above call will set the status code */ 2080 P_date_time_created = 2081 addr (P_message_ptr -> message.reserved) -> message_reserved_data.info_ptr 2082 -> new_message_info.date_time_created; 2083 return ("1"b); 2084 end; 2085 2086 else return ("0"b); 2087 2088 2089 2090 /* Actually verifies a new message */ 2091 2092 verify_new_message_internal: 2093 procedure (p_message_ptr, p_code) returns (bit (1) aligned); 2094 2095 dcl p_message_ptr pointer parameter; 2096 dcl p_code fixed binary (35) parameter; 2097 2098 if ^verify_message_internal (p_message_ptr, p_code) then ; 2099 /* not a message */ 2100 2101 else if addr (p_message_ptr -> message.reserved) -> message_reserved_data.type ^= NEW_MESSAGE then 2102 p_code = mlsys_et_$not_new_message; /* not a message which user-ring can modify */ 2103 2104 else p_code = 0; /* supplied structure passes all tests */ 2105 2106 return ((p_code = 0)); 2107 2108 end verify_new_message_internal; 2109 2110 /* Verify the the supplied message trace contains valid data */ 2111 2112 verify_trace: 2113 procedure (p_trace_ptr, p_code) returns (bit (1) aligned); 2114 2115 dcl p_trace_ptr pointer parameter; 2116 dcl p_code fixed binary (35) parameter; 2117 dcl ignore bit (1) aligned; 2118 dcl idx fixed binary; 2119 2120 if p_trace_ptr -> message_trace.version ^= MESSAGE_TRACE_VERSION_2 then 2121 p_code = error_table_$unimplemented_version; 2122 2123 else do; 2124 p_code = 0; /* assume success for now */ 2125 2126 if p_trace_ptr -> message_trace.implicit_route ^= null () then 2127 if p_trace_ptr -> message_trace.implicit_route -> address_route.version ^= ADDRESS_ROUTE_VERSION_1 2128 then p_code = error_table_$unimplemented_version; 2129 2130 do idx = 1 to p_trace_ptr -> message_trace.n_relays while (p_code = 0); 2131 if p_trace_ptr -> message_trace.relays (idx).relay_recipient ^= null () then 2132 ignore = 2133 mlsys_address_mgr_$verify_address (p_trace_ptr 2134 -> message_trace.relays (idx).relay_recipient, p_code); 2135 end; 2136 end; 2137 2138 return ((p_code = 0)); 2139 2140 end verify_trace; 2141 2142 /* Verify that the supplied message envelope contains valid data */ 2143 2144 verify_envelope: 2145 procedure (p_envelope_ptr, p_code) returns (bit (1) aligned); 2146 2147 dcl 1 envelope aligned based (p_envelope_ptr) like message_envelope; 2148 dcl p_envelope_ptr pointer parameter; 2149 dcl p_code fixed binary (35) parameter; 2150 dcl ignore bit (1) aligned; 2151 2152 if envelope.sender ^= null () then ignore = mlsys_address_mgr_$verify_address (envelope.sender, p_code); 2153 2154 if (p_code = 0) & (envelope.trace ^= null ()) then ignore = verify_trace (envelope.trace, p_code); 2155 2156 if (p_code = 0) & (envelope.delivered_by ^= null ()) then 2157 ignore = mlsys_address_mgr_$verify_address (envelope.delivered_by, p_code); 2158 2159 if (p_code = 0) & (envelope.acknowledge_to ^= null ()) then 2160 ignore = mlsys_address_mgr_$verify_address (envelope.acknowledge_to, p_code); 2161 2162 return ((p_code = 0)); 2163 2164 end verify_envelope; 2165 2166 2167 2168 /* Verify that the supplied message redistribution contains valid data */ 2169 2170 verify_redistribution: 2171 procedure (p_redistribution_ptr, p_code) returns (bit (1) aligned); 2172 2173 dcl 1 redistribution aligned based (p_redistribution_ptr) like message_redistribution; 2174 dcl p_redistribution_ptr pointer parameter; 2175 dcl p_code fixed binary (35) parameter; 2176 dcl ignore bit (1) aligned; 2177 2178 ignore = verify_envelope (addr (redistribution.envelope), p_code); 2179 2180 if (p_code = 0) & (redistribution.from ^= null ()) then 2181 ignore = mlsys_address_list_mgr_$verify_address_list (redistribution.from, p_code); 2182 2183 if (p_code = 0) & (redistribution.to ^= null ()) then 2184 ignore = mlsys_address_list_mgr_$verify_address_list (redistribution.to, p_code); 2185 2186 return ((p_code = 0)); 2187 2188 end verify_redistribution; 2189 2190 /* Verify that the supplied user-defined field contains valid data */ 2191 2192 verify_user_field: 2193 procedure (p_user_field_ptr, p_code) returns (bit (1) aligned); 2194 2195 dcl 1 user_field aligned based (p_user_field_ptr) like message_user_field; 2196 dcl 1 address_list_user_field aligned based (p_user_field_ptr) like message_address_list_user_field; 2197 dcl p_user_field_ptr pointer parameter; 2198 dcl p_code fixed binary (35) parameter; 2199 dcl ignore bit (1) aligned; 2200 2201 call mlsys_field_id_mgr_$get_user_field_name (user_field.field_id, (""), p_code); 2202 if p_code = error_table_$smallarg then p_code = 0;/* the ID is OK: we didn't supply space for the name */ 2203 2204 if (p_code = 0) 2205 & ((user_field.field_type < MESSAGE_TEXT_USER_FIELD) 2206 | (user_field.field_type > MESSAGE_INTEGER_USER_FIELD)) then 2207 p_code = mlsys_et_$unknown_user_field_type; 2208 2209 if (p_code = 0) & (user_field.field_type = MESSAGE_ADDRESS_LIST_USER_FIELD) then 2210 if address_list_user_field.address_list_ptr ^= null () then 2211 ignore = 2212 mlsys_address_list_mgr_$verify_address_list (address_list_user_field.address_list_ptr, p_code); 2213 2214 return ((p_code = 0)); 2215 2216 end verify_user_field; 2217 2218 2219 2220 /* Verify that the supplied message reference contains valid data */ 2221 2222 verify_reference: 2223 procedure (p_reference_ptr, p_code) returns (bit (1) aligned); 2224 2225 dcl 1 reference aligned based (p_reference_ptr) like message_reference; 2226 dcl p_reference_ptr pointer parameter; 2227 dcl p_code fixed binary (35) parameter; 2228 dcl ignore bit (1) aligned; 2229 2230 if reference.from ^= null () then 2231 ignore = mlsys_address_list_mgr_$verify_address_list (reference.from, p_code); 2232 2233 else p_code = 0; /* looks OK */ 2234 2235 return ((p_code = 0)); 2236 2237 end verify_reference; 2238 2239 /* Verify that the supplied body section contains valid data */ 2240 2241 verify_body_section: 2242 procedure (p_body_section_ptr, p_code) returns (bit (1) aligned); 2243 2244 dcl p_body_section_ptr pointer parameter; 2245 dcl p_code fixed binary (35) parameter; 2246 2247 if (p_body_section_ptr -> message_body_section.section_type < MESSAGE_PREFORMATTED_BODY_SECTION) 2248 | (p_body_section_ptr -> message_body_section.section_type > MESSAGE_BIT_STRING_BODY_SECTION) then 2249 p_code = mlsys_et_$unknown_body_section_type; 2250 2251 else p_code = 0; /* it passes */ 2252 2253 return ((p_code = 0)); 2254 2255 end verify_body_section; 2256 2257 /* Computes the position where to add a body section, redistribution, etc.: If the input position is positive, the object 2258* is added at the given position (ie: if input position is 1, the object is added at the front of the list); if the input 2259* position is negative, it is added at the given position from the end (ie: if input position is -1, the object is made 2260* the last one in the list) */ 2261 2262 compute_position_for_add: 2263 procedure (p_input_position, p_n_in_list, p_actual_position); 2264 2265 dcl (p_input_position, p_n_in_list, p_actual_position) fixed binary parameter; 2266 2267 if p_input_position = 0 then /* a position of zero is equivalent to a value of 1 */ 2268 p_actual_position = 1; 2269 2270 else if p_input_position > 0 then /* add it at the given position from the beginning */ 2271 p_actual_position = min (p_input_position, (p_n_in_list + 1)); 2272 2273 else /*** if p_input_position < 0 then */ 2274 p_actual_position = max (1, (p_n_in_list + p_input_position + 2)); 2275 /* add it at the given position from the end */ 2276 2277 return; 2278 2279 end compute_position_for_add; 2280 2281 /* Count the lines in a piece of text */ 2282 2283 count_lines_in_text: 2284 procedure (p_text) returns (fixed binary (21)); 2285 2286 dcl p_text character (*) parameter; 2287 dcl (text_lth, n_lines, used, idx) fixed binary (21); 2288 2289 text_lth = length (p_text); 2290 2291 n_lines, used = 0; 2292 2293 do while (used < text_lth); 2294 2295 begin; 2296 2297 dcl rest_of_text character (text_lth - used) unaligned defined (p_text) position (used + 1); 2298 2299 idx = index (rest_of_text, NL); 2300 if idx = 0 then idx = length (rest_of_text) + 1; 2301 2302 n_lines = n_lines + 1; 2303 used = used + idx; 2304 end; 2305 end; 2306 2307 return (n_lines); 2308 2309 end count_lines_in_text; 2310 2311 /* Convert a text field which must be a single line into its canonical form: translate all whitespace in the text to 2312* spaces, strip leading and trailing whitespace, and compress all multi-character sequences of whitespace into a single 2313* space */ 2314 2315 normalize_single_line_field: 2316 procedure (p_text, p_text_ptr, p_text_lth) options (non_quick); 2317 2318 dcl p_text character (*) unaligned parameter; 2319 dcl p_text_ptr pointer parameter; 2320 dcl p_text_lth fixed binary (21) parameter; 2321 2322 dcl work_string character (work_string_lth) varying based (work_string_ptr); 2323 dcl work_string_ptr pointer; 2324 dcl work_string_lth fixed binary (21); 2325 2326 dcl result_string character (length (work_string)) unaligned based (result_string_ptr); 2327 dcl result_string_ptr pointer; 2328 2329 dcl idx fixed binary (21); 2330 2331 2332 work_string_lth = length (p_text); 2333 2334 work_string_ptr = null (); /* for cleanup handler */ 2335 on condition (cleanup) 2336 begin; 2337 if work_string_ptr ^= null () then 2338 if baseno (work_string_ptr) ^= baseno (stackframeptr ()) then 2339 call mlsys_storage_mgr_$release_temp_segment (work_string_ptr, (0)); 2340 end; 2341 2342 if work_string_lth > MAX_STACK_EXTENSION then do; /* too big for the stack */ 2343 call mlsys_storage_mgr_$get_temp_segment (work_string_ptr, code); 2344 if code ^= 0 then call abort_normalize_field (code); 2345 end; 2346 else call cu_$grow_stack_frame ((divide ((work_string_lth + 3), 4, 18, 0) + 1), work_string_ptr, (0)); 2347 2348 work_string = ltrim (rtrim (translate (p_text, "", NON_SPACE_WHITESPACE))); 2349 /* strips leading/trailing whitespace leaving just spaces */ 2350 2351 idx = index (work_string, SPACE_SPACE); /* need do until ... */ 2352 do while (idx ^= 0); 2353 work_string = substr (work_string, 1, idx) || substr (work_string, (idx + 2)); 2354 idx = index (work_string, SPACE_SPACE); 2355 end; 2356 2357 allocate result_string in (mlsys_area) set (result_string_ptr); 2358 result_string = work_string; 2359 2360 if baseno (work_string_ptr) ^= baseno (stackframeptr ()) then 2361 call mlsys_storage_mgr_$release_temp_segment (work_string_ptr, (0)); 2362 2363 p_text_ptr = addr (result_string); /* tell the caller where it is ... */ 2364 p_text_lth = length (work_string); /* ... and how long it is */ 2365 2366 return; 2367 2368 end normalize_single_line_field; 2369 2370 /* Convert a multiline text field (or body section) to its canonical form: The canonical form of a multiline field is 2371* simply the text of said field with all horizontal tabs expanded into the appropriate number of spaces */ 2372 2373 normalize_multiline_field: 2374 procedure (p_text, p_text_ptr, p_text_lth) options (non_quick); 2375 2376 dcl p_text character (*) parameter; 2377 dcl p_text_ptr pointer parameter; 2378 dcl p_text_lth fixed binary (21); 2379 2380 dcl work_string character (work_string_lth) unaligned based (work_string_ptr); 2381 dcl (work_string_lth, work_string_used) fixed binary (21); 2382 dcl work_string_ptr pointer; 2383 2384 dcl result_string character (work_string_used) unaligned based (result_string_ptr); 2385 dcl result_string_ptr pointer; 2386 2387 dcl the_character character (1) aligned; 2388 dcl (text_used, column, n_spaces, idx) fixed binary (21); 2389 dcl stack_increment fixed binary (18); 2390 2391 2392 stack_increment = 16 * divide ((divide ((length (p_text) + 3), 4, 18, 0) + 15), 16, 18, 0); 2393 2394 work_string_lth = 4 * stack_increment; /* initial work space ... */ 2395 work_string_used = 0; /* ... isn't used yet */ 2396 2397 work_string_ptr = null (); /* for cleanup handler */ 2398 on condition (cleanup) 2399 begin; 2400 if work_string_ptr ^= null () then 2401 if baseno (work_string_ptr) ^= baseno (stackframeptr ()) then 2402 call mlsys_storage_mgr_$release_temp_segment (work_string_ptr, (0)); 2403 end; 2404 2405 if work_string_lth > MAX_STACK_EXTENSION then do; 2406 call mlsys_storage_mgr_$get_temp_segment (work_string_ptr, code); 2407 if code ^= 0 then call abort_normalize_field (code); 2408 work_string_lth = 4 * sys_info$max_seg_size; 2409 end; 2410 else call cu_$grow_stack_frame (stack_increment, work_string_ptr, (0)); 2411 2412 column = 1; /* where we are right now */ 2413 text_used = 0; 2414 2415 do while (text_used < length (p_text)); 2416 2417 begin; 2418 dcl rest_of_text character (length (p_text) - text_used) unaligned defined (p_text) position (text_used + 1); 2419 2420 idx = verify (rest_of_text, SINGLE_WIDTH_CHARACTERS); 2421 if idx = 0 then idx = length (rest_of_text) + 1; 2422 2423 call add_to_work_string (addr (rest_of_text), (idx - 1)); 2424 column = column + idx - 1; /* update where we are */ 2425 text_used = text_used + idx - 1; 2426 end; 2427 2428 if text_used < length (p_text) then do; /* we did find a special character */ 2429 the_character = substr (p_text, (text_used + 1), 1); 2430 text_used = text_used + 1; 2431 2432 if the_character = HT then do; /* a tab: we must change it to spaces ... */ 2433 if mod (column, 10) = 0 then /* ... at the column just before a tab stop ... */ 2434 n_spaces = 1; /* ... the following computation fails */ 2435 else n_spaces = 11 - mod (column, 10); 2436 call add_to_work_string (addr (TEN_SPACES), n_spaces); 2437 column = column + n_spaces; 2438 end; 2439 2440 else do; /* some other special char */ 2441 call add_to_work_string (addr (the_character), 1); 2442 if the_character = BS then column = max ((column - 1), 1); 2443 else if (the_character = NL) | (the_character = CR) | (the_character = VT) | (the_character = FF) 2444 then column = 1; 2445 else ; /* ... all others are non-printing */ 2446 end; 2447 end; 2448 end; 2449 2450 allocate result_string in (mlsys_area) set (result_string_ptr); 2451 result_string = substr (work_string, 1, work_string_used); 2452 2453 if baseno (work_string_ptr) ^= baseno (stackframeptr ()) then 2454 call mlsys_storage_mgr_$release_temp_segment (work_string_ptr, (0)); 2455 2456 p_text_ptr = addr (result_string); /* tell caller where it is ... */ 2457 p_text_lth = length (result_string); /* ... and how long it is */ 2458 2459 return; 2460 2461 2462 2463 /* Internal to normalize_multiline_field: adds a piece of text to the work string, expanding it if necessary */ 2464 2465 add_to_work_string: 2466 procedure (p_piece_ptr, p_piece_lth); 2467 2468 dcl p_piece character (p_piece_lth) unaligned based (p_piece_ptr); 2469 dcl p_piece_ptr pointer parameter; 2470 dcl p_piece_lth fixed binary (21) parameter; 2471 2472 if (work_string_used + p_piece_lth) > work_string_lth then do; 2473 if baseno (work_string_ptr) ^= baseno (stackframeptr ()) then 2474 call abort_normalize_field (mlsys_et_$message_too_large); 2475 else if (work_string_used + p_piece_lth) > MAX_STACK_EXTENSION then do; 2476 call mlsys_storage_mgr_$get_temp_segment (work_string_ptr, code); 2477 if code ^= 0 then call abort_normalize_field (code); 2478 work_string_lth = 4 * sys_info$max_seg_size; 2479 end; 2480 else do; 2481 do while (work_string_lth < (work_string_used + p_piece_lth)); 2482 call cu_$grow_stack_frame (stack_increment, (null ()), (0)); 2483 work_string_lth = work_string_lth + (4 * stack_increment); 2484 end; 2485 end; 2486 end; 2487 2488 substr (work_string, (work_string_used + 1), p_piece_lth) = p_piece; 2489 work_string_used = work_string_used + p_piece_lth; 2490 2491 return; 2492 2493 end add_to_work_string; 2494 2495 end normalize_multiline_field; 2496 2497 2498 2499 /* Aborts a call to either normalize_single_line_field or normalize_multiline_field by aborting the entire operation */ 2500 2501 abort_normalize_field: 2502 procedure (p_code); 2503 2504 dcl p_code fixed binary (35) parameter; 2505 2506 P_code = p_code; /* set caller's status code */ 2507 go to ABORT_THE_OPERATION; 2508 2509 end abort_normalize_field; 2510 2511 ABORT_THE_OPERATION: 2512 return; 2513 1 1 /* BEGIN INCLUDE FILE ... mlsys_copy_ptr.incl.pl1 */ 1 2 /* Created: August 1983 by G. Palter */ 1 3 /* Recoded: October 1983 by W. Olin Sibert to be guarenteed to work */ 1 4 1 5 /* Copies a pointer parameter while changing the ring number in said pointer to the ring of execution: This change of 1 6* ring number is required to allow the mail system to properly manipulate ring-2 objects as requested by the caller as 1 7* the caller's pointer to said object would cause an access violation. The mail system does its own validation to insure 1 8* that the pointer provided by the caller is legitimate */ 1 9 1 10 copy_ptr: 1 11 procedure (p_pointer) returns (pointer); 1 12 1 13 dcl p_pointer pointer parameter; 1 14 dcl return_value pointer options (packed); 1 15 1 16 return_value = p_pointer; /* packed pointers don't have ring numbers ... */ 1 17 1 18 return (return_value); /* ... so it will be set to the ring of execution */ 1 19 1 20 end copy_ptr; 1 21 1 22 /* END INCLUDE FILE ... mlsys_copy_ptr.incl.pl1 */ 2514 2515 2 1 /* BEGIN INCLUDE FILE ... mlsys_message.incl.pl1 */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(85-12-19,Herbst), approve(86-03-25,MCR7367), 2 6* audit(86-04-28,Margolin), install(86-05-22,MR12.0-1059): 2 7* Added seen switch to message. 2 8* END HISTORY COMMENTS */ 2 9 2 10 2 11 /* Created: June 1983 by G. Palter */ 2 12 2 13 /* Definition of a message as used by the Multics Mail System */ 2 14 2 15 dcl 1 message aligned based (message_ptr), 2 16 2 version character (8) unaligned, 2 17 2 reserved bit (144), /* for exclusive use of the mail system */ 2 18 2 n_reply_references fixed binary, /* # of messages for which this is a reply */ 2 19 2 n_user_fields fixed binary, /* # of non-standard header fields in this message */ 2 20 2 n_redistributions fixed binary, /* # of times this message has been forwarded */ 2 21 2 n_body_sections fixed binary, /* # of sections in the body */ 2 22 2 flags, 2 23 3 interactive bit (1) unaligned, /* ON => this is an interactive message */ 2 24 3 can_be_deleted bit (1) unaligned, /* ON => the user can delete this message if desired */ 2 25 3 marked_for_deletion bit (1) unaligned, /* ON => message will be deleted when mailbox is closed */ 2 26 3 must_be_acknowledged bit (1) unaligned, /* ON => an ACK should be generated when message is read */ 2 27 3 seen bit (1) unaligned, /* ON => user has printed message at least once */ 2 28 3 reserved bit (31) unaligned, /* for use by the mail system */ 2 29 2 pad bit (36), 2 30 2 envelope like message_envelope, /* who/when/how the message was mailed & delivered */ 2 31 2 header, 2 32 3 message_id bit (72), /* ID of this message (same value for all copies) */ 2 33 3 access_class bit (72), /* AIM access class of this message */ 2 34 3 date_time_created fixed binary (71), /* date/time this message was composed */ 2 35 3 from pointer, /* -> address list of author(s) of the message */ 2 36 3 reply_to pointer, /* -> address list of recipients for reply (if not authors) */ 2 37 3 to pointer, /* -> address list of primary recipients */ 2 38 3 cc pointer, /* -> address list of secondary recipients */ 2 39 3 bcc pointer, /* -> address list of blind recipients */ 2 40 3 subject like message_text_field, /* subject of the message */ 2 41 3 reply_references pointer, /* -> list of messages for which this message is a reply */ 2 42 3 user_fields_list pointer, /* -> list of user-defined fields in this message */ 2 43 2 redistributions_list pointer, /* -> redistributions list for this message */ 2 44 2 body, 2 45 3 total_lines fixed binary (21), /* total # of lines in the body or -1 if indeterminate */ 2 46 3 pad bit (36), 2 47 3 body_sections (message_n_body_sections refer (message.n_body_sections)) like message_body_section; 2 48 2 49 dcl MESSAGE_VERSION_2 character (8) static options (constant) initial ("mlsmsg02"); 2 50 2 51 dcl message_subject character (message.header.subject.text_lth) unaligned based (message.header.subject.text_ptr); 2 52 2 53 dcl message_ptr pointer; 2 54 2 55 dcl (message_n_body_sections, message_trace_n_relays, message_n_redistributions, message_n_user_fields, 2 56 message_references_list_n_references) 2 57 fixed binary; /* for exclusive use of the mail system */ 2 58 2 59 /* Definition of a message envelope: describes when, by whom, and by what route the message was mailed */ 2 60 2 61 dcl 1 message_envelope aligned based (message_envelope_ptr), 2 62 2 date_time_mailed fixed binary (71), /* date/time this message was entered into the mail system */ 2 63 2 sender pointer, /* -> address of entity that mailed the message */ 2 64 2 trace pointer, /* -> message_trace describing how it got here */ 2 65 2 date_time_delivered fixed binary (71), /* date/time this message was delivered */ 2 66 2 delivered_by pointer, /* -> address of entity that delivered the message */ 2 67 2 acknowledge_to pointer; /* -> address of entity to receive ACK when message is read */ 2 68 2 69 dcl message_envelope_ptr pointer; 2 70 2 71 2 72 /* Structure used in calls to mail_system_daemon_ entrypoints which manipulate the message envelope */ 2 73 2 74 dcl 1 message_envelope_parameter aligned based (message_envelope_parameter_ptr), 2 75 2 pad pointer, /* forces even word alignment */ 2 76 2 version character (8) unaligned, 2 77 2 envelope like message_envelope; 2 78 2 79 dcl MESSAGE_ENVELOPE_PARAMETER_VERSION_2 character (8) static options (constant) initial ("mlsenv02"); 2 80 2 81 dcl message_envelope_parameter_ptr pointer; 2 82 2 83 2 84 /* Definition of a message trace: describes the route and each relay operation by which a message was passed through the 2 85* networks to reach this recipient */ 2 86 2 87 dcl 1 message_trace aligned based (message_trace_ptr), 2 88 2 version character (8) unaligned, 2 89 2 reserved bit (144), /* ... exclusively for use by the mail system */ 2 90 2 implicit_route pointer, /* -> an address_route which defines the route it took */ 2 91 2 pad bit (36), 2 92 2 n_relays fixed binary, /* # of relay operations required to reach this site */ 2 93 2 relays (message_trace_n_relays refer (message_trace.n_relays)), 2 94 3 date_time_relayed fixed binary (71), /* ... when this relay operation took place */ 2 95 3 sending_host character (256) varying, /* ... the host which relayed the message */ 2 96 3 receiving_host character (256) varying, /* ... the host which received it */ 2 97 3 communications_media character (32) unaligned, /* ... medium over which relay took place (ARPA, Tymnet) */ 2 98 3 communications_protocol character (32) unaligned,/* ... low-level protocol used (TCP, X.25) */ 2 99 3 mail_protocol character (32) unaligned, /* ... mailer protocol used (SMTP, NBS) */ 2 100 3 relay_id bit (72), /* ... unique ID assigned by receiving system or ""b */ 2 101 3 relay_recipient pointer; /* ... -> address of recipient as given by sending system */ 2 102 2 103 dcl MESSAGE_TRACE_VERSION_2 character (8) static options (constant) initial ("mlstrc02"); 2 104 2 105 dcl message_trace_ptr pointer; 2 106 2 107 /* Definition of a message's redistributions list */ 2 108 2 109 dcl 1 message_redistributions_list aligned based (message.redistributions_list), 2 110 2 version character (8) unaligned, 2 111 2 reserved bit (144), /* ... exclusively for use by the mail system */ 2 112 2 pad bit (36), 2 113 2 n_redistributions fixed binary, /* # of redistributions */ 2 114 2 redistributions (message_n_redistributions refer (message_redistributions_list.n_redistributions)) 2 115 like message_redistribution; /* the redistributions: oldest first */ 2 116 2 117 dcl MESSAGE_REDISTRIBUTIONS_LIST_VERSION_2 character (8) static options (constant) initial ("mlsrl002"); 2 118 2 119 2 120 /* Definition of a single redistribution (forwarding) of a message */ 2 121 2 122 dcl 1 message_redistribution aligned based (message_redistribution_ptr), 2 123 2 envelope like message_envelope, 2 124 2 header, 2 125 3 message_id bit (72), /* ID of this redistribution (same for all copies) */ 2 126 3 date_time_created fixed binary (71), /* date/time when this redistribution was made */ 2 127 3 from pointer, /* -> address list of authors of this redistribution */ 2 128 3 to pointer, /* -> address list of recipients of the redistribution */ 2 129 3 comment like message_text_field; /* optional comment associated with the redistribution */ 2 130 2 131 dcl message_redistribution_comment character (message_redistribution.comment.text_lth) unaligned 2 132 based (message_redistribution.comment.text_ptr); 2 133 2 134 dcl message_redistribution_ptr pointer; 2 135 2 136 2 137 /* Structure used in calls to mail_system_daemon_ entrypoints which manipulate the redistributions of a message */ 2 138 2 139 dcl 1 message_redistribution_parameter aligned based (message_redistribution_parameter_ptr), 2 140 2 pad pointer, /* forces even word alignment */ 2 141 2 version character (8) unaligned, 2 142 2 redistribution like message_redistribution; 2 143 2 144 dcl MESSAGE_REDISTRIBUTION_PARAMETER_VERSION_2 character (8) static options (constant) initial ("mlsdist2"); 2 145 2 146 dcl message_redistribution_parameter_ptr pointer; 2 147 2 148 /* Definition of the list of user-defined fields in a message */ 2 149 2 150 dcl 1 message_user_fields_list aligned based (message.user_fields_list), 2 151 2 version character (8) unaligned, 2 152 2 reserved bit (144), /* ... exclusively for use by the mail system */ 2 153 2 pad bit (36), 2 154 2 n_user_fields fixed binary, /* # of user-defined fields in the message */ 2 155 2 user_fields (message_n_user_fields refer (message_user_fields_list.n_user_fields)) 2 156 like message_user_field; /* the actual user-defined fields */ 2 157 2 158 dcl MESSAGE_USER_FIELDS_LIST_VERSION_2 character (8) static options (constant) initial ("mlsufl02"); 2 159 2 160 2 161 /* Definition of a user defined message header field */ 2 162 2 163 dcl 1 message_user_field aligned based (message_user_field_ptr), 2 164 2 header, 2 165 3 field_id bit (36) aligned, /* identifies the purpose of this field */ 2 166 3 field_type fixed binary, /* type of data contained in this field */ 2 167 2 field_type_variable bit (144); /* the actual data (see below) */ 2 168 2 169 dcl message_user_field_ptr pointer; 2 170 2 171 2 172 /* Defined types of user defined fields */ 2 173 2 174 dcl (MESSAGE_TEXT_USER_FIELD initial (1), /* content of the field is a text string */ 2 175 MESSAGE_ADDRESS_LIST_USER_FIELD initial (2), /* content of the field is an address list */ 2 176 MESSAGE_DATE_USER_FIELD initial (3), /* content of the field is a date/time */ 2 177 MESSAGE_INTEGER_USER_FIELD initial (4)) /* content of the filed is a fixed binary value */ 2 178 fixed binary static options (constant); 2 179 2 180 2 181 /* Structures used to access the data for the different types of user defined fields */ 2 182 2 183 dcl 1 message_text_user_field aligned based (message_user_field_ptr), 2 184 2 header like message_user_field.header, 2 185 2 text like message_text_field; /* the message text */ 2 186 2 187 dcl message_text_user_field_text character (message_text_user_field.text.text_lth) unaligned 2 188 based (message_text_user_field.text.text_ptr); 2 189 2 190 dcl 1 message_address_list_user_field aligned based (message_user_field_ptr), 2 191 2 header like message_user_field.header, 2 192 2 address_list_ptr pointer, /* -> the address list */ 2 193 2 pad bit (72); 2 194 2 195 dcl 1 message_date_user_field aligned based (message_user_field_ptr), 2 196 2 header like message_user_field.header, 2 197 2 date_time fixed binary (71), /* the clock reading */ 2 198 2 pad bit (72); 2 199 2 200 dcl 1 message_integer_user_field aligned based (message_user_field_ptr), 2 201 2 header like message_user_field.header, 2 202 2 value fixed binary (35), /* the integer value */ 2 203 2 pad bit (108); 2 204 2 205 2 206 /* Structure used in calls to mail_system_ entrypoints which manipulate the user-defined fields of a message */ 2 207 2 208 dcl 1 message_user_field_parameter aligned based (message_user_field_parameter_ptr), 2 209 2 pad pointer, /* forces even word alignment */ 2 210 2 version character (8) unaligned, 2 211 2 user_field like message_user_field; 2 212 2 213 dcl MESSAGE_USER_FIELD_PARAMETER_VERSION_2 character (8) static options (constant) initial ("mlsudf02"); 2 214 2 215 dcl message_user_field_parameter_ptr pointer; 2 216 2 217 /* Definition of a list of message references used as the value of message header fields (eg: In-Reply-To) */ 2 218 2 219 dcl 1 message_references_list aligned based (message_references_list_ptr), 2 220 2 version character (8) unaligned, 2 221 2 reserved bit (144), /* ... exclusively for use by the mail system */ 2 222 2 pad bit (36), 2 223 2 n_references fixed binary, /* # of references in this list */ 2 224 2 references (message_references_list_n_references refer (message_references_list.n_references)) 2 225 like message_reference; /* the references themselves */ 2 226 2 227 dcl MESSAGE_REFERENCES_LIST_VERSION_2 character (8) static options (constant) initial ("mlsref02"); 2 228 2 229 dcl message_references_list_ptr pointer; 2 230 2 231 2 232 /* Definition of a reference to another message */ 2 233 2 234 dcl 1 message_reference aligned based (message_reference_ptr), 2 235 2 message_id bit (72), /* ID of the other message */ 2 236 2 date_time_created fixed binary (71), /* date/time the other message was created */ 2 237 2 from pointer, /* -> address list of authors of the other message */ 2 238 2 subject like message_text_field; /* subject of the other message */ 2 239 2 240 dcl message_reference_subject character (message_reference.subject.text_lth) unaligned 2 241 based (message_reference.subject.text_ptr); 2 242 2 243 dcl message_reference_ptr pointer; 2 244 2 245 2 246 /* Structure used in calls to mail_system_daemon_ entrypoints which manipulate message references */ 2 247 2 248 dcl 1 message_reference_parameter aligned based (message_reference_parameter_ptr), 2 249 2 pad pointer, /* forces even word alignment */ 2 250 2 version character (8) unaligned, 2 251 2 reference like message_reference; 2 252 2 253 dcl MESSAGE_REFERENCE_PARAMETER_VERSION_2 character (8) static options (constant) initial ("mlsref02"); 2 254 2 255 dcl message_reference_parameter_ptr pointer; 2 256 2 257 2 258 /* Definition of a text field in a message (Subject, Comment, or a user defined field) */ 2 259 2 260 dcl 1 message_text_field aligned based (message_text_field_ptr), 2 261 2 text_ptr pointer, /* -> the actual text */ 2 262 2 text_lth fixed binary (21), /* length of said text */ 2 263 2 flags, 2 264 3 multiline_text bit (1) unaligned, /* ON => the text of this field may span multiple lines; 2 265* OFF => the text will always be a single line */ 2 266 3 reserved bit (35) unaligned; /* for exclusive use of the mail system */ 2 267 2 268 dcl message_text_field_text character (message_text_field.text_lth) unaligned based (message_text_field.text_ptr); 2 269 2 270 dcl message_text_field_ptr pointer; 2 271 2 272 /* Definition of a section of the body of a message */ 2 273 2 274 dcl 1 message_body_section aligned based (message_body_section_ptr), 2 275 2 header, 2 276 3 section_type fixed binary, /* type of "text" stored in this section */ 2 277 3 section_n_lines fixed binary (21), /* # of lines in this section or -1 if indeterminate */ 2 278 2 section_type_variable bit (144); /* the actual data (see below) */ 2 279 2 280 dcl message_body_section_ptr pointer; 2 281 2 282 2 283 /* Defined types of message body sections */ 2 284 2 285 dcl (MESSAGE_PREFORMATTED_BODY_SECTION initial (1), /* text formatted by the authors/sender */ 2 286 MESSAGE_BIT_STRING_BODY_SECTION initial (2)) /* arbitrary bit string */ 2 287 fixed binary static options (constant); 2 288 2 289 2 290 /* Structures used to access the data for the different types of message body sections */ 2 291 2 292 dcl 1 message_preformatted_body_section aligned based (message_body_section_ptr), 2 293 2 header like message_body_section.header, 2 294 2 text_ptr pointer, /* -> the text */ 2 295 2 text_lth fixed binary (21), /* length of said text in characters */ 2 296 2 reserved bit (36); /* for exclusive use of the mail system */ 2 297 2 298 dcl message_preformatted_body_section_text character (message_preformatted_body_section.text_lth) unaligned 2 299 based (message_preformatted_body_section.text_ptr); 2 300 2 301 dcl 1 message_bit_string_body_section aligned based (message_body_section_ptr), 2 302 2 header like message_body_section.header, 2 303 2 bit_string_ptr pointer, /* -> the bit string */ 2 304 2 bit_string_lth fixed binary (24), /* length of said bit string in bits (obviously) */ 2 305 2 reserved bit (36); /* for exclusive use of the mail system */ 2 306 2 307 dcl message_bit_string_body_section_bit_string bit (message_bit_string_body_section.bit_string_lth) unaligned 2 308 based (message_bit_string_body_section.bit_string_ptr); 2 309 2 310 2 311 /* Structure used in calls to mail_system_ entrypoints which manipulate the sections of a message's body */ 2 312 2 313 dcl 1 message_body_section_parameter aligned based (message_body_section_parameter_ptr), 2 314 2 pad pointer, /* forces even word alignment */ 2 315 2 version character (8) unaligned, 2 316 2 section like message_body_section; 2 317 2 318 dcl MESSAGE_BODY_SECTION_PARAMETER_VERSION_2 character (8) static options (constant) initial ("mlsmbs02"); 2 319 2 320 dcl message_body_section_parameter_ptr pointer; 2 321 2 322 /* END INCLUDE FILE ... mlsys_message.incl.pl1 */ 2516 2517 3 1 /* BEGIN INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 3 2 /* Created: June 1983 by G. Palter */ 3 3 3 4 /* Definition of an address list -- a collection of addresses used as the value of certain message fields, etc. */ 3 5 3 6 dcl 1 address_list aligned based (address_list_ptr), 3 7 2 version character (8) unaligned, 3 8 2 reserved bit (144), /* ... exclusively for use by the mail system */ 3 9 2 n_addresses fixed binary, /* # of address in this list */ 3 10 2 addresses (address_list_n_addresses refer (address_list.n_addresses)) pointer; 3 11 3 12 dcl ADDRESS_LIST_VERSION_2 character (8) static options (constant) initial ("mlsals02"); 3 13 3 14 dcl address_list_ptr pointer; 3 15 3 16 dcl address_list_n_addresses fixed binary; /* reserved exclusively for use by the mail system */ 3 17 3 18 /* END INCLUDE FILE ... mlsys_address_list.incl.pl1 */ 2518 2519 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 */ 2520 2521 5 1 /* BEGIN INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(86-06-11,Mills), approve(86-06-11,MCR7419), 5 6* audit(86-06-17,Margolin), install(86-06-30,MR12.0-1080): 5 7* Added mlsys_data_$domains_available. 5 8* END HISTORY COMMENTS */ 5 9 5 10 5 11 /* Created: May 1981 by G. Palter */ 5 12 /* Modified: July 1983 by G. Palter to merge with mlsys_data_ */ 5 13 5 14 /* Constants used internally by the Multics mail system */ 5 15 5 16 dcl mlsys_data_$max_opening_retries fixed binary external; /* maximum number of times to reopen a mailbox if it gets 5 17* damaged and salvaged while open */ 5 18 5 19 dcl mlsys_data_$max_lock_wait_retries fixed binary external; 5 20 /* maximum number of times to try to send a message while the 5 21* mailbox is locked (being salvaged?) */ 5 22 5 23 5 24 /* Allocation overhead factors: When allocating those structures with refer extents, insure that the variable portion of 5 25* the structure contains a multiple of the appropriate constant number of slots. These extra slots will be used for 5 26* later additions to the structure; when a new element must be added to a full structure, add this many new slots (rather 5 27* than a single new slot) 5 28* 5 29* The following expression should be used to determine the initial allocation: 5 30* 5 31* n_slots_to_allocate = n_slots_needed + CONSTANT - mod (n_slots_needed, CONSTANT); */ 5 32 5 33 dcl (mlsys_data_$mailbox_allocation, /* mailbox.messages */ 5 34 mlsys_data_$message_body_sections_allocation, /* message.body_sections */ 5 35 mlsys_data_$message_redistributions_list_allocation, /* message_redistributions_list.redistributions */ 5 36 mlsys_data_$message_user_fields_allocation, /* message_user_fields_list.user_fields */ 5 37 mlsys_data_$message_references_list_allocation, /* message_references_list.references */ 5 38 mlsys_data_$address_list_allocation) /* address_list.addresses */ 5 39 fixed binary external; 5 40 5 41 5 42 /* Static data user by the Multics mail system */ 5 43 5 44 dcl (mlsys_data_$forum_not_available, /* 1 => forum isn't available on the system or in this ring */ 5 45 mlsys_data_$ism_not_available, /* 1 => no inter-system mailer on this system */ 5 46 mlsys_data_$domains_available) /* 1 => domain name system software on this sytem */ 5 47 fixed binary (1) external; 5 48 5 49 dcl (mlsys_data_$subsystem_ring, /* ring in which the mail system is secured */ 5 50 mlsys_data_$highest_usable_ring, /* highest ring of execution which may use the mail system */ 5 51 mlsys_data_$lowest_forum_ring) /* lowest ring of execution with access to forum */ 5 52 fixed binary (3) external; 5 53 5 54 dcl mlsys_data_$temp_segment_list_ptr pointer external; /* -> list of all mail system temporary segments */ 5 55 5 56 dcl mlsys_data_$valid_segments (0:4095) bit (1) unaligned external; 5 57 /* indicates which segments have been used by the mail system 5 58* for the allocation of user-visible data in order to 5 59* validate that pointers passed from the user-ring are OK */ 5 60 5 61 dcl mlsys_area area based (mlsys_data_$subsystem_area_ptr);/* area used for all user-visible allocations ... */ 5 62 dcl mlsys_data_$subsystem_area_ptr pointer external; /* ... and the pointer on which it is based */ 5 63 5 64 dcl mlsys_data_$hash_tables_segment_ptr pointer external; /* -> hash tables used by the mail system */ 5 65 5 66 dcl mlsys_data_$transmit_cache_ptr pointer external; /* -> cache of recently used mailboxes for mlsys_transmit_ */ 5 67 5 68 dcl mlsys_data_$user_is_anonymous bit (1) aligned external;/* ON => the user is an anonymous user */ 5 69 5 70 dcl mlsys_data_$person_id character (24) varying external; /* the user's Person_id */ 5 71 dcl mlsys_data_$project_id character (12) varying external;/* the user's Project_id */ 5 72 dcl mlsys_data_$user_id character (32) varying external; /* the user's User_id (Person_id.Project_id) */ 5 73 5 74 /* END INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 2522 2523 6 1 /* BEGIN INCLUDE FILE aim_template.incl.pl1 */ 6 2 6 3 /* Created 740723 by PG */ 6 4 /* Modified 06/28/78 by C. D. Tavares to add rcp privilege */ 6 5 /* Modified 83-05-10 by E. N. Kitltitz to add communications privilege */ 6 6 6 7 /* This structure defines the components of both an access 6 8* class and an access authorization as interpreted by the 6 9* Access Isolation Mechanism. */ 6 10 6 11 6 12 dcl 1 aim_template aligned based, /* authorization/access class template */ 6 13 2 categories bit (36), /* access categories */ 6 14 2 level fixed bin (17) unaligned, /* sensitivity level */ 6 15 2 privileges unaligned, /* special access privileges (in authorization only) */ 6 16 (3 ipc, /* interprocess communication privilege */ 6 17 3 dir, /* directory privilege */ 6 18 3 seg, /* segment privilege */ 6 19 3 soos, /* security out-of-service privilege */ 6 20 3 ring1, /* ring 1 access privilege */ 6 21 3 rcp, /* RCP resource access privilege */ 6 22 3 comm) bit (1), /* communications cross-AIM privilege */ 6 23 3 pad bit (11); 6 24 6 25 6 26 /* END INCLUDE FILE aim_template.incl.pl1 */ 2524 2525 2526 /* Various whitespace constants are placed here as they generate so many blank pages ... */ 2527 2528 dcl VT character (1) static options (constant) initial (" "); 2529 dcl FF character (1) static options (constant) initial (" "); 2530 2531 dcl NON_SPACE_WHITESPACE character (4) static options (constant) initial (" 2532 "); /* horizontal tab, newline, vertical tab, formfeed */ 2533 2534 end mlsys_message_mgr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/30/86 1343.5 mlsys_message_mgr_.pl1 >spec>install>1080>mlsys_message_mgr_.pl1 2514 1 10/27/83 2104.2 mlsys_copy_ptr.incl.pl1 >ldd>include>mlsys_copy_ptr.incl.pl1 2516 2 05/22/86 1225.8 mlsys_message.incl.pl1 >ldd>include>mlsys_message.incl.pl1 2518 3 10/27/83 2104.2 mlsys_address_list.incl.pl1 >ldd>include>mlsys_address_list.incl.pl1 2520 4 10/27/83 2104.2 mlsys_address_route.incl.pl1 >ldd>include>mlsys_address_route.incl.pl1 2522 5 06/30/86 1338.7 mlsys_internal_data.incl.pl1 >spec>install>1080>mlsys_internal_data.incl.pl1 2524 6 09/07/83 1610.6 aim_template.incl.pl1 >ldd>include>aim_template.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ADDRESS_LIST_VERSION_2 000012 constant char(8) initial unaligned dcl 3-12 set ref 275* 278* 281* 284* 287* 658* 667* 1600* ADDRESS_ROUTE_VERSION_1 000010 constant char(8) initial unaligned dcl 4-14 ref 2126 BS constant char(1) initial unaligned dcl 161 ref 2442 CR constant char(1) initial unaligned dcl 161 ref 2443 FF constant char(1) initial unaligned dcl 2529 ref 2443 HT constant char(1) initial unaligned dcl 161 ref 509 684 985 2432 IN_MAILBOX_MESSAGE constant fixed bin(17,0) initial dcl 102 ref 226 254 2063 LOWERCASE 000070 constant char(26) initial unaligned dcl 175 ref 1417 1420 MAX_STACK_EXTENSION constant fixed bin(21,0) initial dcl 156 ref 2342 2405 2475 MESSAGE_ADDRESS_LIST_USER_FIELD constant fixed bin(17,0) initial dcl 2-174 ref 1301 2209 MESSAGE_BIT_STRING_BODY_SECTION constant fixed bin(17,0) initial dcl 2-285 ref 1085 2247 MESSAGE_BODY_SECTION_PARAMETER_VERSION_2 000014 constant char(8) initial unaligned dcl 2-318 ref 423 1744 1798 MESSAGE_ENVELOPE_PARAMETER_VERSION_2 000034 constant char(8) initial unaligned dcl 2-79 ref 1326 MESSAGE_INTEGER_USER_FIELD constant fixed bin(17,0) initial dcl 2-174 ref 2204 MESSAGE_PREFORMATTED_BODY_SECTION constant fixed bin(17,0) initial dcl 2-285 ref 1075 2247 MESSAGE_REDISTRIBUTIONS_LIST_VERSION_2 000030 constant char(8) initial unaligned dcl 2-117 ref 315 626 MESSAGE_REDISTRIBUTION_PARAMETER_VERSION_2 000026 constant char(8) initial unaligned dcl 2-144 ref 582 1844 MESSAGE_REFERENCES_LIST_VERSION_2 000020 constant char(8) initial unaligned dcl 2-227 ref 297 796 MESSAGE_REFERENCE_PARAMETER_VERSION_2 000016 constant char(8) initial unaligned dcl 2-253 ref 736 1900 MESSAGE_TEXT_USER_FIELD constant fixed bin(17,0) initial dcl 2-174 ref 1291 2204 MESSAGE_TRACE_VERSION_2 000032 constant char(8) initial unaligned dcl 2-103 ref 1389 2120 MESSAGE_USER_FIELDS_LIST_VERSION_2 000024 constant char(8) initial unaligned dcl 2-158 ref 305 943 MESSAGE_USER_FIELD_PARAMETER_VERSION_2 000022 constant char(8) initial unaligned dcl 2-213 ref 885 1963 MESSAGE_VERSION_2 000036 constant char(8) initial unaligned dcl 2-49 ref 236 247 469 2027 NEW_MESSAGE constant fixed bin(17,0) initial dcl 102 ref 233 255 310 383 435 1056 1760 1814 2002 2101 NL constant char(1) initial unaligned dcl 161 ref 2299 2443 NON_SPACE_WHITESPACE 000006 constant char(4) initial unaligned dcl 2531 ref 841 994 1680 2348 NULL_STRING 000106 constant char(1) initial unaligned dcl 158 set ref 290 369 675 829 971 1075 1085 1166 1232 1291 1655 1664 P_access_class parameter bit(72) dcl 46 ref 1693 1699 P_address_list_ptr parameter pointer dcl 40 set ref 1491 1496* 1500 1505* 1512 1517* 1521 1526* 1531 1536* 1540 1545* 1552 1557* 1561 1566* 1571 1576* 1580 1585* P_allow_duplicates parameter bit(1) dcl 72 ref 858 866 874 894 1935 1943 1951 1976 P_code parameter fixed bin(35,0) dcl 30 set ref 223 230 238* 324* 330 333* 337 340* 390* 396 399* 404 407* 412 415* 424* 429* 440* 563 566* 571 574* 583* 588* 595* 702 705* 710 713* 718 721* 722* 737* 740* 751* 761* 858 861* 866 869* 874 877* 886* 891* 898* 909* 1032 1035* 1039 1042* 1050* 1059* 1117 1120* 1124 1127* 1135* 1141* 1186 1189* 1193 1196* 1204* 1210* 1251 1254* 1258 1261* 1269* 1275* 1318 1321* 1327* 1332* 1337* 1491 1494* 1496* 1500 1503* 1505* 1512 1515* 1517* 1521 1524* 1526* 1531 1534* 1536* 1540 1543* 1545* 1552 1555* 1557* 1561 1564* 1566* 1571 1574* 1576* 1580 1583* 1585* 1628 1631* 1636 1639* 1644 1647* 1686* 1693 1696* 1701* 1710* 1717 1720* 1725 1728* 1733 1736* 1745* 1749* 1764* 1770 1773* 1778 1781* 1786 1789* 1799* 1803* 1806* 1818* 1824 1827* 1832 1835* 1845* 1849* 1852* 1860* 1866 1869* 1874 1877* 1882 1885* 1886* 1901* 1904* 1911* 1920* 1929* 1935 1938* 1943 1946* 1951 1954* 1964* 1968* 1971* 1981* 1991* 1997 2000* 2038 2041* 2075 2078* 2506* P_date_time_created parameter fixed bin(71,0) dcl 80 set ref 1997 2002* 2006* 2075 2080* P_im_message_info_ptr parameter pointer dcl 35 set ref 223 254 2038 2043* P_message_body_section_parameter_ptr parameter pointer dcl 49 ref 396 404 412 421 1717 1725 1733 1742 1770 1778 1786 1796 P_message_envelope_parameter_ptr parameter pointer dcl 38 ref 1318 1324 P_message_ptr parameter pointer dcl 29 set ref 223 230 323* 330 333* 337 340* 343* 345* 396 399* 404 407* 412 415* 419* 438* 563 566* 571 574* 578* 702 705* 710 713* 718 721* 742* 858 861* 866 869* 874 877* 881* 1032 1035* 1039 1042* 1045* 1117 1120* 1124 1127* 1130* 1186 1189* 1193 1196* 1199* 1251 1254* 1258 1261* 1264* 1318 1321* 1323* 1491 1494* 1495* 1500 1503* 1504* 1512 1515* 1516* 1521 1524* 1525* 1531 1534* 1535* 1540 1543* 1544* 1552 1555* 1556* 1561 1564* 1565* 1571 1574* 1575* 1580 1583* 1584* 1628 1631* 1636 1639* 1644 1647* 1652* 1693 1696* 1698* 1717 1720* 1725 1728* 1733 1736* 1740* 1763* 1770 1773* 1778 1781* 1786 1789* 1793* 1817* 1824 1827* 1832 1835* 1839* 1866 1869* 1874 1877* 1882 1885* 1906* 1935 1938* 1943 1946* 1951 1954* 1958* 1997 2000* 2002 2002 2006 2038 2041* 2043 2075 2078* 2080 P_message_redistribution_parameter_ptr parameter pointer dcl 54 ref 563 571 580 1824 1832 1842 P_message_reference_parameter_ptr parameter pointer dcl 64 ref 702 710 734 1866 1874 1898 P_message_user_field_parameter_ptr parameter pointer dcl 69 ref 858 866 874 883 1935 1943 1951 1961 P_message_version parameter char(8) unaligned dcl 32 ref 223 230 236 P_position parameter fixed bin(17,0) dcl 75 set ref 396 404 412 431* 439* 563 571 590* 594* 702 710 718 750* 756* 760* 858 866 874 897* 904* 908* 1032 1039 1047 1117 1124 1132 1186 1193 1201 1251 1258 1266 1770 1778 1786 1795 1824 1832 1841 1866 1874 1882 1908 1919* 1935 1943 1951 1960 1980* P_referenced_message_ptr parameter pointer dcl 59 set ref 718 722* 725* 1882 1886* 1889* P_subject parameter char unaligned dcl 44 set ref 1628 1636 1644 1663 1669* 1675 1677 SINGLE_WIDTH_CHARACTERS 000040 constant char(95) initial unaligned dcl 180 ref 2420 SPACE 000106 constant char(1) initial unaligned dcl 161 ref 842 843 995 996 1681 1682 SPACE_SPACE constant char(2) initial unaligned dcl 170 ref 845 998 1683 2351 2354 TEN_SPACES 020767 constant char(10) initial unaligned dcl 172 set ref 2436 2436 UPPERCASE 000077 constant char(26) initial unaligned dcl 175 ref 1417 1420 VT constant char(1) initial unaligned dcl 2528 ref 2443 access_class 32 based bit(72) level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 271* 1703* 1708* access_class 000100 automatic bit(72) dcl 87 in procedure "mlsys_message_mgr_" set ref 1699* 1703* 1703 1708 acknowledge_to 12 based pointer level 2 in structure "target_envelope" dcl 1351 in procedure "set_envelope" set ref 1368 1369* 1369* 1370* acknowledge_to 26 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 267* acknowledge_to 12 based pointer level 2 in structure "p_envelope" dcl 1445 in procedure "delete_envelope" set ref 1448 1448* acknowledge_to 12 based pointer level 2 in structure "envelope" dcl 2147 in procedure "verify_envelope" set ref 2159 2159* addr builtin function dcl 218 ref 249 252 254 257 260 290 293 298 301 306 308 316 318 369 369 381 381 383 383 383 386 428 435 435 465 466 471 496 506 533 587 620 622 628 648 649 649 649 649 675 682 726 740 740 744 791 792 798 816 829 836 839 890 938 939 945 963 971 981 983 1056 1056 1073 1075 1075 1085 1085 1155 1157 1157 1166 1166 1227 1232 1232 1289 1291 1291 1331 1334 1334 1335 1335 1655 1655 1664 1671 1675 1678 1749 1749 1757 1760 1760 1803 1803 1811 1814 1814 1849 1849 1857 1890 1904 1904 1926 1968 1968 1988 2002 2002 2043 2063 2080 2101 2178 2178 2363 2423 2423 2436 2436 2441 2441 2456 address_list_ptr 2 based pointer level 2 in structure "address_list_user_field" dcl 2196 in procedure "verify_user_field" set ref 2209 2209* address_list_ptr 2 based pointer level 2 in structure "message_address_list_user_field" dcl 2-190 in procedure "mlsys_message_mgr_" set ref 1004* 1301 1301* address_list_ptr 2 based pointer level 2 in structure "the_address_list_user_field" dcl 922 in procedure "add_user_field_internal" set ref 1004* 1006 1007* 1007* 1010* 1011* address_list_ptr 000174 automatic pointer dcl 3-14 in procedure "mlsys_message_mgr_" set ref 1600* 1607* 1610* 1616 address_list_user_field based structure level 1 dcl 2196 address_route based structure level 1 dcl 4-6 address_route_ptr 000176 automatic pointer dcl 4-16 set ref 1392* 1393 1393 1393 1396 aim_check_$greater_or_equal 000046 constant entry external dcl 194 ref 1703 aim_template based structure level 1 dcl 6-12 baseno builtin function dcl 218 ref 511 536 686 839 983 1393 1678 2024 2337 2337 2360 2360 2400 2400 2453 2453 2473 2473 bcc 46 based pointer level 3 dcl 2-15 set ref 287* 288* 375 375* 1576* 1585* binary builtin function dcl 218 ref 511 536 686 839 983 1393 1678 2024 bit_string_lth 4 based fixed bin(24,0) level 2 in structure "message_bit_string_body_section" dcl 2-301 in procedure "mlsys_message_mgr_" ref 524 528 528 531 531 1089 1089 bit_string_lth 4 based fixed bin(24,0) level 2 in structure "the_bit_string_body_section" dcl 451 in procedure "add_body_section_internal" set ref 524* bit_string_ptr 2 based pointer level 2 in structure "message_bit_string_body_section" dcl 2-301 in procedure "mlsys_message_mgr_" set ref 531 536 539* 1085 1085 1089 1090* bit_string_ptr 2 based pointer level 2 in structure "the_bit_string_body_section" dcl 451 in procedure "add_body_section_internal" set ref 528* 531 539* body 62 based structure level 2 dcl 2-15 body_sections 64 based structure array level 3 dcl 2-15 set ref 483* 483 492* 492 496 1073 1094* 1094 cc 44 based pointer level 3 dcl 2-15 set ref 284* 285* 376 376* 1557* 1566* cleanup 000000 stack reference condition dcl 216 ref 458 613 784 931 2335 2398 clock builtin function dcl 218 ref 435 1056 1760 1814 code 000103 automatic fixed bin(35,0) dcl 91 set ref 2343* 2344 2344* 2406* 2407 2407* 2476* 2477 2477* column 000110 automatic fixed bin(21,0) dcl 2388 set ref 2412* 2424* 2424 2433 2435 2437* 2437 2442* 2442 2443* comment 24 based structure level 3 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" comment 24 based structure level 3 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" copy_redistribution_data 000130 automatic bit(1) dcl 151 set ref 567* 575* 652 662 678 1828* 1836* copy_reference_data 000131 automatic bit(1) dcl 151 set ref 706* 714* 723* 819 832 1870* 1878* 1887* copy_section_content 000127 automatic bit(1) dcl 151 set ref 400* 408* 416* 502 527 1721* 1729* 1737* 1774* 1782* 1790* copy_subject 000126 automatic bit(1) dcl 151 set ref 1632* 1640* 1648* 1668 copy_user_field_content 000132 automatic bit(1) dcl 151 set ref 862* 870* 878* 974 1007 1939* 1947* 1955* cu_$grow_stack_frame 000050 constant entry external dcl 195 ref 2346 2410 2482 date_time 2 based fixed bin(71,0) level 2 in structure "the_date_user_field" dcl 923 in procedure "add_user_field_internal" set ref 1015* date_time 2 based fixed bin(71,0) level 2 in structure "message_date_user_field" dcl 2-195 in procedure "mlsys_message_mgr_" ref 1015 date_time_created based fixed bin(71,0) level 2 in structure "new_message_info" dcl 135 in procedure "mlsys_message_mgr_" set ref 258* 435* 1056* 1760* 1814* 2002 2080 date_time_created 34 based fixed bin(71,0) level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 273* 728 1892 2006 date_time_created 6 based fixed bin(71,0) level 3 in structure "message_reference_parameter" dcl 2-248 in procedure "mlsys_message_mgr_" set ref 728* 1892* date_time_delivered 22 based fixed bin(71,0) level 3 dcl 2-15 set ref 266* date_time_mailed 14 based fixed bin(71,0) level 3 dcl 2-15 set ref 266* delivered_by 10 based pointer level 2 in structure "p_envelope" dcl 1445 in procedure "delete_envelope" set ref 1451 1451* delivered_by 10 based pointer level 2 in structure "target_envelope" dcl 1351 in procedure "set_envelope" set ref 1363 1364* 1364* 1365* delivered_by 24 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 267* delivered_by 10 based pointer level 2 in structure "envelope" dcl 2147 in procedure "verify_envelope" set ref 2156 2156* divide builtin function dcl 218 ref 2346 2392 2392 envelope 4 based structure level 2 in structure "message_envelope_parameter" dcl 2-74 in procedure "mlsys_message_mgr_" set ref 1331 envelope based structure level 2 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" set ref 649 649 1157 1157 envelope 14 based structure level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 381 381 478* 478 1334 1334 1335 1335 envelope based structure level 2 in structure "redistribution" dcl 2173 in procedure "verify_redistribution" set ref 2178 2178 envelope based structure level 1 dcl 2147 in procedure "verify_envelope" envelope based structure level 2 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 649 649 error_table_$ai_restricted 000016 external static fixed bin(35,0) dcl 187 ref 1710 error_table_$bad_index 000020 external static fixed bin(35,0) dcl 187 ref 1050 1135 1204 1269 1806 1852 1911 1971 error_table_$smallarg 000022 external static fixed bin(35,0) dcl 187 ref 2202 error_table_$unimplemented_version 000024 external static fixed bin(35,0) dcl 187 ref 238 424 583 737 886 1327 1745 1799 1845 1901 1964 2120 2126 field_id based bit(36) level 3 in structure "user_field" dcl 2195 in procedure "verify_user_field" set ref 2201* field_id based bit(36) level 3 in structure "message_user_field" dcl 2-163 in procedure "mlsys_message_mgr_" ref 896 field_id 10 based bit(36) array level 4 in structure "message_user_fields_list" dcl 2-150 in procedure "mlsys_message_mgr_" set ref 896 1978 field_id 4 based bit(36) level 4 in structure "message_user_field_parameter" dcl 2-208 in procedure "mlsys_message_mgr_" set ref 1978 field_type 1 based fixed bin(17,0) level 3 in structure "user_field" dcl 2195 in procedure "verify_user_field" ref 2204 2204 2209 field_type 1 based fixed bin(17,0) level 3 in structure "message_user_field" dcl 2-163 in procedure "mlsys_message_mgr_" ref 965 1291 1301 flags 11 based structure level 3 in structure "the_reference" dcl 775 in procedure "add_reference_internal" set ref 827* flags 27 based structure level 4 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" flags 5 based structure level 3 in structure "message_text_user_field" dcl 2-183 in procedure "mlsys_message_mgr_" flags 27 based structure level 4 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 672* flags 11 based structure level 3 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" flags 5 based structure level 3 in structure "the_text_user_field" dcl 921 in procedure "add_user_field_internal" flags 53 based structure level 4 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 292* 1661* flags 12 based structure level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 264* 477* 477 free_bit_string based bit(1) level 2 packed unaligned dcl 128 set ref 533* 1085 free_text based bit(1) level 2 in structure "message_preformatted_body_section_reserved_data" packed unaligned dcl 124 in procedure "mlsys_message_mgr_" set ref 506* 1075 free_text based bit(1) level 2 in structure "message_text_field_reserved_flags" packed unaligned dcl 120 in procedure "mlsys_message_mgr_" set ref 293* 369 682* 836* 981* 1166 1232 1291 1655 1671* from 20 based pointer level 3 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" set ref 1160 1160* from 36 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 275* 276* 379 379* 729 1496* 1505* 1893 from 4 based pointer level 2 in structure "the_reference" dcl 775 in procedure "add_reference_internal" set ref 818 819* 819* 821* 821* 822* 823* from 20 based pointer level 3 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 651 652* 652* 655* 655* 656* 658* 660* from 10 based pointer level 3 in structure "message_reference_parameter" dcl 2-248 in procedure "mlsys_message_mgr_" set ref 729* 1893* from 4 based pointer level 2 in structure "reference" dcl 2225 in procedure "verify_reference" set ref 2230 2230* from 4 based pointer level 2 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" set ref 1229 1229* from 20 based pointer level 3 in structure "redistribution" dcl 2173 in procedure "verify_redistribution" set ref 2180 2180* get_authorization_ 000052 constant entry external dcl 196 ref 271 1703 1703 get_privileges_ 000054 constant entry external dcl 197 ref 1707 header 10 based structure array level 3 in structure "message_user_fields_list" dcl 2-150 in procedure "mlsys_message_mgr_" header 14 based structure level 2 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 650* header based structure level 2 in structure "message_body_section" dcl 2-274 in procedure "mlsys_message_mgr_" ref 497 header based structure level 2 in structure "the_body_section" dcl 449 in procedure "add_body_section_internal" set ref 497* header 64 based structure array level 4 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" header 30 based structure level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 479* 479 header 4 based structure level 3 in structure "message_user_field_parameter" dcl 2-208 in procedure "mlsys_message_mgr_" header based structure level 2 in structure "user_field" dcl 2195 in procedure "verify_user_field" header 14 based structure level 2 in structure "redistribution" dcl 2173 in procedure "verify_redistribution" header 14 based structure level 2 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" set ref 650 header based structure level 2 in structure "the_user_field" dcl 920 in procedure "add_user_field_internal" set ref 964* header based structure level 2 in structure "address_route" dcl 4-6 in procedure "mlsys_message_mgr_" header based structure level 2 in structure "message_user_field" dcl 2-163 in procedure "mlsys_message_mgr_" ref 964 header 4 based structure level 3 in structure "message_body_section_parameter" dcl 2-313 in procedure "mlsys_message_mgr_" idx 000106 automatic fixed bin(17,0) dcl 1383 in procedure "set_trace" set ref 1403* 1404 1404 1405 1405 1409 1409 1412 1412 1417 1417 1420 1420 1424 1425 1425 1427* idx 000131 automatic fixed bin(21,0) dcl 2287 in procedure "count_lines_in_text" set ref 2299* 2300 2300* 2303 idx 000274 automatic fixed bin(17,0) dcl 1287 in procedure "delete_user_field_internal" set ref 1306* 1307 1307* idx 000242 automatic fixed bin(17,0) dcl 1071 in procedure "delete_body_section_internal" set ref 1093* 1094 1094* 1101* 1102 1104* idx 000264 automatic fixed bin(17,0) dcl 1224 in procedure "delete_reference_internal" set ref 1239* 1240 1240* idx 000133 automatic fixed bin(17,0) dcl 154 in procedure "mlsys_message_mgr_" set ref 347* 348* 351* 352* 357* 358* 363* 364* 747* 748 750* 895* 896 897* 1752* 1753* 1916* 1917 1919* 1977* 1978 1980* idx 000312 automatic fixed bin(17,0) dcl 1468 in procedure "delete_trace" set ref 1472* 1473 1473* idx 000104 automatic fixed bin(17,0) dcl 927 in procedure "add_user_field_internal" set ref 948* 949 949* 958* 959 959* idx 000106 automatic fixed bin(21,0) dcl 2329 in procedure "normalize_single_line_field" set ref 2351* 2352 2353 2353 2354* idx 000104 automatic fixed bin(17,0) dcl 609 in procedure "add_redistribution_internal" set ref 632* 633 633* 642* 643 643* idx 000353 automatic fixed bin(17,0) dcl 2118 in procedure "verify_trace" set ref 2130* 2131 2131* idx 000104 automatic fixed bin(17,0) dcl 778 in procedure "add_reference_internal" set ref 802* 803 803* 811* 812 812* idx 000104 automatic fixed bin(17,0) dcl 454 in procedure "add_body_section_internal" set ref 482* 483 483* 491* 492 492* 547* 548 550* idx 000254 automatic fixed bin(17,0) dcl 1153 in procedure "delete_redistribution_internal" set ref 1173* 1174 1174* idx 000112 automatic fixed bin(21,0) dcl 2388 in procedure "normalize_multiline_field" set ref 2420* 2421 2421* 2423 2424 2425 ignore 000404 automatic bit(1) dcl 2199 in procedure "verify_user_field" set ref 2209* ignore 000374 automatic bit(1) dcl 2176 in procedure "verify_redistribution" set ref 2178* 2180* 2183* ignore 000414 automatic bit(1) dcl 2228 in procedure "verify_reference" set ref 2230* ignore 000364 automatic bit(1) dcl 2150 in procedure "verify_envelope" set ref 2152* 2154* 2156* 2159* ignore 000352 automatic bit(1) dcl 2117 in procedure "verify_trace" set ref 2131* implicit_route 6 based pointer level 2 dcl 2-87 set ref 1392* 1393* 1396* 1398* 1399 1399* 1477 1477* 2126 2126 index builtin function dcl 218 ref 509 684 845 985 998 1683 2299 2351 2354 info_ptr based pointer level 2 dcl 96 set ref 254* 257* 260* 383 383 386* 435 1056 1760 1814 2002 2043* 2080 length builtin function dcl 218 ref 843 996 1663 1677 1682 2289 2300 2332 2357 2357 2358 2363 2364 2392 2415 2418 2421 2428 2457 local_mrfp 000106 automatic structure level 1 dcl 143 set ref 726 1890 ltrim builtin function dcl 218 ref 2348 max builtin function dcl 218 ref 1108 2273 2442 message based structure level 1 dcl 2-15 set ref 245 388 460 468 485 message_address_list_user_field based structure level 1 dcl 2-190 message_bit_string_body_section based structure level 1 dcl 2-301 message_bit_string_body_section_bit_string based bit unaligned dcl 2-307 set ref 528 531* 531 1089 message_bit_string_body_section_reserved_data based structure level 1 dcl 128 message_body_section based structure level 1 dcl 2-274 message_body_section_parameter based structure level 1 dcl 2-313 message_body_section_parameter_ptr 000172 automatic pointer dcl 2-320 set ref 421* 423 428 1742* 1744 1749 1749 1757 1796* 1798 1803 1803 1811 message_body_section_ptr 000170 automatic pointer dcl 2-280 set ref 428* 429* 497 498 503 503 503 509 509 511 515 516 518 518 524 528 528 531 531 531 536 539 1073* 1075 1075 1075 1075 1079 1079 1079 1080 1085 1085 1085 1085 1089 1089 1089 1090 1757* 1811* message_date_user_field based structure level 1 dcl 2-195 message_envelope based structure level 1 dcl 2-61 message_envelope_parameter based structure level 1 dcl 2-74 message_envelope_parameter_ptr 000146 automatic pointer dcl 2-81 set ref 1324* 1326 1331 message_envelope_ptr 000144 automatic pointer dcl 2-69 set ref 1331* 1332* 1335* message_id 10 based bit(72) array level 3 in structure "message_references_list" dcl 2-219 in procedure "mlsys_message_mgr_" set ref 748 1917 message_id based bit(72) level 2 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" ref 748 message_id 30 based bit(72) level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 269* 727 1891 message_id 4 based bit(72) level 3 in structure "message_reference_parameter" dcl 2-248 in procedure "mlsys_message_mgr_" set ref 727* 1891* 1917 message_integer_user_field based structure level 1 dcl 2-200 message_n_body_sections 000136 automatic fixed bin(17,0) dcl 2-55 set ref 242* 245 245 249 466* 468 468 471 message_n_redistributions 000140 automatic fixed bin(17,0) dcl 2-55 set ref 313* 314 314 316 622* 625 625 628 message_n_user_fields 000141 automatic fixed bin(17,0) dcl 2-55 set ref 303* 304 304 306 939* 942 942 945 message_preformatted_body_section based structure level 1 dcl 2-292 message_preformatted_body_section_reserved_data based structure level 1 dcl 124 message_preformatted_body_section_text based char unaligned dcl 2-298 set ref 503* 509 518* 1079 message_ptr 000134 automatic pointer dcl 2-53 in procedure "mlsys_message_mgr_" set ref 245* 247 249 250 252 254 257 260 262 262 262 264 266 266 267 267 267 267 269 271 273 275 276 278 279 281 282 284 285 287 288 290 291 292 293 300 301 304 305 306 307 308 308 310 314 315 316 317 318 318 321 323 343* 347 351 354 354 355 357 360 361 363 364 364 366 367 369 369 369 371 371 371 372 375 375 376 376 377 377 378 378 379 379 381 381 383 383 383 386 388 419* 431 435 435 438 465 465 466 470 473 474 475 476 477 478 479 480 481 482 483 485 486* 491 492 492 496 542 542 546 547 547 548 548 550 550 550 554 554 554 554 578* 590 620 620 622 627 630 632 633 636 637 642 643 643 648 694 694 694 725* 727 728 729 730 742* 747 748 756 758 758 802 881* 895 896 904 938 938 939 944 947 948 949 952 953 958 959 959 963 1023 1023 1023 1045* 1049 1056 1056 1073 1093 1094 1094 1097 1097 1100 1101 1101 1102 1102 1104 1104 1104 1108 1108 1108 1108 1130* 1134 1155 1173 1174 1174 1178 1178 1178 1199* 1203 1208 1208 1264* 1268 1289 1306 1307 1307 1310 1310 1310 1323* 1334 1334 1335 1335 1495* 1496 1504* 1505 1516* 1517 1525* 1526 1535* 1536 1544* 1545 1556* 1557 1565* 1566 1575* 1576 1584* 1585 1652* 1655 1655 1655 1657 1657 1657 1658 1661 1664 1665 1669 1669 1671 1675 1676 1676 1677 1678 1678 1680 1680 1681 1681 1682 1682 1682 1682 1683 1683 1698* 1703 1708 1740* 1752 1760 1760 1763 1793* 1805 1814 1814 1817 1839* 1851 1889* 1891 1892 1893 1894 1906* 1910 1916 1917 1925 1925 1927 1927 1958* 1970 1977 1978 message_ptr based pointer level 2 in structure "message_redistributions_list_reserved_data" dcl 112 in procedure "mlsys_message_mgr_" set ref 318* message_ptr based pointer level 2 in structure "message_user_fields_list_reserved_data" dcl 116 in procedure "mlsys_message_mgr_" set ref 308* message_ptr based pointer level 2 in structure "message_references_list_reserved_data" dcl 108 in procedure "mlsys_message_mgr_" set ref 301* message_redistribution based structure level 1 dcl 2-122 message_redistribution_comment based char unaligned dcl 2-131 set ref 679* 684 1169 message_redistribution_parameter based structure level 1 dcl 2-139 message_redistribution_parameter_ptr 000154 automatic pointer dcl 2-146 set ref 580* 582 587 1842* 1844 1849 1849 1857 message_redistribution_ptr 000152 automatic pointer dcl 2-134 set ref 587* 588* 649 649 650 674 674 679 679 679 684 684 686 690 691 1155* 1157 1157 1160 1160 1163 1163 1166 1166 1166 1169 1169 1169 1170 1857* message_redistributions_list based structure level 1 dcl 2-109 set ref 314 354 615 625 636 message_redistributions_list_reserved_data based structure level 1 dcl 112 message_reference based structure level 1 dcl 2-234 set ref 817 message_reference_parameter based structure level 1 dcl 2-248 message_reference_parameter_ptr 000166 automatic pointer dcl 2-255 set ref 726* 727 728 729 730 734* 736 740 740 744 1890* 1891 1892 1893 1894 1898* 1900 1904 1904 1917 1926 message_reference_ptr 000164 automatic pointer dcl 2-243 set ref 744* 748 817 828 828 833 833 833 839 839 841 841 842 842 843 843 843 843 845 845 846 847 1227* 1229 1229 1232 1232 1232 1235 1235 1235 1236 1926* message_reference_subject based char unaligned dcl 2-240 set ref 833* 839 841 842 843 843 845 1235 message_references_list based structure level 1 dcl 2-219 set ref 296 366 786 795 805 message_references_list_n_references 000142 automatic fixed bin(17,0) dcl 2-55 set ref 295* 296 296 298 792* 795 795 798 message_references_list_ptr 000162 automatic pointer dcl 2-229 set ref 296* 297 298 299 300 301 780* 791 792 797 801 803 805 806* 812 812 816 850 1226* 1227 1240 1240 1243 message_references_list_reserved_data based structure level 1 dcl 108 message_reserved_data based structure level 1 dcl 96 message_subject based char unaligned dcl 2-51 set ref 371 1657 1678 1680 1681 1682 1682 1683 message_text_field based structure level 1 dcl 2-260 message_text_field_reserved_flags based structure level 1 packed unaligned dcl 120 message_text_user_field based structure level 1 dcl 2-183 message_text_user_field_text based char unaligned dcl 2-187 set ref 975* 979* 983 985 994 995 996 996 998 1295 message_trace based structure level 1 dcl 2-87 set ref 1387 1480 message_trace_n_relays 000137 automatic fixed bin(17,0) dcl 2-55 set ref 1385* 1387 1387 message_trace_ptr 000150 automatic pointer dcl 2-105 set ref 1470* 1472 1473 1473 1477 1477 1480 message_type 000125 automatic fixed bin(17,0) dcl 149 set ref 226* 233* 252 254 255 310 message_user_field based structure level 1 dcl 2-163 message_user_field_parameter based structure level 1 dcl 2-208 message_user_field_parameter_ptr 000160 automatic pointer dcl 2-215 set ref 883* 885 890 1961* 1963 1968 1968 1978 1988 message_user_field_ptr 000156 automatic pointer dcl 2-169 set ref 890* 891* 896 964 965 967 970 970 975 975 975 979 979 979 983 983 985 985 989 990 994 994 995 995 996 996 996 996 998 998 999 1000 1004 1015 1019 1289* 1291 1291 1291 1291 1295 1295 1295 1296 1301 1301 1301 1988* message_user_fields_list based structure level 1 dcl 2-150 set ref 304 360 933 942 952 message_user_fields_list_reserved_data based structure level 1 dcl 116 min builtin function dcl 218 ref 2270 mlsys_address_list_mgr_$copy_address_list 000060 constant entry external dcl 199 ref 652 662 819 1007 1607 mlsys_address_list_mgr_$create_read_only_address_list 000056 constant entry external dcl 198 ref 275 278 281 284 287 658 667 1600 mlsys_address_list_mgr_$decrement_reference_count 000062 constant entry external dcl 200 ref 375 376 377 378 379 1160 1163 1229 1301 1613 mlsys_address_list_mgr_$increment_reference_count 000064 constant entry external dcl 201 ref 276 279 282 285 288 660 669 823 1011 1618 mlsys_address_list_mgr_$set_read_only 000066 constant entry external dcl 202 ref 656 665 822 1010 1617 mlsys_address_list_mgr_$verify_address_list 000070 constant entry external dcl 203 ref 1605 2180 2183 2209 2230 mlsys_address_mgr_$decrement_reference_count 000072 constant entry external dcl 204 ref 1448 1451 1456 1473 mlsys_address_mgr_$increment_reference_count 000074 constant entry external dcl 205 ref 1358 1365 1370 1427 mlsys_address_mgr_$verify_address 000076 constant entry external dcl 206 ref 2131 2152 2156 2159 mlsys_address_route_mgr_$create_address_route 000100 constant entry external dcl 207 ref 1396 mlsys_address_route_mgr_$decrement_reference_count 000102 constant entry external dcl 208 ref 1477 mlsys_address_route_mgr_$increment_reference_count 000104 constant entry external dcl 209 ref 1399 mlsys_area based area(1024) dcl 5-61 ref 245 256 296 304 314 354 360 366 371 383 388 460 468 485 528 615 625 636 786 795 805 933 942 952 1079 1089 1169 1235 1295 1387 1480 1657 2357 2450 mlsys_data_$message_body_sections_allocation 000120 external static fixed bin(17,0) dcl 5-33 ref 242 466 mlsys_data_$message_redistributions_list_allocation 000122 external static fixed bin(17,0) dcl 5-33 ref 313 622 mlsys_data_$message_references_list_allocation 000126 external static fixed bin(17,0) dcl 5-33 ref 295 792 mlsys_data_$message_user_fields_allocation 000124 external static fixed bin(17,0) dcl 5-33 ref 303 939 mlsys_data_$subsystem_area_ptr 000132 external static pointer dcl 5-62 ref 245 256 296 304 314 354 360 366 371 383 388 460 468 485 528 615 625 636 786 795 805 933 942 952 1079 1089 1169 1235 1295 1387 1480 1657 2357 2450 mlsys_data_$valid_segments 000130 external static bit(1) array unaligned dcl 5-56 ref 511 536 686 839 983 1393 1678 2024 mlsys_et_$duplicate_reply_reference 000026 external static fixed bin(35,0) dcl 187 ref 751 1920 mlsys_et_$duplicate_user_field 000030 external static fixed bin(35,0) dcl 187 ref 898 1981 mlsys_et_$message_too_large 000032 external static fixed bin(35,0) dcl 187 set ref 2473* mlsys_et_$not_in_mailbox_message 000034 external static fixed bin(35,0) dcl 187 ref 2063 mlsys_et_$not_message 000036 external static fixed bin(35,0) dcl 187 ref 2022 2024 2027 mlsys_et_$not_new_message 000040 external static fixed bin(35,0) dcl 187 ref 2101 mlsys_et_$unknown_body_section_type 000042 external static fixed bin(35,0) dcl 187 ref 2247 mlsys_et_$unknown_user_field_type 000044 external static fixed bin(35,0) dcl 187 ref 2204 mlsys_field_id_mgr_$get_user_field_name 000106 constant entry external dcl 210 ref 2201 mlsys_nit_interface_$get_fully_qualified_name 000110 constant entry external dcl 211 ref 1409 1412 mlsys_nit_interface_$is_local_system 000112 constant entry external dcl 212 ref 1405 mlsys_storage_mgr_$get_temp_segment 000114 constant entry external dcl 213 ref 2343 2406 2476 mlsys_storage_mgr_$release_temp_segment 000116 constant entry external dcl 214 ref 2337 2360 2400 2453 mod builtin function dcl 218 ref 2433 2435 multiline_text 5 based bit(1) level 4 in structure "message_text_user_field" packed unaligned dcl 2-183 in procedure "mlsys_message_mgr_" ref 967 multiline_text 5 based bit(1) level 4 in structure "the_text_user_field" packed unaligned dcl 921 in procedure "add_user_field_internal" set ref 967* 975 985 multiline_text 27 based bit(1) level 5 in structure "the_redistribution" packed unaligned dcl 606 in procedure "add_redistribution_internal" set ref 673* n_body_sections 11 based fixed bin(17,0) level 2 dcl 2-15 set ref 245* 250* 347 388 431* 460 465 468* 476* 476 482 485 491 542* 542 547 554 1049 1093 1097* 1097 1101 1108 1752 1805 n_body_sections_allocated 2 based fixed bin(17,0) level 2 dcl 96 set ref 249* 465 466 471* n_lines 000127 automatic fixed bin(21,0) dcl 2287 set ref 2291* 2302* 2302 2307 n_redistributions 10 based fixed bin(17,0) level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 262* 351 475* 475 590* 620 632 642 694 694* 1134 1173 1178 1178* 1851 n_redistributions 7 based fixed bin(17,0) level 2 in structure "message_redistributions_list" dcl 2-109 in procedure "mlsys_message_mgr_" set ref 314* 317* 354 615 625* 630* 630 636 694* 1178* n_redistributions_allocated 2 based fixed bin(17,0) level 2 dcl 112 set ref 316* 620 622 628* n_references 7 based fixed bin(17,0) level 2 dcl 2-219 set ref 296* 299* 366 786 795* 801* 801 805 850* 1243* n_references_allocated 2 based fixed bin(17,0) level 2 dcl 108 set ref 298* 791 792 798* n_relays 11 based fixed bin(17,0) level 2 in structure "message_trace" dcl 2-87 in procedure "mlsys_message_mgr_" set ref 1385 1387* 1403 1405 1472 1480 2130 n_relays 6 based fixed bin(17,0) level 3 in structure "address_route" dcl 4-6 in procedure "mlsys_message_mgr_" ref 1396 n_reply_references 6 based fixed bin(17,0) level 2 dcl 2-15 set ref 262* 363 364* 473* 473 747 756* 758* 802 1203 1208* 1910 1916 1925* 1927* n_spaces 000111 automatic fixed bin(21,0) dcl 2388 set ref 2433* 2435* 2436* 2437 n_user_fields 7 based fixed bin(17,0) level 2 in structure "message_user_fields_list" dcl 2-150 in procedure "mlsys_message_mgr_" set ref 304* 307* 360 933 942* 947* 947 952 1023* 1310* n_user_fields 7 based fixed bin(17,0) level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 262* 357 474* 474 895 904* 938 948 958 1023 1023* 1268 1306 1310 1310* 1970 1977 n_user_fields_allocated 2 based fixed bin(17,0) level 2 dcl 116 set ref 306* 938 939 945* new_message_info based structure level 1 dcl 135 set ref 256 383 new_message_info_ptr 000104 automatic pointer dcl 138 set ref 256* 257 258 new_message_ptr 000100 automatic pointer dcl 453 set ref 456* 460 460 461* 468* 469 470 471 473 474 475 476 477 478 479 480 481 483 486 487* new_rl_ptr 000100 automatic pointer dcl 777 in procedure "add_reference_internal" set ref 782* 786 786 787* 795* 796 797 798 801 803 806 807* new_rl_ptr 000100 automatic pointer dcl 608 in procedure "add_redistribution_internal" set ref 611* 615 615 616* 625* 626 627 628 630 633 637 638* new_ufl_ptr 000100 automatic pointer dcl 926 set ref 929* 933 933 934* 942* 943 944 945 947 949 953 954* null builtin function dcl 218 ref 260 267 310 345 354 355 361 367 369 372 375 376 377 378 379 383 386 456 460 461 487 611 615 616 638 651 661 674 782 786 787 807 818 828 929 933 934 954 970 1006 1075 1080 1085 1090 1160 1163 1166 1170 1229 1232 1236 1291 1296 1301 1356 1361 1363 1368 1393 1398 1399 1424 1448 1451 1454 1456 1473 1477 1481 1599 1613 1655 1658 2022 2126 2131 2152 2154 2156 2159 2180 2183 2209 2230 2334 2337 2397 2400 2482 p_actual_position parameter fixed bin(17,0) dcl 2265 set ref 2262 2267* 2270* 2273* p_address_list_ptr parameter pointer dcl 1595 set ref 1592 1599 1605* 1607* 1610* p_body_section_ptr parameter pointer dcl 2244 ref 2241 2247 2247 p_code parameter fixed bin(35,0) dcl 1597 in procedure "replace_address_list_field" set ref 1592 1600* 1602 1605* 1607* 1608 1620* p_code parameter fixed bin(35,0) dcl 2198 in procedure "verify_user_field" set ref 2192 2201* 2202 2202* 2204 2204* 2209 2209* 2214 p_code parameter fixed bin(35,0) dcl 2504 in procedure "abort_normalize_field" ref 2501 2506 p_code parameter fixed bin(35,0) dcl 2227 in procedure "verify_reference" set ref 2222 2230* 2233* 2235 p_code parameter fixed bin(35,0) dcl 2149 in procedure "verify_envelope" set ref 2144 2152* 2154 2154* 2156 2156* 2159 2159* 2162 p_code parameter fixed bin(35,0) dcl 2245 in procedure "verify_body_section" set ref 2241 2247* 2251* 2253 p_code parameter fixed bin(35,0) dcl 2116 in procedure "verify_trace" set ref 2112 2120* 2124* 2126* 2130 2131* 2138 p_code parameter fixed bin(35,0) dcl 2020 in procedure "verify_message_internal" set ref 2016 2022* 2024* 2027* 2030* 2032 p_code parameter fixed bin(35,0) dcl 2058 in procedure "verify_im_message_internal" set ref 2054 2060* 2063* 2066* 2068 p_code parameter fixed bin(35,0) dcl 2175 in procedure "verify_redistribution" set ref 2170 2178* 2180 2180* 2183 2183* 2186 p_code parameter fixed bin(35,0) dcl 2096 in procedure "verify_new_message_internal" set ref 2092 2098* 2101* 2104* 2106 p_copy_address_list parameter bit(1) dcl 1596 ref 1592 1606 p_envelope based structure level 1 dcl 1445 p_envelope_ptr parameter pointer dcl 1446 in procedure "delete_envelope" ref 1442 1448 1448 1451 1451 1454 1454 1456 1456 p_envelope_ptr parameter pointer dcl 2148 in procedure "verify_envelope" ref 2144 2152 2152 2154 2154 2156 2156 2159 2159 p_field parameter pointer dcl 1595 set ref 1592 1613 1613* 1616* 1617* 1618* p_input_position parameter fixed bin(17,0) dcl 2265 ref 2262 2267 2270 2270 2273 p_message_ptr parameter pointer dcl 2095 in procedure "verify_new_message_internal" set ref 2092 2098* 2101 p_message_ptr parameter pointer dcl 2057 in procedure "verify_im_message_internal" set ref 2054 2060* 2063 p_message_ptr parameter pointer dcl 2019 in procedure "verify_message_internal" ref 2016 2022 2024 2027 p_n_in_list parameter fixed bin(17,0) dcl 2265 ref 2262 2270 2273 p_n_references parameter fixed bin(17,0) dcl 772 in procedure "add_reference_internal" set ref 769 791 811 850 850* p_n_references parameter fixed bin(17,0) dcl 1221 in procedure "delete_reference_internal" set ref 1218 1239 1243 1243* p_piece based char unaligned dcl 2468 ref 2488 p_piece_lth parameter fixed bin(21,0) dcl 2470 ref 2465 2472 2475 2481 2488 2488 2489 p_piece_ptr parameter pointer dcl 2469 ref 2465 2488 p_pointer parameter pointer dcl 1-13 ref 1-10 1-16 p_position parameter fixed bin(17,0) dcl 1070 in procedure "delete_body_section_internal" ref 1067 1073 1093 p_position parameter fixed bin(17,0) dcl 1286 in procedure "delete_user_field_internal" ref 1283 1289 1306 p_position parameter fixed bin(17,0) dcl 1152 in procedure "delete_redistribution_internal" ref 1149 1155 1173 p_position parameter fixed bin(17,0) dcl 1223 in procedure "delete_reference_internal" ref 1218 1227 1239 p_redistribution_ptr parameter pointer dcl 2174 ref 2170 2178 2178 2180 2180 2183 2183 p_reference_ptr parameter pointer dcl 2226 ref 2222 2230 2230 p_references_list_ptr parameter pointer dcl 773 set ref 769 780 806* p_references_ptr parameter pointer dcl 1222 ref 1218 1226 p_source_envelope_ptr parameter pointer dcl 1349 ref 1345 1354 1361 1361 p_source_trace_ptr parameter pointer dcl 1382 ref 1379 1385 1392 1404 p_target_envelope_ptr parameter pointer dcl 1352 ref 1345 1354 1356 1357 1357 1358 1361 1363 1364 1364 1365 1368 1369 1369 1370 p_target_trace_ptr parameter pointer dcl 1382 set ref 1379 1387* 1389 1390 1390 1393 1396 1398 1399 1399 1403 1404 1405 1405 1409 1409 1412 1412 1417 1417 1420 1420 1424 1425 1425 1427 p_text parameter char unaligned dcl 2286 in procedure "count_lines_in_text" ref 2283 2289 2299 2299 2300 2300 p_text parameter char unaligned dcl 2318 in procedure "normalize_single_line_field" ref 2315 2332 2348 p_text parameter char unaligned dcl 2376 in procedure "normalize_multiline_field" ref 2373 2392 2415 2418 2420 2420 2421 2421 2423 2423 2423 2423 2428 2429 p_text_lth parameter fixed bin(21,0) dcl 2378 in procedure "normalize_multiline_field" set ref 2373 2457* p_text_lth parameter fixed bin(21,0) dcl 2320 in procedure "normalize_single_line_field" set ref 2315 2364* p_text_ptr parameter pointer dcl 2319 in procedure "normalize_single_line_field" set ref 2315 2363* p_text_ptr parameter pointer dcl 2377 in procedure "normalize_multiline_field" set ref 2373 2456* p_trace_ptr parameter pointer dcl 1467 in procedure "delete_trace" set ref 1464 1470 1481* p_trace_ptr parameter pointer dcl 2115 in procedure "verify_trace" ref 2112 2120 2126 2126 2130 2131 2131 p_user_field_ptr parameter pointer dcl 2197 ref 2192 2201 2204 2204 2209 2209 2209 pad 10 based bit(36) level 2 dcl 2-87 set ref 1390* position 000102 automatic fixed bin(17,0) dcl 89 set ref 431* 439 491 496 590* 594 642 648 756* 760 811 816 904* 908 958 963 1047* 1049 1049 1054* 1132* 1134 1134 1139* 1201* 1203 1203 1208* 1266* 1268 1268 1273* 1756* 1795* 1805 1805 1810* 1841* 1851 1851 1856* 1908* 1910 1910 1916 1916 1925* 1960* 1970 1970 1977 1977 1987* privileges 1(18) based structure level 2 in structure "aim_template" packed unaligned dcl 6-12 in procedure "mlsys_message_mgr_" privileges 000124 automatic structure level 2 in structure "user_privileges" packed unaligned dcl 145 in procedure "mlsys_message_mgr_" receiving_host 115 based varying char(256) array level 3 dcl 2-87 set ref 1405* 1412* 1412* 1420* 1420 redistribution 4 based structure level 2 in structure "message_redistribution_parameter" dcl 2-139 in procedure "mlsys_message_mgr_" set ref 587 1849 1849 1857 redistribution based structure level 1 dcl 2173 in procedure "verify_redistribution" redistributions 10 based structure array level 2 dcl 2-109 set ref 633* 633 643* 643 648 1155 1174* 1174 redistributions_list 60 based pointer level 2 dcl 2-15 set ref 310* 314* 315 316 317 318 354 354 355* 480* 480 620 622 627 630 633 636 637* 643 643 648 694 1155 1174 1174 1178 reference 4 based structure level 2 in structure "message_reference_parameter" dcl 2-248 in procedure "mlsys_message_mgr_" set ref 740 740 744 1904 1904 1926 reference based structure level 1 dcl 2225 in procedure "verify_reference" references 10 based structure array level 2 dcl 2-219 set ref 803* 803 812* 812 816 1227 1240* 1240 relay_recipient 250 based pointer array level 3 dcl 2-87 set ref 1424 1425* 1425* 1427* 1473 1473* 2131 2131* relays 12 based structure array level 2 in structure "message_trace" dcl 2-87 in procedure "mlsys_message_mgr_" set ref 1404* 1404 relays 7 based varying char(256) array level 2 in structure "address_route" dcl 4-6 in procedure "mlsys_message_mgr_" set ref 1396* reply_references 54 based pointer level 3 dcl 2-15 set ref 300* 364* 366 367* 748 758* 1208* 1917 1925* 1927* reply_to 40 based pointer level 3 dcl 2-15 set ref 278* 279* 378 378* 1517* 1526* reserved 2 based bit(144) level 2 in structure "message_references_list" dcl 2-219 in procedure "mlsys_message_mgr_" set ref 298 301 791 792 797* 797 798 reserved 27(01) based bit(35) level 5 in structure "message_redistribution" packed unaligned dcl 2-122 in procedure "mlsys_message_mgr_" set ref 1166 reserved 2 based bit(144) level 2 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 249 252 254 257 260 383 383 383 386 435 435 465 466 470* 470 471 1056 1056 1760 1760 1814 1814 2002 2002 2043 2063 2080 2101 reserved 2 based bit(144) level 2 in structure "message_user_fields_list" dcl 2-150 in procedure "mlsys_message_mgr_" set ref 306 308 938 939 944* 944 945 reserved 5 based bit(36) level 2 in structure "the_preformatted_body_section" dcl 450 in procedure "add_body_section_internal" set ref 500* 506 reserved 5 based bit(36) level 2 in structure "message_bit_string_body_section" dcl 2-301 in procedure "mlsys_message_mgr_" set ref 1085 reserved 53(01) based bit(35) level 5 in structure "message" packed unaligned dcl 2-15 in procedure "mlsys_message_mgr_" set ref 293 369 1655 1671 reserved 2 based bit(144) level 2 in structure "message_trace" dcl 2-87 in procedure "mlsys_message_mgr_" set ref 1390* reserved 2 based bit(144) level 2 in structure "message_redistributions_list" dcl 2-109 in procedure "mlsys_message_mgr_" set ref 316 318 620 622 627* 627 628 reserved 5 based bit(36) level 2 in structure "the_bit_string_body_section" dcl 451 in procedure "add_body_section_internal" set ref 525* 533 reserved 5(01) based bit(35) level 4 in structure "message_text_user_field" packed unaligned dcl 2-183 in procedure "mlsys_message_mgr_" set ref 1291 reserved 11(01) based bit(35) level 4 in structure "message_reference" packed unaligned dcl 2-234 in procedure "mlsys_message_mgr_" set ref 1232 reserved 11(01) based bit(35) level 4 in structure "the_reference" packed unaligned dcl 775 in procedure "add_reference_internal" set ref 836 reserved 5(01) based bit(35) level 4 in structure "the_text_user_field" packed unaligned dcl 921 in procedure "add_user_field_internal" set ref 969* 981 reserved 27(01) based bit(35) level 5 in structure "the_redistribution" packed unaligned dcl 606 in procedure "add_redistribution_internal" set ref 682 reserved 5 based bit(36) level 2 in structure "message_preformatted_body_section" dcl 2-292 in procedure "mlsys_message_mgr_" set ref 1075 rest_of_text defined char unaligned dcl 2418 in begin block on line 2417 set ref 2420 2421 2423 2423 rest_of_text defined char unaligned dcl 2297 in begin block on line 2295 ref 2299 2300 result_string based char unaligned dcl 2326 in procedure "normalize_single_line_field" set ref 2357 2358* 2363 result_string based char unaligned dcl 2384 in procedure "normalize_multiline_field" set ref 2450 2451* 2456 2457 result_string_ptr 000104 automatic pointer dcl 2327 in procedure "normalize_single_line_field" set ref 2357* 2358 2363 result_string_ptr 000104 automatic pointer dcl 2385 in procedure "normalize_multiline_field" set ref 2450* 2451 2456 2457 return_value 000100 automatic pointer dcl 1-14 set ref 1-16* 1-18 ring1 0(04) 000124 automatic bit(1) level 3 packed unaligned dcl 145 set ref 1708 rtrim builtin function dcl 218 ref 2348 search builtin function dcl 218 ref 841 994 1680 section 4 based structure level 2 dcl 2-313 set ref 428 1749 1749 1757 1803 1803 1811 section_n_lines 65 based fixed bin(21,0) array level 5 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 548 550 1102 1104 section_n_lines 1 based fixed bin(21,0) level 3 in structure "the_body_section" dcl 449 in procedure "add_body_section_internal" set ref 518* 522* section_type based fixed bin(17,0) level 3 dcl 2-274 ref 498 1075 1085 2247 2247 sender 2 based pointer level 2 in structure "envelope" dcl 2147 in procedure "verify_envelope" set ref 2152 2152* sender 2 based pointer level 2 in structure "p_envelope" dcl 1445 in procedure "delete_envelope" set ref 1456 1456* sender 16 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 267* sender 2 based pointer level 2 in structure "target_envelope" dcl 1351 in procedure "set_envelope" set ref 1356 1357* 1357* 1358* sending_host 14 based varying char(256) array level 3 dcl 2-87 set ref 1409* 1409* 1417* 1417 source_envelope based structure level 1 dcl 1348 set ref 1354 stack_increment 000113 automatic fixed bin(18,0) dcl 2389 set ref 2392* 2394 2410* 2482* 2483 stackframeptr builtin function dcl 218 ref 2337 2360 2400 2453 2473 string builtin function dcl 218 set ref 264* 292* 477* 477 500* 525* 672* 827* 969* 1661* 1707* subject 12 based structure level 3 in structure "message_reference_parameter" dcl 2-248 in procedure "mlsys_message_mgr_" set ref 730* 1894* subject 6 based structure level 2 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" subject 6 based structure level 2 in structure "the_reference" dcl 775 in procedure "add_reference_internal" subject 50 based structure level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 730 1894 substr builtin function dcl 218 set ref 843 996 1682 2353 2353 2429 2451 2488* sys_info$max_seg_size 000014 external static fixed bin(19,0) dcl 185 ref 2408 2478 target_envelope based structure level 1 dcl 1351 set ref 1354* text 2 based structure level 2 in structure "the_text_user_field" dcl 921 in procedure "add_user_field_internal" text 2 based structure level 2 in structure "message_text_user_field" dcl 2-183 in procedure "mlsys_message_mgr_" text_lth 52 based fixed bin(21,0) level 4 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 291* 371 371 1657 1657 1665* 1669* 1677* 1678 1680 1681 1682 1682 1683 text_lth 26 based fixed bin(21,0) level 4 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 676* 679* 691* text_lth 4 based fixed bin(21,0) level 3 in structure "the_text_user_field" dcl 921 in procedure "add_user_field_internal" set ref 972* 975* 979* 990* 1000* text_lth 000126 automatic fixed bin(21,0) dcl 2287 in procedure "count_lines_in_text" set ref 2289* 2293 2297 text_lth 10 based fixed bin(21,0) level 3 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" ref 828 833 833 839 841 842 843 843 845 847 1235 1235 text_lth 4 based fixed bin(21,0) level 3 in structure "message_text_user_field" dcl 2-183 in procedure "mlsys_message_mgr_" ref 970 975 975 979 979 983 985 990 994 995 996 996 998 1000 1295 1295 text_lth 4 based fixed bin(21,0) level 2 in structure "message_preformatted_body_section" dcl 2-292 in procedure "mlsys_message_mgr_" ref 503 503 509 516 518 518 1079 1079 text_lth 26 based fixed bin(21,0) level 4 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" ref 674 679 679 684 691 1169 1169 text_lth 10 based fixed bin(21,0) level 3 in structure "the_reference" dcl 775 in procedure "add_reference_internal" set ref 830* 833* 847* text_lth 4 based fixed bin(21,0) level 2 in structure "the_preformatted_body_section" dcl 450 in procedure "add_body_section_internal" set ref 503* 516* text_ptr 24 based pointer level 4 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 675* 679* 690* text_ptr 50 based pointer level 4 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 290* 369 369 371 372* 1655 1655 1657 1658* 1664* 1669* 1675* 1676* 1676* 1678 1680 1681 1682 1682 1683 text_ptr 2 based pointer level 3 in structure "message_text_user_field" dcl 2-183 in procedure "mlsys_message_mgr_" set ref 970 975 979 983 985 989* 994 995 996 996 998 999* 1291 1291 1295 1296* text_ptr 2 based pointer level 3 in structure "the_text_user_field" dcl 921 in procedure "add_user_field_internal" set ref 971* 975* 979* 989* 999* text_ptr 6 based pointer level 3 in structure "the_reference" dcl 775 in procedure "add_reference_internal" set ref 829* 833* 846* text_ptr 6 based pointer level 3 in structure "message_reference" dcl 2-234 in procedure "mlsys_message_mgr_" set ref 828 833 839 841 842 843 843 845 846* 1232 1232 1235 1236* text_ptr 2 based pointer level 2 in structure "message_preformatted_body_section" dcl 2-292 in procedure "mlsys_message_mgr_" set ref 503 509 511 515* 1075 1075 1079 1080* text_ptr 2 based pointer level 2 in structure "the_preformatted_body_section" dcl 450 in procedure "add_body_section_internal" set ref 503* 515* 518 text_ptr 24 based pointer level 4 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" set ref 674 679 684 686 690* 1166 1166 1169 1170* text_used 000107 automatic fixed bin(21,0) dcl 2388 set ref 2413* 2415 2418 2420 2421 2423 2423 2425* 2425 2428 2429 2430* 2430 the_address_list_user_field based structure level 1 dcl 922 the_bit_string_body_section based structure level 1 dcl 451 the_body_section based structure level 1 dcl 449 the_character 000106 automatic char(1) dcl 2387 set ref 2429* 2432 2441 2441 2442 2443 2443 2443 2443 the_date_user_field based structure level 1 dcl 923 the_integer_user_field based structure level 1 dcl 924 the_preformatted_body_section based structure level 1 dcl 450 the_redistribution based structure level 1 dcl 606 the_redistribution_ptr 000102 automatic pointer dcl 608 set ref 648* 649 649 650 651 652 652 655 655 656 658 660 661 662 662 664 664 665 667 669 672 673 675 676 679 679 682 690 691 the_reference based structure level 1 dcl 775 set ref 817* the_reference_ptr 000102 automatic pointer dcl 777 set ref 816* 817 818 819 819 821 821 822 823 827 829 830 833 833 836 846 847 the_section_ptr 000102 automatic pointer dcl 453 set ref 496* 497 500 503 503 506 515 516 518 518 522 524 525 528 531 533 539 the_text_user_field based structure level 1 dcl 921 the_user_field based structure level 1 dcl 920 the_user_field_ptr 000102 automatic pointer dcl 926 set ref 963* 964 967 969 971 972 975 975 975 979 979 981 985 989 990 999 1000 1004 1006 1007 1007 1010 1011 1015 1019 to 42 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 281* 282* 377 377* 1536* 1545* to 22 based pointer level 3 in structure "redistribution" dcl 2173 in procedure "verify_redistribution" set ref 2183 2183* to 22 based pointer level 3 in structure "the_redistribution" dcl 606 in procedure "add_redistribution_internal" set ref 661 662* 662* 664* 664* 665* 667* 669* to 22 based pointer level 3 in structure "message_redistribution" dcl 2-122 in procedure "mlsys_message_mgr_" set ref 1163 1163* total_lines 62 based fixed bin(21,0) level 3 dcl 2-15 set ref 321* 481* 481 546* 547 548* 550* 550 554 554* 554 1100* 1101 1102* 1104* 1104 1108 1108* 1108 trace 4 based pointer level 2 in structure "p_envelope" dcl 1445 in procedure "delete_envelope" set ref 1454 1454* trace 20 based pointer level 3 in structure "message" dcl 2-15 in procedure "mlsys_message_mgr_" set ref 267* trace 4 based pointer level 2 in structure "envelope" dcl 2147 in procedure "verify_envelope" set ref 2154 2154* trace 4 based pointer level 2 in structure "target_envelope" dcl 1351 in procedure "set_envelope" set ref 1361* trace 4 based pointer level 2 in structure "source_envelope" dcl 1348 in procedure "set_envelope" set ref 1361 1361* translate builtin function dcl 218 ref 1417 1420 2348 type 3 based fixed bin(17,0) level 2 dcl 96 set ref 252* 383 435 1056 1760 1814 2002 2063 2101 used 000130 automatic fixed bin(21,0) dcl 2287 set ref 2291* 2293 2297 2299 2300 2303* 2303 user_field based structure level 1 dcl 2195 in procedure "verify_user_field" user_field 4 based structure level 2 in structure "message_user_field_parameter" dcl 2-208 in procedure "mlsys_message_mgr_" set ref 890 1968 1968 1988 user_fields 10 based structure array level 2 dcl 2-150 set ref 949* 949 959* 959 963 1289 1307* 1307 user_fields_list 56 based pointer level 3 dcl 2-15 set ref 304* 305 306 307 308 360 361* 896 938 939 944 947 949 952 953* 959 959 963 1023 1289 1307 1307 1310 1978 user_privileges 000124 automatic structure level 1 dcl 145 set ref 1707* value 2 based fixed bin(35,0) level 2 in structure "the_integer_user_field" dcl 924 in procedure "add_user_field_internal" set ref 1019* value 2 based fixed bin(35,0) level 2 in structure "message_integer_user_field" dcl 2-200 in procedure "mlsys_message_mgr_" ref 1019 verify builtin function dcl 218 ref 842 995 1681 2420 version based char(8) level 2 in structure "message" packed unaligned dcl 2-15 in procedure "mlsys_message_mgr_" set ref 247* 469* 2027 version 2 based char(8) level 2 in structure "message_envelope_parameter" packed unaligned dcl 2-74 in procedure "mlsys_message_mgr_" ref 1326 version based char(8) level 2 in structure "message_trace" packed unaligned dcl 2-87 in procedure "mlsys_message_mgr_" set ref 1389* 2120 version 2 based char(8) level 2 in structure "message_body_section_parameter" packed unaligned dcl 2-313 in procedure "mlsys_message_mgr_" ref 423 1744 1798 version based char(8) level 2 in structure "message_references_list" packed unaligned dcl 2-219 in procedure "mlsys_message_mgr_" set ref 297* 796* version based char(8) level 2 in structure "message_redistributions_list" packed unaligned dcl 2-109 in procedure "mlsys_message_mgr_" set ref 315* 626* version 2 based char(8) level 2 in structure "message_reference_parameter" packed unaligned dcl 2-248 in procedure "mlsys_message_mgr_" ref 736 1900 version based char(8) level 3 in structure "address_route" packed unaligned dcl 4-6 in procedure "mlsys_message_mgr_" ref 2126 version based char(8) level 2 in structure "message_user_fields_list" packed unaligned dcl 2-150 in procedure "mlsys_message_mgr_" set ref 305* 943* version 2 based char(8) level 2 in structure "message_user_field_parameter" packed unaligned dcl 2-208 in procedure "mlsys_message_mgr_" ref 885 1963 version 2 based char(8) level 2 in structure "message_redistribution_parameter" packed unaligned dcl 2-139 in procedure "mlsys_message_mgr_" ref 582 1844 work_string based char unaligned dcl 2380 in procedure "normalize_multiline_field" set ref 2451 2488* work_string based varying char dcl 2322 in procedure "normalize_single_line_field" set ref 2348* 2351 2353* 2353 2353 2354 2357 2357 2358 2358 2363 2364 work_string_lth 000100 automatic fixed bin(21,0) dcl 2381 in procedure "normalize_multiline_field" set ref 2394* 2405 2408* 2451 2472 2478* 2481 2483* 2483 2488 work_string_lth 000102 automatic fixed bin(21,0) dcl 2324 in procedure "normalize_single_line_field" set ref 2332* 2342 2346 2348 2353 work_string_ptr 000100 automatic pointer dcl 2323 in procedure "normalize_single_line_field" set ref 2334* 2337 2337 2337* 2343* 2346* 2348 2351 2353 2353 2353 2354 2357 2357 2358 2358 2360 2360* 2363 2364 work_string_ptr 000102 automatic pointer dcl 2382 in procedure "normalize_multiline_field" set ref 2397* 2400 2400 2400* 2406* 2410* 2451 2453 2453* 2473 2476* 2488 work_string_used 000101 automatic fixed bin(21,0) dcl 2381 set ref 2395* 2450 2450 2451 2451 2456 2457 2472 2475 2481 2488 2489* 2489 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. MESSAGE_DATE_USER_FIELD internal static fixed bin(17,0) initial dcl 2-174 address_list based structure level 1 dcl 3-6 address_list_n_addresses automatic fixed bin(17,0) dcl 3-16 address_route_n_relays automatic fixed bin(17,0) dcl 4-18 message_text_field_ptr automatic pointer dcl 2-270 message_text_field_text based char unaligned dcl 2-268 mlsys_data_$address_list_allocation external static fixed bin(17,0) dcl 5-33 mlsys_data_$domains_available external static fixed bin(1,0) dcl 5-44 mlsys_data_$forum_not_available external static fixed bin(1,0) dcl 5-44 mlsys_data_$hash_tables_segment_ptr external static pointer dcl 5-64 mlsys_data_$highest_usable_ring external static fixed bin(3,0) dcl 5-49 mlsys_data_$ism_not_available external static fixed bin(1,0) dcl 5-44 mlsys_data_$lowest_forum_ring external static fixed bin(3,0) dcl 5-49 mlsys_data_$mailbox_allocation external static fixed bin(17,0) dcl 5-33 mlsys_data_$max_lock_wait_retries external static fixed bin(17,0) dcl 5-19 mlsys_data_$max_opening_retries external static fixed bin(17,0) dcl 5-16 mlsys_data_$person_id external static varying char(24) dcl 5-70 mlsys_data_$project_id external static varying char(12) dcl 5-71 mlsys_data_$subsystem_ring external static fixed bin(3,0) dcl 5-49 mlsys_data_$temp_segment_list_ptr external static pointer dcl 5-54 mlsys_data_$transmit_cache_ptr external static pointer dcl 5-66 mlsys_data_$user_id external static varying char(32) dcl 5-72 mlsys_data_$user_is_anonymous external static bit(1) dcl 5-68 NAMES DECLARED BY EXPLICIT CONTEXT. ABORT_THE_OPERATION 010764 constant label dcl 2511 ref 2507 ADD_BODY_SECTION_COMMON 001671 constant label dcl 419 ref 401 409 ADD_REDISTRIBUTION_COMMON 002134 constant label dcl 578 ref 568 ADD_REPLY_REFERENCE_COMMON 002510 constant label dcl 734 ref 707 715 ADD_REPLY_REFERENCE_NO_RP_CHECK 002557 constant label dcl 742 ref 731 ADD_SECTION 000000 constant label array(2) dcl 500 ref 498 ADD_USER_FIELD 000002 constant label array(4) dcl 967 ref 965 ADD_USER_FIELD_COMMON 003065 constant label dcl 881 set ref 863 871 COPY_BIT_STRING 011420 constant label dcl 528 ref 536 COPY_PREFORMATTED_TEXT 011271 constant label dcl 503 ref 509 511 COPY_REDISTRIBUTION_COMMENT 012251 constant label dcl 679 ref 684 686 COPY_REFERENCED_SUBJECT 012724 constant label dcl 833 ref 839 841 842 843 845 COPY_SUBJECT_TEXT 006015 constant label dcl 1669 ref 1678 1680 1681 1682 1683 COPY_USER_FIELD_TEXT 013366 constant label dcl 975 ref 983 985 994 995 996 998 CREATE_MESSAGE_COMMON 000226 constant label dcl 236 ref 227 DELETE_BODY_SECTION_COMMON 003351 constant label dcl 1045 ref 1036 DELETE_REDISTRIBUTION_COMMON 003536 constant label dcl 1130 ref 1121 DELETE_REPLY_REFERENCE_COMMON 003712 constant label dcl 1199 ref 1190 DELETE_USER_FIELD_COMMON 004076 constant label dcl 1264 ref 1255 END_ADD_SECTION_CASE 011505 constant label dcl 542 ref 520 540 END_ADD_USER_FIELD_CASE 013676 constant label dcl 1023 ref 1002 1013 1017 1021 FREE_MESSAGE_COMMON 001037 constant label dcl 343 set ref 334 REPLACE_BODY_COMMON 006504 constant label dcl 1740 ref 1722 1730 REPLACE_BODY_SECTION_COMMON 007026 constant label dcl 1793 ref 1775 1783 REPLACE_REDISTRIBUTION_COMMON 007303 constant label dcl 1839 ref 1829 REPLACE_REPLY_REFERENCE_COMMON 007671 constant label dcl 1898 ref 1871 1879 REPLACE_REPLY_REFERENCE_NO_RP_CHECK 007740 constant label dcl 1906 ref 1895 REPLACE_SUBJECT_COMMON 005731 constant label dcl 1652 ref 1633 1641 1649 REPLACE_USER_FIELD_COMMON 010307 constant label dcl 1958 ref 1940 1948 abort_normalize_field 017667 constant entry internal dcl 2501 ref 2344 2407 2473 2477 add_body_section 001502 constant entry external dcl 396 add_body_section_internal 010774 constant entry internal dcl 446 ref 433 1758 1812 add_body_section_new 001623 constant entry external dcl 412 add_body_section_no_copy 001553 constant entry external dcl 404 add_redistribution 002016 constant entry external dcl 563 add_redistribution_internal 011554 constant entry internal dcl 603 ref 592 1858 add_redistribution_no_copy 002067 constant entry external dcl 571 add_reference_internal 012356 constant entry internal dcl 769 ref 758 1927 add_reply_reference 002246 constant entry external dcl 702 add_reply_reference_new 002367 constant entry external dcl 718 add_reply_reference_no_copy 002317 constant entry external dcl 710 add_to_work_string 017536 constant entry internal dcl 2465 ref 2423 2436 2441 add_user_field 002676 constant entry external dcl 858 add_user_field_internal 013067 constant entry internal dcl 917 ref 906 1989 add_user_field_new 003017 constant entry external dcl 874 add_user_field_no_copy 002747 constant entry external dcl 866 compute_position_for_add 016504 constant entry internal dcl 2262 ref 431 590 756 904 copy_ptr 017704 constant entry internal dcl 1-10 ref 343 419 515 539 578 655 664 690 725 742 821 846 881 989 999 1004 1045 1130 1199 1264 1323 1357 1364 1369 1392 1425 1495 1504 1516 1525 1535 1544 1556 1565 1575 1584 1610 1652 1676 1698 1740 1793 1839 1889 1906 1958 2043 count_lines_in_text 016532 constant entry internal dcl 2283 ref 518 create_im_message 000165 constant entry external dcl 223 create_new_message 000210 constant entry external dcl 230 delete_body_section 003242 constant entry external dcl 1032 delete_body_section_internal 013706 constant entry internal dcl 1067 ref 348 1054 1753 1810 delete_body_section_new 003307 constant entry external dcl 1039 delete_envelope 015303 constant entry internal dcl 1442 ref 381 1157 1334 delete_redistribution 003427 constant entry external dcl 1117 delete_redistribution_internal 014123 constant entry internal dcl 1149 ref 352 1139 1856 delete_redistribution_no_copy 003474 constant entry external dcl 1124 delete_reference_internal 014266 constant entry internal dcl 1218 ref 364 1208 1925 delete_reply_reference 003603 constant entry external dcl 1186 delete_reply_reference_new 003650 constant entry external dcl 1193 delete_trace 015374 constant entry internal dcl 1464 ref 1454 delete_user_field 003767 constant entry external dcl 1251 delete_user_field_internal 014410 constant entry internal dcl 1283 ref 358 1273 1987 delete_user_field_new 004034 constant entry external dcl 1258 free_message 000734 constant entry external dcl 330 free_message_new 000777 constant entry external dcl 337 mlsys_message_mgr_ 000143 constant entry external dcl 21 normalize_multiline_field 017150 constant entry internal dcl 2373 ref 503 679 975 normalize_single_line_field 016604 constant entry internal dcl 2315 ref 833 979 1669 replace_address_list_field 015475 constant entry internal dcl 1592 ref 1496 1505 1517 1526 1536 1545 1557 1566 1576 1585 replace_bcc_new 005430 constant entry external dcl 1580 replace_bcc_no_copy 005327 constant entry external dcl 1571 replace_body 006323 constant entry external dcl 1717 replace_body_new 006440 constant entry external dcl 1733 replace_body_no_copy 006372 constant entry external dcl 1725 replace_body_section 006637 constant entry external dcl 1770 replace_body_section_new 006760 constant entry external dcl 1786 replace_body_section_no_copy 006710 constant entry external dcl 1778 replace_cc_new 005226 constant entry external dcl 1561 replace_cc_no_copy 005125 constant entry external dcl 1552 replace_from_new 004420 constant entry external dcl 1500 replace_from_no_copy 004317 constant entry external dcl 1491 replace_message_envelope 004145 constant entry external dcl 1318 replace_redistribution 007165 constant entry external dcl 1824 replace_redistribution_no_copy 007236 constant entry external dcl 1832 replace_reply_reference 007427 constant entry external dcl 1866 replace_reply_reference_new 007550 constant entry external dcl 1882 replace_reply_reference_no_copy 007500 constant entry external dcl 1874 replace_reply_to_new 004622 constant entry external dcl 1521 replace_reply_to_no_copy 004521 constant entry external dcl 1512 replace_subject 005533 constant entry external dcl 1628 replace_subject_new 005660 constant entry external dcl 1644 replace_subject_no_copy 005606 constant entry external dcl 1636 replace_to_new 005024 constant entry external dcl 1540 replace_to_no_copy 004723 constant entry external dcl 1531 replace_user_field 010120 constant entry external dcl 1935 replace_user_field_new 010241 constant entry external dcl 1951 replace_user_field_no_copy 010171 constant entry external dcl 1943 set_access_class_new 006156 constant entry external dcl 1693 set_envelope 014540 constant entry internal dcl 1345 ref 649 1335 set_trace 014712 constant entry internal dcl 1379 ref 1361 verify_body_section 016463 constant entry internal dcl 2241 ref 429 1749 1803 verify_envelope 016106 constant entry internal dcl 2144 ref 1332 2178 verify_im_message 010615 constant entry external dcl 2038 verify_im_message_internal 015705 constant entry internal dcl 2054 ref 722 1886 2041 verify_message 010520 constant entry external dcl 1997 verify_message_internal 015641 constant entry internal dcl 2016 ref 333 399 407 566 574 705 713 861 869 1035 1120 1127 1189 1254 1321 1494 1515 1534 1555 1574 1631 1639 1720 1728 1773 1781 1827 1835 1869 1877 1938 1946 2000 2060 2098 verify_new_message 010705 constant entry external dcl 2075 verify_new_message_internal 015745 constant entry internal dcl 2092 ref 340 415 721 877 1042 1196 1261 1503 1524 1543 1564 1583 1647 1696 1736 1789 1885 1954 2078 verify_redistribution 016232 constant entry internal dcl 2170 ref 588 1849 verify_reference 016430 constant entry internal dcl 2222 ref 740 1904 verify_trace 016006 constant entry internal dcl 2112 ref 2154 verify_user_field 016327 constant entry internal dcl 2192 ref 891 1968 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 22744 23100 20775 22754 Length 24022 20775 134 705 1747 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mlsys_message_mgr_ 556 external procedure is an external procedure. add_body_section_internal 123 internal procedure enables or reverts conditions. on unit on line 458 76 on unit add_redistribution_internal 112 internal procedure enables or reverts conditions. on unit on line 613 76 on unit add_reference_internal 110 internal procedure enables or reverts conditions. on unit on line 784 76 on unit add_user_field_internal 110 internal procedure enables or reverts conditions. on unit on line 931 76 on unit delete_body_section_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. delete_redistribution_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. delete_reference_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. delete_user_field_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. set_envelope 102 internal procedure is called by several nonquick procedures. set_trace internal procedure shares stack frame of internal procedure set_envelope. delete_envelope internal procedure shares stack frame of external procedure mlsys_message_mgr_. delete_trace internal procedure shares stack frame of external procedure mlsys_message_mgr_. replace_address_list_field internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_message_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_im_message_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_new_message_internal internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_trace internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_envelope internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_redistribution internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_user_field internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_reference internal procedure shares stack frame of external procedure mlsys_message_mgr_. verify_body_section internal procedure shares stack frame of external procedure mlsys_message_mgr_. compute_position_for_add internal procedure shares stack frame of external procedure mlsys_message_mgr_. count_lines_in_text internal procedure shares stack frame of internal procedure add_body_section_internal. begin block on line 2295 begin block shares stack frame of internal procedure add_body_section_internal. normalize_single_line_field 100 internal procedure enables or reverts conditions, and is declared options(non_quick). on unit on line 2335 74 on unit normalize_multiline_field 134 internal procedure enables or reverts conditions, and is declared options(non_quick). on unit on line 2398 74 on unit begin block on line 2417 begin block shares stack frame of internal procedure normalize_multiline_field. add_to_work_string internal procedure shares stack frame of internal procedure normalize_multiline_field. abort_normalize_field 64 internal procedure is called by several nonquick procedures. copy_ptr 65 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME add_body_section_internal 000100 new_message_ptr add_body_section_internal 000102 the_section_ptr add_body_section_internal 000104 idx add_body_section_internal 000126 text_lth count_lines_in_text 000127 n_lines count_lines_in_text 000130 used count_lines_in_text 000131 idx count_lines_in_text add_redistribution_internal 000100 new_rl_ptr add_redistribution_internal 000102 the_redistribution_ptr add_redistribution_internal 000104 idx add_redistribution_internal add_reference_internal 000100 new_rl_ptr add_reference_internal 000102 the_reference_ptr add_reference_internal 000104 idx add_reference_internal add_user_field_internal 000100 new_ufl_ptr add_user_field_internal 000102 the_user_field_ptr add_user_field_internal 000104 idx add_user_field_internal copy_ptr 000100 return_value copy_ptr mlsys_message_mgr_ 000100 access_class mlsys_message_mgr_ 000102 position mlsys_message_mgr_ 000103 code mlsys_message_mgr_ 000104 new_message_info_ptr mlsys_message_mgr_ 000106 local_mrfp mlsys_message_mgr_ 000124 user_privileges mlsys_message_mgr_ 000125 message_type mlsys_message_mgr_ 000126 copy_subject mlsys_message_mgr_ 000127 copy_section_content mlsys_message_mgr_ 000130 copy_redistribution_data mlsys_message_mgr_ 000131 copy_reference_data mlsys_message_mgr_ 000132 copy_user_field_content mlsys_message_mgr_ 000133 idx mlsys_message_mgr_ 000134 message_ptr mlsys_message_mgr_ 000136 message_n_body_sections mlsys_message_mgr_ 000137 message_trace_n_relays mlsys_message_mgr_ 000140 message_n_redistributions mlsys_message_mgr_ 000141 message_n_user_fields mlsys_message_mgr_ 000142 message_references_list_n_references mlsys_message_mgr_ 000144 message_envelope_ptr mlsys_message_mgr_ 000146 message_envelope_parameter_ptr mlsys_message_mgr_ 000150 message_trace_ptr mlsys_message_mgr_ 000152 message_redistribution_ptr mlsys_message_mgr_ 000154 message_redistribution_parameter_ptr mlsys_message_mgr_ 000156 message_user_field_ptr mlsys_message_mgr_ 000160 message_user_field_parameter_ptr mlsys_message_mgr_ 000162 message_references_list_ptr mlsys_message_mgr_ 000164 message_reference_ptr mlsys_message_mgr_ 000166 message_reference_parameter_ptr mlsys_message_mgr_ 000170 message_body_section_ptr mlsys_message_mgr_ 000172 message_body_section_parameter_ptr mlsys_message_mgr_ 000174 address_list_ptr mlsys_message_mgr_ 000176 address_route_ptr mlsys_message_mgr_ 000242 idx delete_body_section_internal 000254 idx delete_redistribution_internal 000264 idx delete_reference_internal 000274 idx delete_user_field_internal 000312 idx delete_trace 000352 ignore verify_trace 000353 idx verify_trace 000364 ignore verify_envelope 000374 ignore verify_redistribution 000404 ignore verify_user_field 000414 ignore verify_reference normalize_multiline_field 000100 work_string_lth normalize_multiline_field 000101 work_string_used normalize_multiline_field 000102 work_string_ptr normalize_multiline_field 000104 result_string_ptr normalize_multiline_field 000106 the_character normalize_multiline_field 000107 text_used normalize_multiline_field 000110 column normalize_multiline_field 000111 n_spaces normalize_multiline_field 000112 idx normalize_multiline_field 000113 stack_increment normalize_multiline_field normalize_single_line_field 000100 work_string_ptr normalize_single_line_field 000102 work_string_lth normalize_single_line_field 000104 result_string_ptr normalize_single_line_field 000106 idx normalize_single_line_field set_envelope 000106 idx set_trace THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_cs call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return tra_ext mod_fx1 signal enable shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc clock THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. aim_check_$greater_or_equal cu_$grow_stack_frame freen_ get_authorization_ get_privileges_ mlsys_address_list_mgr_$copy_address_list mlsys_address_list_mgr_$create_read_only_address_list mlsys_address_list_mgr_$decrement_reference_count mlsys_address_list_mgr_$increment_reference_count mlsys_address_list_mgr_$set_read_only mlsys_address_list_mgr_$verify_address_list mlsys_address_mgr_$decrement_reference_count mlsys_address_mgr_$increment_reference_count mlsys_address_mgr_$verify_address mlsys_address_route_mgr_$create_address_route mlsys_address_route_mgr_$decrement_reference_count mlsys_address_route_mgr_$increment_reference_count mlsys_field_id_mgr_$get_user_field_name mlsys_nit_interface_$get_fully_qualified_name mlsys_nit_interface_$is_local_system mlsys_storage_mgr_$allocate mlsys_storage_mgr_$get_temp_segment mlsys_storage_mgr_$release_temp_segment THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$ai_restricted error_table_$bad_index error_table_$smallarg error_table_$unimplemented_version mlsys_data_$message_body_sections_allocation mlsys_data_$message_redistributions_list_allocation mlsys_data_$message_references_list_allocation mlsys_data_$message_user_fields_allocation mlsys_data_$subsystem_area_ptr mlsys_data_$valid_segments mlsys_et_$duplicate_reply_reference mlsys_et_$duplicate_user_field mlsys_et_$message_too_large mlsys_et_$not_in_mailbox_message mlsys_et_$not_message mlsys_et_$not_new_message mlsys_et_$unknown_body_section_type mlsys_et_$unknown_user_field_type sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 21 000142 24 000152 223 000160 226 000201 227 000203 230 000204 233 000224 236 000226 238 000234 239 000237 242 000246 245 000251 247 000274 249 000277 250 000301 252 000302 254 000304 255 000314 256 000316 257 000334 258 000337 259 000341 260 000342 262 000344 264 000350 266 000351 267 000354 269 000361 271 000364 273 000373 275 000376 276 000412 278 000422 279 000437 281 000447 282 000464 284 000474 285 000511 287 000521 288 000536 290 000546 291 000551 292 000552 293 000553 295 000555 296 000560 297 000603 298 000606 299 000610 300 000611 301 000613 303 000614 304 000617 305 000643 306 000646 307 000650 308 000651 310 000652 313 000660 314 000663 315 000707 316 000712 317 000714 318 000715 321 000716 323 000717 324 000720 326 000721 330 000730 333 000750 334 000774 337 000775 340 001013 343 001037 345 001047 347 001051 348 001057 349 001061 351 001064 352 001073 353 001075 354 001100 355 001130 357 001133 358 001141 359 001143 360 001146 361 001172 363 001175 364 001203 365 001216 366 001221 367 001245 369 001250 371 001265 372 001307 375 001312 376 001325 377 001341 378 001355 379 001371 381 001405 383 001412 386 001440 388 001443 390 001465 392 001466 396 001475 399 001522 400 001546 401 001550 404 001551 407 001573 408 001617 409 001620 412 001621 415 001643 416 001667 419 001671 421 001701 423 001704 424 001710 425 001713 428 001722 429 001724 431 001750 433 001763 435 001767 438 002000 439 002002 440 002004 442 002005 563 002014 566 002036 567 002062 568 002064 571 002065 574 002107 575 002133 578 002134 580 002144 582 002147 583 002153 584 002156 587 002165 588 002167 590 002213 592 002226 594 002232 595 002234 597 002235 702 002244 705 002266 706 002312 707 002314 710 002315 713 002337 714 002363 715 002364 718 002365 721 002407 722 002433 723 002457 725 002460 726 002470 727 002472 728 002477 729 002501 730 002503 731 002507 734 002510 736 002513 737 002517 738 002522 740 002531 742 002557 744 002567 747 002572 748 002603 750 002615 751 002617 752 002622 754 002631 756 002633 758 002646 760 002657 761 002661 763 002662 858 002671 861 002716 862 002742 863 002744 866 002745 869 002767 870 003013 871 003014 874 003015 877 003037 878 003063 881 003065 883 003075 885 003100 886 003104 887 003107 890 003116 891 003120 894 003144 895 003150 896 003161 897 003167 898 003171 899 003174 901 003203 904 003205 906 003220 908 003224 909 003226 911 003227 1032 003236 1035 003260 1036 003304 1039 003305 1042 003325 1045 003351 1047 003361 1049 003363 1050 003370 1051 003373 1054 003402 1056 003404 1059 003415 1061 003416 1117 003425 1120 003445 1121 003471 1124 003472 1127 003512 1130 003536 1132 003546 1134 003550 1135 003555 1136 003560 1139 003567 1141 003571 1143 003572 1186 003601 1189 003621 1190 003645 1193 003646 1196 003666 1199 003712 1201 003722 1203 003724 1204 003731 1205 003734 1208 003743 1210 003755 1212 003756 1251 003765 1254 004005 1255 004031 1258 004032 1261 004052 1264 004076 1266 004106 1268 004110 1269 004115 1270 004120 1273 004127 1275 004131 1277 004132 1318 004141 1321 004161 1323 004205 1324 004215 1326 004221 1327 004225 1328 004230 1331 004237 1332 004241 1334 004265 1335 004272 1337 004305 1339 004306 1491 004315 1494 004333 1495 004357 1496 004367 1497 004407 1500 004416 1503 004434 1504 004460 1505 004470 1506 004510 1512 004517 1515 004535 1516 004561 1517 004571 1518 004611 1521 004620 1524 004636 1525 004662 1526 004672 1527 004712 1531 004721 1534 004737 1535 004763 1536 004773 1537 005013 1540 005022 1543 005040 1544 005064 1545 005074 1546 005114 1552 005123 1555 005141 1556 005165 1557 005175 1558 005215 1561 005224 1564 005242 1565 005266 1566 005276 1567 005316 1571 005325 1574 005343 1575 005367 1576 005377 1577 005417 1580 005426 1583 005444 1584 005470 1585 005500 1586 005520 1628 005527 1631 005555 1632 005601 1633 005603 1636 005604 1639 005630 1640 005654 1641 005655 1644 005656 1647 005702 1648 005726 1649 005730 1652 005731 1655 005741 1657 005757 1658 006001 1661 006004 1663 006005 1664 006007 1665 006011 1666 006012 1668 006013 1669 006015 1671 006040 1672 006043 1675 006044 1676 006047 1677 006057 1678 006062 1680 006074 1681 006110 1682 006124 1683 006130 1684 006141 1686 006142 1688 006143 1693 006152 1696 006172 1698 006216 1699 006226 1701 006233 1703 006234 1707 006266 1708 006277 1710 006307 1713 006312 1717 006321 1720 006341 1721 006365 1722 006367 1725 006370 1728 006410 1729 006434 1730 006435 1733 006436 1736 006456 1737 006502 1740 006504 1742 006514 1744 006517 1745 006523 1746 006526 1749 006535 1752 006563 1753 006571 1754 006573 1756 006576 1757 006600 1758 006603 1760 006607 1763 006620 1764 006622 1766 006623 1770 006632 1773 006657 1774 006703 1775 006705 1778 006706 1781 006730 1782 006754 1783 006755 1786 006756 1789 007000 1790 007024 1793 007026 1795 007036 1796 007040 1798 007043 1799 007047 1800 007052 1803 007061 1805 007107 1806 007115 1807 007120 1810 007127 1811 007131 1812 007134 1814 007140 1817 007151 1818 007153 1820 007154 1824 007163 1827 007205 1828 007231 1829 007233 1832 007234 1835 007256 1836 007302 1839 007303 1841 007313 1842 007315 1844 007320 1845 007324 1846 007327 1849 007336 1851 007364 1852 007372 1853 007375 1856 007404 1857 007406 1858 007411 1860 007415 1862 007416 1866 007425 1869 007447 1870 007473 1871 007475 1874 007476 1877 007520 1878 007544 1879 007545 1882 007546 1885 007570 1886 007614 1887 007640 1889 007641 1890 007651 1891 007653 1892 007660 1893 007662 1894 007664 1895 007670 1898 007671 1900 007674 1901 007700 1902 007703 1904 007712 1906 007740 1908 007750 1910 007752 1911 007757 1912 007762 1916 007771 1917 010003 1919 010016 1920 010020 1921 010023 1923 010032 1925 010054 1926 010067 1927 010072 1929 010103 1931 010104 1935 010113 1938 010140 1939 010164 1940 010166 1943 010167 1946 010211 1947 010235 1948 010236 1951 010237 1954 010261 1955 010305 1958 010307 1960 010317 1961 010321 1963 010324 1964 010330 1965 010333 1968 010342 1970 010370 1971 010376 1972 010401 1976 010410 1977 010414 1978 010425 1980 010435 1981 010437 1982 010442 1984 010451 1987 010472 1988 010474 1989 010477 1991 010503 1993 010504 1997 010513 2000 010533 2002 010550 2006 010563 2007 010566 2010 010577 2038 010610 2041 010630 2043 010645 2045 010660 2048 010672 2075 010703 2078 010720 2080 010735 2083 010742 2086 010753 2511 010764 446 010773 456 011001 458 011003 460 011017 461 011046 462 011051 465 011052 466 011060 468 011064 469 011110 470 011113 471 011117 473 011121 474 011123 475 011125 476 011127 477 011131 478 011133 479 011136 480 011142 481 011145 482 011150 483 011157 484 011171 485 011173 486 011217 487 011222 491 011224 492 011235 493 011246 496 011251 497 011257 498 011264 500 011266 502 011267 503 011271 506 011320 508 011323 509 011324 511 011337 515 011350 516 011361 518 011366 520 011410 522 011411 524 011413 525 011415 527 011416 528 011420 531 011445 533 011456 535 011461 536 011462 539 011473 540 011504 542 011505 546 011510 547 011511 548 011526 550 011537 552 011540 554 011542 557 011552 603 011553 611 011561 613 011563 615 011577 616 011626 617 011631 620 011632 622 011641 625 011645 626 011671 627 011674 628 011701 630 011703 632 011705 633 011715 635 011727 636 011731 637 011756 638 011762 642 011764 643 011775 645 012006 648 012011 649 012020 650 012035 651 012043 652 012047 655 012066 656 012077 657 012107 658 012110 660 012124 661 012134 662 012141 664 012161 665 012172 666 012202 667 012203 669 012217 672 012227 673 012231 674 012233 675 012243 676 012245 677 012246 678 012247 679 012251 682 012300 683 012303 684 012304 686 012316 690 012327 691 012340 694 012345 696 012354 769 012355 780 012363 782 012370 784 012372 786 012406 787 012435 788 012440 791 012441 792 012450 795 012454 796 012500 797 012503 798 012507 801 012511 802 012513 803 012523 804 012534 805 012536 806 012562 807 012567 811 012571 812 012603 813 012613 816 012616 817 012624 818 012630 819 012634 821 012653 822 012664 823 012674 827 012704 828 012706 829 012716 830 012720 831 012721 832 012722 833 012724 836 012753 837 012756 839 012757 841 012771 842 013005 843 013021 845 013025 846 013036 847 013051 850 013056 852 013065 917 013066 929 013074 931 013076 933 013112 934 013141 935 013144 938 013145 939 013154 942 013160 943 013204 944 013207 945 013214 947 013216 948 013220 949 013227 951 013243 952 013245 953 013272 954 013276 958 013300 959 013311 960 013323 963 013326 964 013335 965 013342 967 013344 969 013350 970 013352 971 013360 972 013362 973 013363 974 013364 975 013366 979 013421 981 013447 982 013452 983 013453 985 013465 989 013505 990 013517 991 013524 994 013525 995 013541 996 013555 998 013561 999 013572 1000 013604 1002 013611 1004 013612 1006 013623 1007 013630 1010 013647 1011 013657 1013 013667 1015 013670 1017 013672 1019 013673 1021 013675 1023 013676 1026 013705 1067 013706 1073 013710 1075 013715 1079 013735 1080 013757 1083 013762 1085 013763 1089 014002 1090 014024 1093 014027 1094 014041 1095 014051 1097 014053 1100 014056 1101 014057 1102 014073 1104 014104 1106 014105 1108 014107 1111 014122 1149 014123 1155 014125 1157 014133 1160 014137 1163 014153 1166 014167 1169 014205 1170 014227 1173 014232 1174 014245 1176 014255 1178 014257 1180 014265 1218 014266 1226 014270 1227 014273 1229 014277 1232 014312 1235 014330 1236 014352 1239 014355 1240 014367 1241 014377 1243 014401 1245 014407 1283 014410 1289 014412 1291 014420 1295 014440 1296 014462 1299 014465 1301 014466 1306 014503 1307 014515 1308 014526 1310 014530 1312 014536 1345 014537 1354 014545 1356 014555 1357 014561 1358 014572 1361 014604 1363 014625 1364 014634 1365 014645 1368 014657 1369 014666 1370 014677 1373 014711 1379 014712 1385 014714 1387 014721 1389 014751 1390 014754 1392 014760 1393 014773 1396 015017 1398 015050 1399 015055 1403 015073 1404 015105 1405 015120 1409 015145 1412 015161 1415 015176 1417 015177 1420 015222 1423 015243 1424 015244 1425 015254 1427 015265 1430 015300 1432 015302 1442 015303 1448 015305 1451 015322 1454 015340 1456 015355 1458 015373 1464 015374 1470 015376 1472 015401 1473 015411 1475 015430 1477 015432 1480 015446 1481 015471 1483 015474 1592 015475 1599 015477 1600 015503 1602 015517 1603 015523 1605 015524 1606 015544 1607 015550 1608 015563 1609 015567 1610 015570 1613 015600 1616 015614 1617 015617 1618 015626 1620 015636 1622 015640 2016 015641 2022 015643 2024 015653 2027 015671 2030 015700 2032 015701 2054 015705 2060 015707 2063 015726 2066 015737 2068 015740 2092 015745 2098 015747 2101 015766 2104 016000 2106 016001 2112 016006 2120 016010 2124 016022 2126 016023 2130 016037 2131 016052 2135 016077 2138 016101 2144 016106 2152 016110 2154 016132 2156 016155 2159 016201 2162 016225 2170 016232 2178 016234 2180 016252 2183 016276 2186 016322 2192 016327 2201 016331 2202 016355 2204 016363 2209 016376 2214 016423 2222 016430 2230 016432 2233 016455 2235 016456 2241 016463 2247 016465 2251 016477 2253 016500 2262 016504 2267 016506 2270 016513 2273 016523 2277 016531 2283 016532 2289 016543 2291 016544 2293 016546 2297 016551 2299 016554 2300 016570 2302 016574 2303 016575 2305 016576 2307 016577 2315 016603 2332 016617 2334 016620 2335 016622 2337 016636 2340 016665 2342 016666 2343 016671 2344 016703 2345 016715 2346 016716 2348 016736 2351 017003 2352 017016 2353 017020 2354 017051 2355 017064 2357 017065 2358 017107 2360 017116 2363 017141 2364 017144 2366 017146 2373 017147 2392 017163 2394 017171 2395 017173 2397 017174 2398 017176 2400 017212 2403 017241 2405 017242 2406 017245 2407 017257 2408 017271 2409 017275 2410 017276 2412 017312 2413 017314 2415 017315 2418 017321 2420 017324 2421 017341 2423 017345 2424 017354 2425 017360 2428 017364 2429 017366 2430 017374 2432 017375 2433 017400 2435 017410 2436 017413 2437 017417 2438 017421 2441 017422 2442 017430 2443 017442 2448 017454 2450 017455 2451 017477 2453 017505 2456 017530 2457 017533 2459 017535 2465 017536 2472 017540 2473 017544 2475 017567 2476 017572 2477 017604 2478 017616 2479 017622 2481 017623 2482 017631 2483 017647 2484 017652 2488 017653 2489 017664 2491 017665 2501 017666 2506 017674 2507 017700 1 10 017703 1 16 017711 1 18 017715 ----------------------------------------------------------- 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