idnits 2.17.1 draft-liu-anima-grasp-api-02.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- No issues found here. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year -- The document date (September 30, 2016) is 2764 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) == Outdated reference: A later version (-15) exists of draft-ietf-anima-grasp-07 == Outdated reference: A later version (-10) exists of draft-ietf-anima-reference-model-02 == Outdated reference: A later version (-13) exists of draft-liu-anima-grasp-distribution-02 -- Obsolete informational reference (is this intentional?): RFC 7749 (Obsoleted by RFC 7991) Summary: 0 errors (**), 0 flaws (~~), 4 warnings (==), 2 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 Network Working Group B. Carpenter 3 Internet-Draft Univ. of Auckland 4 Intended status: Standards Track B. Liu, Ed. 5 Expires: April 3, 2017 Huawei Technologies 6 W. Wang 7 X. Gong 8 BUPT University 9 September 30, 2016 11 Generic Autonomic Signaling Protocol Application Program Interface 12 (GRASP API) 13 draft-liu-anima-grasp-api-02 15 Abstract 17 This document specifies the application programming interface (API) 18 of the Generic Autonomic Signaling Protocol (GRASP). The API is used 19 for Autonomic Service Agents (ASA) calling the GRASP protocol module 20 to communicate autonomic network signalings with other ASAs. 22 Status of This Memo 24 This Internet-Draft is submitted in full conformance with the 25 provisions of BCP 78 and BCP 79. 27 Internet-Drafts are working documents of the Internet Engineering 28 Task Force (IETF). Note that other groups may also distribute 29 working documents as Internet-Drafts. The list of current Internet- 30 Drafts is at http://datatracker.ietf.org/drafts/current/. 32 Internet-Drafts are draft documents valid for a maximum of six months 33 and may be updated, replaced, or obsoleted by other documents at any 34 time. It is inappropriate to use Internet-Drafts as reference 35 material or to cite them other than as "work in progress." 37 This Internet-Draft will expire on April 3, 2017. 39 Copyright Notice 41 Copyright (c) 2016 IETF Trust and the persons identified as the 42 document authors. All rights reserved. 44 This document is subject to BCP 78 and the IETF Trust's Legal 45 Provisions Relating to IETF Documents 46 (http://trustee.ietf.org/license-info) in effect on the date of 47 publication of this document. Please review these documents 48 carefully, as they describe your rights and restrictions with respect 49 to this document. Code Components extracted from this document must 50 include Simplified BSD License text as described in Section 4.e of 51 the Trust Legal Provisions and are provided without warranty as 52 described in the Simplified BSD License. 54 Table of Contents 56 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2 57 2. GRASP API for ASA . . . . . . . . . . . . . . . . . . . . . . 3 58 2.1. Design Principles . . . . . . . . . . . . . . . . . . . . 3 59 2.2. API definition . . . . . . . . . . . . . . . . . . . . . 4 60 2.2.1. Parameters and data structures . . . . . . . . . . . 4 61 2.2.2. Registration . . . . . . . . . . . . . . . . . . . . 6 62 2.2.3. Discovery . . . . . . . . . . . . . . . . . . . . . . 8 63 2.2.4. Negotiation . . . . . . . . . . . . . . . . . . . . . 9 64 2.2.5. Synchronization and Flooding . . . . . . . . . . . . 13 65 3. Example Logic Flows . . . . . . . . . . . . . . . . . . . . . 17 66 4. Security Considerations . . . . . . . . . . . . . . . . . . . 18 67 5. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 18 68 6. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . 18 69 7. References . . . . . . . . . . . . . . . . . . . . . . . . . 18 70 7.1. Normative References . . . . . . . . . . . . . . . . . . 18 71 7.2. Informative References . . . . . . . . . . . . . . . . . 18 72 Appendix A. Change log [RFC Editor: Please remove] . . . . . . . 19 73 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 19 75 1. Introduction 77 As defined in [I-D.ietf-anima-reference-model] , the Autonomic 78 Serveice Agent (ASA) is the atomic entity of an autonomic function; 79 and it is instantiated on autonomic nodes. When ASAs communicate 80 with each other, they should use the Generic Autonomic Signaling 81 Protocol (GRASP) [I-D.ietf-anima-grasp]. 83 As the following figure shows, the GRASP could contain two major sub- 84 layers. The bottom is the GRASP base protocol module, which is only 85 responsible for sending and recieving GRASP messages. The upper 86 layer is some extended functions based upon GRASP basic protocol. 87 For example, [I-D.liu-anima-grasp-distribution] is one of the 88 extended functions. 90 It is desirable that ASAs can be designed as portable user-space 91 programs using a portable API. In many operating systems, the GRASP 92 module will therefore be split into two layers, one being a library 93 that provides the API and the other being kernel code containing 94 common components such as multicast handling and the discovery cache. 95 The details of this are system-dependent. 97 +----+ +----+ 98 |ASAs| |ASAs| 99 +----+ +----+ 100 | | 101 | GRASP Function API | 102 | | 103 +------------------+ |GRASP API 104 | GRASP Extended | | 105 | Function Modules | | 106 +------------------+ | 107 +------------------------------------------+ 108 | GRASP Library | 109 | GRASP Module - - - - - - - - - - - - - -| 110 | GRASP Kernel | 111 +------------------------------------------+ 113 Both the GRASP base module and the extended function modules should 114 be available to the ASAs. Thus, there needs to be two sub-sets of 115 API. However, since the extended functions are expected to be added 116 in an incremental manner, it is inappropriate to define the function 117 APIs in a single document. This document only defines the base GRASP 118 API. 120 2. GRASP API for ASA 122 2.1. Design Principles 124 The assumption of this document is that any Autonomic Service Agent 125 (ASA) needs to call a GRASP module that handles protocol details 126 (security, sending and listening for GRASP messages, waiting, caching 127 discovery results, negotiation looping, sending and receiving 128 sychronization data, etc.) but understands nothing about individual 129 objectives. So this is a high level abstract API for use by ASAs. 130 Individual language bindings should be defined in separate documents. 132 An assumption of this API is that ASAs may fall into various classes: 134 o ASAs that only use GRASP for discovery purposes. 136 o ASAs that use GRASP negotiation but only as an initiator (client). 138 o ASAs that use GRASP negotiation but only as a responder. 140 o ASAs that use GRASP negotiation as an initiator or responder. 142 o ASAs that use GRASP synchronization but only as an initiator 143 (recipient). 145 o ASAs that use GRASP synchronization but only as a responder and/or 146 flooder. 148 o ASAs that use GRASP synchronization as an initiator, responder 149 and/or flooder. 151 The API also assumes that one ASA may support multiple objectives. 152 Nothing prevents an ASA from supporting some objectives for 153 synchronization and others for negotiation. 155 This is a preliminary version. Two particular gaps exist: 157 o Authorization of ASAs is out of scope. 159 o The Rapid mode of GRASP is not supported. 161 2.2. API definition 163 2.2.1. Parameters and data structures 165 Wherever a 'timeout' parameter appears, it is an integer expressed in 166 milliseconds. If it is zero, the GRASP default timeout 167 (GRASP_DEF_TIMEOUT, see [I-D.ietf-anima-grasp]) will apply. If no 168 response is received before the timeout expires, the call will fail 169 unless otherwise noted. 171 An 'objective' parameter is a data structure with the following 172 components: 174 o name (UTF-8 string) - the objective's name 176 o neg (Boolean) - True if objective supports negotiation (default 177 False) 179 o synch (Boolean) - True if objective supports synchronization 180 (default False) 182 o loop_count (integer) - Limit on negotiation steps etc. (default 183 GRASP_DEF_LOOPCT, see [I-D.ietf-anima-grasp]) 185 o value - a specific data structure expressing the value of the 186 objective. The format is language dependent, with the constraint 187 that it can be validly represented in CBOR (default integer = 0). 189 An 'ASA_locator' parameter is a data structure with the following 190 contents: 192 o locator - The actual locator, either an IP address or an ASCII 193 string. 195 o ifi (integer) - The interface identifier index via which this was 196 discovered - probably no use to a normal ASA 198 o expire (system dependent type) - The time on the local system 199 clock when this locator will expire from the cache 201 o is_ipaddress (Boolean) - True if the locator is an IP address 203 o is_fqdn (Boolean) - True if the locator is an FQDN 205 o is_uri (Boolean) - True if the locator is a URI 207 o diverted (Boolean) - True if the locator was discovered via a 208 Divert option 210 o protocol (integer) - Applicable transport protocol (IPPROTO_TCP or 211 IPPROTO_UDP) 213 o port (integer) - Applicable port number 215 A 'tagged_objective' parameter is a data structure with the following 216 contents: 218 o objective - An objective 220 o source - The ASA_locator from which the objective came 222 In most calls, an 'asa_nonce' parameter is required. It is generated 223 when an ASA registers with GRASP, and any call in which an invalid 224 nonce is presented will fail. It is an up to 24-bit opaque value 225 (for example represented as a uint32_t, depending on the language). 226 It should be unpredictable; a possible implementation is to use the 227 same mechanism that GRASP uses to generate Session IDs 228 [I-D.ietf-anima-grasp]. Another possible implementation is to hash 229 the name of the ASA with a locally defined secret key. 231 In some calls, a 'session_nonce' parameter is required. This is an 232 opaque data structure as far as the ASA is concerned, used to 233 identify calls to the API as belonging to a specific GRASP session. 234 In fully threaded implementations this parameter might not be needed, 235 but it is included to act as a session handle if necessary. It will 236 also allow GRASP to detect and ignore malicious calls or calls from 237 timed-out sessions. A possible implementation is to form the nonce 238 from the underlying GRASP Session ID and the source address of the 239 session. 241 Other parameters are described in the following sections. 243 2.2.2. Registration 245 These functions are used to register an ASA and the objectives that 246 it supports with the GRASP module. If an authorization model is 247 added to GRASP, it would be added here. 249 o register_asa() 251 Input parameter: 253 name of the ASA (UTF-8 string) 255 Return parameters: 257 success (Boolean) 259 result 261 if success: asa_nonce (integer) 263 if not success: error message (UTF-8 string) 265 This initialises state in the GRASP module for the calling 266 entity (the ASA). In the case of success, an 'asa_nonce' is 267 returned which the ASA must present in all subsequent calls. 268 In the case of failure, the ASA has not been authorized and 269 cannot operate. 271 o deregister_asa() 273 Input parameters: 275 asa_nonce (integer) 277 name of the ASA (UTF-8 string) 279 Return parameters: 281 success (Boolean) 283 result 285 if success: none 287 if not success: error message (UTF-8 string) 289 This removes all state in the GRASP module for the calling 290 entity (the ASA), and deregisters any objectives it has 291 registered. Note that these actions must also happen 292 automatically if an ASA crashes. 294 Note - the ASA name is strictly speaking redundant in this 295 call, but is present for clarity. 297 o register_objective() 299 Input parameters: 301 asa_nonce (integer) 303 objective (structure) 305 ttl (integer - default GRASP_DEF_TIMEOUT) 307 discoverable (Boolean - default False) 309 overlap (Boolean - default False) 311 local (Boolean - default False) 313 Return parameters: 315 success (Boolean) 317 result 319 if success: none 321 if not success: error message (UTF-8 string) 323 This registers an objective that this ASA supports and may 324 modify. The 'objective' becomes a candidate for discovery. 325 However, discovery responses should not be enabled until the 326 ASA calls listen_negotiate() or listen_synchronize(), showing 327 that it is able to act as a responder. The ASA may negotiate 328 the objective or send synchronization or flood data. 329 Registration is not needed if the ASA only wants to receive 330 synchronization or flood data for the objective concerned. 332 The 'ttl' parameter is the valid lifetime (time to live) in 333 milliseconds of any discovery response for this objective. The 334 default value should be the GRASP default timeout 335 (GRASP_DEF_TIMEOUT, see [I-D.ietf-anima-grasp]). 337 If the optional parameter 'discoverable' is True, the objective 338 is immediately discoverable. This is intended for objectives 339 that are only defined for GRASP discovery, and which do not 340 support negotiation or synchronization. 342 If the optional parameter 'overlap' is True, more than one ASA 343 may register this objective in the same GRASP instance. 345 If the optional parameter 'local' is True, discovery must 346 return a link-local address. This feature is for objectives 347 that must be restricted to the local link. 349 This call may be repeated for multiple objectives. 351 o deregister_objective() 353 Input parameters: 355 asa_nonce (integer) 357 objective (structure) 359 Return parameters: 361 success (Boolean) 363 result 365 if success: none 367 if not success: error message (UTF-8 string) 369 The 'objective' must have been registered by the calling ASA; 370 if not, this call fails. Otherwise, it removes all state in 371 the GRASP module for the given objective. 373 2.2.3. Discovery 375 o discover() 377 Input parameters: 379 asa_nonce (integer) 381 objective (structure) 383 timeout (integer) 384 flush (Boolean - default False) 386 Return parameters: 388 locator_list (structure) 390 This returns a list of discovered 'ASA_locator's for the given 391 objective. If the optional parameter 'flush' is True, any 392 locally cached locators for the objective are deleted first. 393 Otherwise, they are returned immediately. If not, GRASP 394 discovery is performed, and all results obtained before the 395 timeout expires are returned. If no results are obtained, an 396 empty list is returned after the timeout. 398 This should be called in a separate thread if asynchronous 399 operation is required. 401 2.2.4. Negotiation 403 o request_negotiate() 405 Input parameters: 407 asa_nonce (integer) 409 objective (structure) 411 peer (ASA_locator) 413 timeout (integer) 415 Return parameters: 417 success (Boolean) 419 session_nonce (structure) 421 result 423 if success: objective (structure) 425 if not success: error message (UTF-8 string) 427 This function opens a negotiation session. The 'objective' 428 parameter must include the requested value, and its loop count 429 should be set to a suitable value by the ASA. If not, the 430 GRASP default will apply. 432 The 'peer' parameter is the target node; it must be an 433 'ASA_locator' as returned by discover(). If the peer is null, 434 GRASP discovery is performed first. 436 If the 'success' parameter is 'true', the negotiation has 437 successfully started. There are then two cases: 439 1. The 'session_nonce' parameter is null. In this case the 440 negotiation has succeeded (the peer has accepted the 441 request). The returned objective contains the value 442 accepted by the peer. 444 2. The 'session_nonce' parameter is not null. In this case 445 negotiation must continue. The returned objective contains 446 the first value proffered by the negotiation peer. Note 447 that this instance of the objective must be used in the 448 subsequent negotiation call because it also contains the 449 current loop count. The 'session_nonce' must be presented 450 in all subsequent negotiation steps. 452 This function must be followed by calls to 'negotiate_step' 453 and/or 'negotiate_wait' and/or 'end_negotiate' until the 454 negotiation ends. 'request_negotiate' may then be called 455 again to start a new negotation. 457 If the 'success' parameter is 'false', the negotiation has 458 failed for the reason given in the result parameter. An 459 exponential backoff is recommended before any retry. 461 This should be called in a separate thread if asynchronous 462 operation is required. 464 Special note for the ACP infrastructure ASA: It is likely that 465 this ASA will need to discover and negotiate with its peers in 466 each of its on-link neighbors. It will therefore need to know 467 not only the link-local IP address but also the physical 468 interface and transport port for connecting to each neighbor. 469 One implementation approach to this is to include these details 470 in the 'session_nonce' data structure, which is opaque to 471 normal ASAs. 473 o listen_negotiate() 475 Input parameters: 477 asa_nonce (integer) 479 objective (structure) 481 Return parameters: 483 success (Boolean) 485 result 487 if success: session_nonce (structure) 489 if not success: error message (UTF-8 string) 491 requested_objective (structure) 493 This function instructs GRASP to listen for negotiation 494 requests for the given 'objective'. It also enables discovery 495 responses for the objective. It will block waiting for an 496 incoming request, so should be called in a separate thread if 497 asynchronous operation is required. Unless there is an 498 unexpected failure, this call only returns after an incoming 499 negotiation request. When it does so, 'requested_objective' 500 contains the first value requested by the negotiation peer. 501 Note that this instance of the objective must be used in the 502 subsequent negotiation call because it also contains the 503 current loop count. The 'session_nonce' must be presented in 504 all subsequent negotiation steps. 506 This function must be followed by calls to 'negotiate_step' 507 and/or 'negotiate_wait' and/or 'end_negotiate' until the 508 negotiation ends. 'listen_negotiate' may then be called again 509 to await a new negotation. 511 If an ASA is capable of handling multiple negotiations 512 simultaneously, it may call 'listen_negotiate' simultaneously 513 from multiple threads. The API and GRASP implementation must 514 support re-entrant use of the listening state and the 515 negotiation calls. Simultaneous sessions will be distinguished 516 by the threads themselves, the GRASP Session IDs, and the 517 underlying unicast transport sockets. 519 o stop_listen_negotiate() 521 Input parameters: 523 asa_nonce (integer) 525 objective (structure) 527 Return parameters: 529 success (Boolean) 531 result 533 if success: null 535 if not success: error message (UTF-8 string) 537 Instructs GRASP to stop listening for negotiation requests for 538 the given objective, i.e., cancels 'listen_negotiate'. Of 539 course, it must be called from a different thread. 541 o negotiate_step() 543 Input parameters: 545 asa_nonce (integer) 547 session_nonce (structure) 549 objective (structure) 551 timeout (integer) 553 Return parameters: 555 Exactly as for 'request_negotiate' 557 Executes the next negotation step with the peer. The 558 'objective' parameter contains the next value being proffered 559 by the ASA in this step. 561 o negotiate_wait() 563 Input parameters: 565 asa_nonce (integer) 567 session_nonce (structure) 569 timeout (integer) 571 Return parameters: 573 success (Boolean) 575 result 576 if success: null 578 if not success: error message (UTF-8 string) 580 Delay negotiation session by 'timeout' milliseconds. 582 o end_negotiate() 584 Input parameters: 586 asa_nonce (integer) 588 session_nonce (structure) 590 reply (Boolean) 592 reason (UTF-8 string) 594 Return parameters: 596 success (Boolean) 598 result 600 if success: null 602 if not success: error message (UTF-8 string) 604 End the negotiation session. 606 'reply' = True for accept (successful negotiation), False for 607 decline (failed negotiation). 609 'reason' = optional string describing reason for decline. 611 2.2.5. Synchronization and Flooding 613 o synchronize() 615 Input parameters: 617 asa_nonce (integer) 619 objective (structure) 621 peer (ASA_locator) 623 timeout (integer) 625 Return parameters: 627 success (Boolean) 629 result 631 if success: objective (structure) 633 if not success: error message (UTF-8 string) 635 This call requests the synchronized value of the given 636 'objective'. 638 Since this is essentially a read operation, any ASA can do it. 639 Therefore the API checks that the ASA is registered but the 640 objective doesn't need to be registered by the calling ASA. 642 If the objective was already flooded, the flooded value is 643 returned immediately in the 'result' parameter. In this case, 644 the 'source' and 'timeout' are ignored. 646 Otherwise, synchronization with a discovered ASA is performed. 647 The 'peer' parameter is an 'ASA_locator' as returned by 648 discover(). If 'peer' is null, GRASP discovery is performed 649 first. 651 This call should be repeated whenever the latest value is 652 needed. 654 Call in a separate thread if asynchronous operation is 655 required. 657 Since this is essentially a read operation, any ASA can use it. 658 Therefore GRASP checks that the calling ASA is registered but 659 the objective doesn't need to be registered by the calling ASA. 661 In the case of failure, an exponential backoff is recommended 662 before retrying. 664 o listen_synchronize() 666 Input parameters: 668 asa_nonce (integer) 670 objective (structure) 672 Return parameters: 674 success (Boolean) 676 result 678 if success: null 680 if not success: error message (UTF-8 string) 682 This instructs GRASP to listen for synchronization requests for 683 the given objective, and to respond with the value given in the 684 'objective' parameter. It also enables discovery responses for 685 the objective. 687 This call is non-blocking and may be repeated whenever the 688 value changes. 690 o stop_listen_synchronize() 692 Input parameters: 694 asa_nonce (integer) 696 objective (structure) 698 Return parameters: 700 success (Boolean) 702 result 704 if success: null 706 if not success: error message (UTF-8 string) 708 This call instructs GRASP to stop listening for synchronization 709 requests for the given 'objective', i.e. it cancels a previous 710 listen_synchronize. 712 o flood() 714 Input parameters: 716 asa_nonce (integer) 718 locator (structure - default null) 720 ttl (integer) 721 objectives (structure) 723 Return parameters: 725 success (Boolean) 727 result 729 if success: null 731 if not success: error message (UTF-8 string) 733 This call instructs GRASP to flood the given synchronization 734 objective(s) and their value(s) to all GRASP nodes. 736 The 'locator' parameter is normally null but may be a valid 737 'ASA_locator'. Infrastructure ASAs needing to flood an 738 {address, protocol, port} 3-tuple with an objective create an 739 ASA_locator object to do so. If the IP address in that locator 740 is the unspecified address ('::') it is replaced by the link- 741 local address of the sending node in each copy of the flood 742 multicast, which will be forced to have a loop count of 1. 743 This feature is for objectives that must be restricted to the 744 local link. 746 The 'ttl' parameter is the valid lifetime (time to live) of the 747 flooded data in milliseconds (0 = infinity) 749 The 'objectives' parameter is a list of one or more objectives. 751 Checks that the ASA registered each objective. 753 This call may be repeated whenever any value changes. 755 o get_flood() 757 Input parameters: 759 asa_nonce (integer) 761 objective (structure) 763 Return parameters: 765 success (Boolean) 767 result 768 if success: tagged_objective_list (structure) 770 if not success: error message (UTF-8 string) 772 This call instructs GRASP to return the given synchronization 773 objective if it has been flooded and its lifetime has not 774 expired. 776 Since this is essentially a read operation, any ASA can do it. 777 Therefore the API checks that the ASA is registered but the 778 objective doesn't need to be registered by the calling ASA. 780 The 'tagged_objective_list' parameter is a list of 781 'tagged_objective' couplets, each one being a copy of the 782 flooded objective and a coresponding locator. Thus if the same 783 objective has been flooded by multiple ASAs, the recipient can 784 distinguish the copies. 786 Note that this call is for advanced ASAs. In a simple case, an 787 ASA can simply call synchronize() in order to get a valid 788 flooded objective. 790 o expire_flood() 792 Input parameters: 794 asa_nonce (integer) 796 tagged_objective (structure) 798 Return parameters: 800 None 802 This is a call that can only be used after a preceding call to 803 get_flood() by an ASA that is capable of deciding that the 804 flooded value is stale or invalid. Use with care. 806 The 'tagged_objective' parameter is the one to be expired. 808 3. Example Logic Flows 810 TBD 812 (Until this section is written, some Python examples can be found at 813 , 814 , and 815 .) 817 4. Security Considerations 819 Security issues for the GRASP protocol are discussed in 820 [I-D.ietf-anima-grasp]. Authorization of ASAs is a subject for 821 future study. 823 The 'asa_nonce' parameter is used in the API as a first line of 824 defence against a malware process attempting to imitate a 825 legitimately registered ASA. The 'session_nonce' parameter is used 826 in the API as a first line of defence against a malware process 827 attempting to hijack a GRASP session. 829 5. IANA Considerations 831 This does not need IANA assignment. 833 6. Acknowledgements 835 This document was produced using the xml2rfc tool [RFC7749]. 837 7. References 839 7.1. Normative References 841 [I-D.ietf-anima-grasp] 842 Bormann, C., Carpenter, B., and B. Liu, "A Generic 843 Autonomic Signaling Protocol (GRASP)", draft-ietf-anima- 844 grasp-07 (work in progress), September 2016. 846 7.2. Informative References 848 [I-D.ietf-anima-reference-model] 849 Behringer, M., Carpenter, B., Eckert, T., Ciavaglia, L., 850 Pierre, P., Liu, B., Nobre, J., and J. Strassner, "A 851 Reference Model for Autonomic Networking", draft-ietf- 852 anima-reference-model-02 (work in progress), July 2016. 854 [I-D.liu-anima-grasp-distribution] 855 Liu, B. and S. Jiang, "Information Distribution over 856 GRASP", draft-liu-anima-grasp-distribution-02 (work in 857 progress), September 2016. 859 [RFC7749] Reschke, J., "The "xml2rfc" Version 2 Vocabulary", 860 RFC 7749, DOI 10.17487/RFC7749, February 2016, 861 . 863 Appendix A. Change log [RFC Editor: Please remove] 865 draft-liu-anima-grasp-api-02, 2016-09-30: 867 Added items for draft-ietf-anima-grasp-07 869 Editorial corrections 871 draft-liu-anima-grasp-api-01, 2016-06-24: 873 Updated for draft-ietf-anima-grasp-05 875 Editorial corrections 877 draft-liu-anima-grasp-api-00, 2016-04-04: 879 Initial version 881 Authors' Addresses 883 Brian Carpenter 884 Department of Computer Science 885 University of Auckland 886 PB 92019 887 Auckland 1142 888 New Zealand 890 Email: brian.e.carpenter@gmail.com 892 Bing Liu (editor) 893 Huawei Technologies 894 Q14, Huawei Campus 895 No.156 Beiqing Road 896 Hai-Dian District, Beijing 100095 897 P.R. China 899 Email: leo.liubing@huawei.com 901 Wendong Wang 902 BUPT University 903 Beijing University of Posts & Telecom. 904 No.10 Xitucheng Road 905 Hai-Dian District, Beijing 100876 906 P.R. China 908 Email: wdwang@bupt.edu.cn 909 Xiangyang Gong 910 BUPT University 911 Beijing University of Posts & Telecom. 912 No.10 Xitucheng Road 913 Hai-Dian District, Beijing 100876 914 P.R. China 916 Email: xygong@bupt.edu.cn