← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xorp/jaunty

« back to all changes in this revision

Viewing changes to xrl/interfaces/bgp_xif.cc

  • Committer: Bazaar Package Importer
  • Author(s): Jose Calhariz, Javier Fernandez-Sanguino, Jose Calhariz
  • Date: 2008-01-23 01:24:37 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080123012437-7l2u9r0k8e7op8st
Tags: 1.5~cvs.20080128-1
http://bugs.debian.org/441121
http://bugs.debian.org/453637
http://bugs.debian.org/454026
http://bugs.debian.org/453485
[ Javier Fernandez-Sanguino ]
* Update to latest CVS contents
* Modify debian/rules to prevent autobuilders from building 
  the binary-independent components: (Closes: #441121)
  - Create a new Build-Depends-Indep with all the TeX
  components used to build documentation
  - Since autobuilders call build, which in turns calls build-indep, hack
    the debian rules file so that the documentation is only built if ps2pdf,
    dvips and pslatex are available. 
* Modify the init.d script:
  - restart action: Do not attempt to stop xorp if not running
  - stop function: fix errors in the script
  - add a try-restart action
  - restructure the init.d script, move the restart code to a function
  - review the use of echo calls and exit values
* Use, as examples, the new boot files at rtrmgr/config/

[ Jose Calhariz ]
* Add depends on ncurses-dev, I don't know why xorp use tigetstr
  function from curses.  This way the depends field change less between
  build environments.
* Removed pushd and popd commands from Makefile and replaced with cd
  commands, was a bashism and FTBFS (closes: #453637)
* debian/control converted to utf-8 (closes: #454026) (closes: #453485)
* init.d/xorp now returns 0 if disabled.
* Added Vcs-Browser and Vcs-Svn fields pointing to the repository of the
  package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xrl/interfaces/bgp_xif.cc
1
1
/*
2
 
 * Copyright (c) 2001-2007 International Computer Science Institute
 
2
 * Copyright (c) 2001-2008 International Computer Science Institute
3
3
 * See LICENSE file for licensing, conditions, and warranties on use.
4
4
 *
5
5
 * DO NOT EDIT THIS FILE - IT IS PROGRAMMATICALLY GENERATED
7
7
 * Generated by 'clnt-gen'.
8
8
 */
9
9
 
10
 
#ident "$XORP: xorp/xrl/interfaces/bgp_xif.cc,v 1.49 2007/07/12 21:46:07 pavlin Exp $"
 
10
#ident "$XORP: xorp/xrl/interfaces/bgp_xif.cc,v 1.51 2008/01/04 03:17:51 pavlin Exp $"
11
11
 
12
12
#include "bgp_xif.hh"
13
13
 
14
14
bool
15
 
XrlBgpV0p2Client::send_get_bgp_version(
 
15
XrlBgpV0p3Client::send_get_bgp_version(
16
16
        const char*     dst_xrl_target_name,
17
17
        const GetBgpVersionCB&  cb
18
18
)
19
19
{
20
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_bgp_version");
21
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_bgp_version, cb));
 
20
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_bgp_version");
 
21
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_bgp_version, cb));
22
22
}
23
23
 
24
24
 
25
25
/* Unmarshall get_bgp_version */
26
26
void
27
 
XrlBgpV0p2Client::unmarshall_get_bgp_version(
 
27
XrlBgpV0p3Client::unmarshall_get_bgp_version(
28
28
        const XrlError& e,
29
29
        XrlArgs*        a,
30
30
        GetBgpVersionCB         cb
50
50
}
51
51
 
52
52
bool
53
 
XrlBgpV0p2Client::send_local_config(
 
53
XrlBgpV0p3Client::send_local_config(
54
54
        const char*     dst_xrl_target_name,
55
 
        const uint32_t& as,
 
55
        const string&   as,
56
56
        const IPv4&     id,
 
57
        const bool&     use_4byte_asnums,
57
58
        const LocalConfigCB&    cb
58
59
)
59
60
{
60
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/local_config");
 
61
    Xrl x(dst_xrl_target_name, "bgp/0.3/local_config");
61
62
    x.args().add("as", as);
62
63
    x.args().add("id", id);
63
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_local_config, cb));
 
64
    x.args().add("use_4byte_asnums", use_4byte_asnums);
 
65
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_local_config, cb));
64
66
}
65
67
 
66
68
 
67
69
/* Unmarshall local_config */
68
70
void
69
 
XrlBgpV0p2Client::unmarshall_local_config(
 
71
XrlBgpV0p3Client::unmarshall_local_config(
70
72
        const XrlError& e,
71
73
        XrlArgs*        a,
72
74
        LocalConfigCB           cb
84
86
}
85
87
 
86
88
bool
87
 
XrlBgpV0p2Client::send_set_local_as(
 
89
XrlBgpV0p3Client::send_set_local_as(
88
90
        const char*     dst_xrl_target_name,
89
 
        const uint32_t& as,
 
91
        const string&   as,
90
92
        const SetLocalAsCB&     cb
91
93
)
92
94
{
93
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_local_as");
 
95
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_local_as");
94
96
    x.args().add("as", as);
95
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_local_as, cb));
 
97
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_local_as, cb));
96
98
}
97
99
 
98
100
 
99
101
/* Unmarshall set_local_as */
100
102
void
101
 
XrlBgpV0p2Client::unmarshall_set_local_as(
 
103
XrlBgpV0p3Client::unmarshall_set_local_as(
102
104
        const XrlError& e,
103
105
        XrlArgs*        a,
104
106
        SetLocalAsCB            cb
116
118
}
117
119
 
118
120
bool
119
 
XrlBgpV0p2Client::send_get_local_as(
 
121
XrlBgpV0p3Client::send_set_4byte_as_support(
 
122
        const char*     dst_xrl_target_name,
 
123
        const bool&     enable,
 
124
        const Set4ByteAsSupportCB&      cb
 
125
)
 
126
{
 
127
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_4byte_as_support");
 
128
    x.args().add("enable", enable);
 
129
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_4byte_as_support, cb));
 
130
}
 
131
 
 
132
 
 
133
/* Unmarshall set_4byte_as_support */
 
134
void
 
135
XrlBgpV0p3Client::unmarshall_set_4byte_as_support(
 
136
        const XrlError& e,
 
137
        XrlArgs*        a,
 
138
        Set4ByteAsSupportCB             cb
 
139
)
 
140
{
 
141
    if (e != XrlError::OKAY()) {
 
142
        cb->dispatch(e);
 
143
        return;
 
144
    } else if (a && a->size() != 0) {
 
145
        XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(0));
 
146
        cb->dispatch(XrlError::BAD_ARGS());
 
147
        return;
 
148
    }
 
149
    cb->dispatch(e);
 
150
}
 
151
 
 
152
bool
 
153
XrlBgpV0p3Client::send_get_local_as(
120
154
        const char*     dst_xrl_target_name,
121
155
        const GetLocalAsCB&     cb
122
156
)
123
157
{
124
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_local_as");
125
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_local_as, cb));
 
158
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_local_as");
 
159
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_local_as, cb));
126
160
}
127
161
 
128
162
 
129
163
/* Unmarshall get_local_as */
130
164
void
131
 
XrlBgpV0p2Client::unmarshall_get_local_as(
 
165
XrlBgpV0p3Client::unmarshall_get_local_as(
132
166
        const XrlError& e,
133
167
        XrlArgs*        a,
134
168
        GetLocalAsCB            cb
142
176
        cb->dispatch(XrlError::BAD_ARGS(), 0);
143
177
        return;
144
178
    }
145
 
    uint32_t as;
 
179
    string as;
146
180
    try {
147
181
        a->get("as", as);
148
182
    } catch (const XrlArgs::BadArgs& e) {
154
188
}
155
189
 
156
190
bool
157
 
XrlBgpV0p2Client::send_set_bgp_id(
 
191
XrlBgpV0p3Client::send_set_bgp_id(
158
192
        const char*     dst_xrl_target_name,
159
193
        const IPv4&     id,
160
194
        const SetBgpIdCB&       cb
161
195
)
162
196
{
163
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_bgp_id");
 
197
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_bgp_id");
164
198
    x.args().add("id", id);
165
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_bgp_id, cb));
 
199
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_bgp_id, cb));
166
200
}
167
201
 
168
202
 
169
203
/* Unmarshall set_bgp_id */
170
204
void
171
 
XrlBgpV0p2Client::unmarshall_set_bgp_id(
 
205
XrlBgpV0p3Client::unmarshall_set_bgp_id(
172
206
        const XrlError& e,
173
207
        XrlArgs*        a,
174
208
        SetBgpIdCB              cb
186
220
}
187
221
 
188
222
bool
189
 
XrlBgpV0p2Client::send_get_bgp_id(
 
223
XrlBgpV0p3Client::send_get_bgp_id(
190
224
        const char*     dst_xrl_target_name,
191
225
        const GetBgpIdCB&       cb
192
226
)
193
227
{
194
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_bgp_id");
195
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_bgp_id, cb));
 
228
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_bgp_id");
 
229
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_bgp_id, cb));
196
230
}
197
231
 
198
232
 
199
233
/* Unmarshall get_bgp_id */
200
234
void
201
 
XrlBgpV0p2Client::unmarshall_get_bgp_id(
 
235
XrlBgpV0p3Client::unmarshall_get_bgp_id(
202
236
        const XrlError& e,
203
237
        XrlArgs*        a,
204
238
        GetBgpIdCB              cb
224
258
}
225
259
 
226
260
bool
227
 
XrlBgpV0p2Client::send_set_confederation_identifier(
 
261
XrlBgpV0p3Client::send_set_confederation_identifier(
228
262
        const char*     dst_xrl_target_name,
229
 
        const uint32_t& as,
 
263
        const string&   as,
230
264
        const bool&     disable,
231
265
        const SetConfederationIdentifierCB&     cb
232
266
)
233
267
{
234
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_confederation_identifier");
 
268
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_confederation_identifier");
235
269
    x.args().add("as", as);
236
270
    x.args().add("disable", disable);
237
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_confederation_identifier, cb));
 
271
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_confederation_identifier, cb));
238
272
}
239
273
 
240
274
 
241
275
/* Unmarshall set_confederation_identifier */
242
276
void
243
 
XrlBgpV0p2Client::unmarshall_set_confederation_identifier(
 
277
XrlBgpV0p3Client::unmarshall_set_confederation_identifier(
244
278
        const XrlError& e,
245
279
        XrlArgs*        a,
246
280
        SetConfederationIdentifierCB            cb
258
292
}
259
293
 
260
294
bool
261
 
XrlBgpV0p2Client::send_set_cluster_id(
 
295
XrlBgpV0p3Client::send_set_cluster_id(
262
296
        const char*     dst_xrl_target_name,
263
297
        const IPv4&     cluster_id,
264
298
        const bool&     disable,
265
299
        const SetClusterIdCB&   cb
266
300
)
267
301
{
268
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_cluster_id");
 
302
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_cluster_id");
269
303
    x.args().add("cluster_id", cluster_id);
270
304
    x.args().add("disable", disable);
271
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_cluster_id, cb));
 
305
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_cluster_id, cb));
272
306
}
273
307
 
274
308
 
275
309
/* Unmarshall set_cluster_id */
276
310
void
277
 
XrlBgpV0p2Client::unmarshall_set_cluster_id(
 
311
XrlBgpV0p3Client::unmarshall_set_cluster_id(
278
312
        const XrlError& e,
279
313
        XrlArgs*        a,
280
314
        SetClusterIdCB          cb
292
326
}
293
327
 
294
328
bool
295
 
XrlBgpV0p2Client::send_set_damping(
 
329
XrlBgpV0p3Client::send_set_damping(
296
330
        const char*     dst_xrl_target_name,
297
331
        const uint32_t& half_life,
298
332
        const uint32_t& max_suppress,
302
336
        const SetDampingCB&     cb
303
337
)
304
338
{
305
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_damping");
 
339
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_damping");
306
340
    x.args().add("half_life", half_life);
307
341
    x.args().add("max_suppress", max_suppress);
308
342
    x.args().add("reuse", reuse);
309
343
    x.args().add("suppress", suppress);
310
344
    x.args().add("disable", disable);
311
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_damping, cb));
 
345
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_damping, cb));
312
346
}
313
347
 
314
348
 
315
349
/* Unmarshall set_damping */
316
350
void
317
 
XrlBgpV0p2Client::unmarshall_set_damping(
 
351
XrlBgpV0p3Client::unmarshall_set_damping(
318
352
        const XrlError& e,
319
353
        XrlArgs*        a,
320
354
        SetDampingCB            cb
332
366
}
333
367
 
334
368
bool
335
 
XrlBgpV0p2Client::send_add_peer(
 
369
XrlBgpV0p3Client::send_add_peer(
336
370
        const char*     dst_xrl_target_name,
337
371
        const string&   local_ip,
338
372
        const uint32_t& local_port,
339
373
        const string&   peer_ip,
340
374
        const uint32_t& peer_port,
341
 
        const uint32_t& as,
 
375
        const string&   as,
342
376
        const IPv4&     next_hop,
343
377
        const uint32_t& holdtime,
344
378
        const AddPeerCB&        cb
345
379
)
346
380
{
347
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/add_peer");
 
381
    Xrl x(dst_xrl_target_name, "bgp/0.3/add_peer");
348
382
    x.args().add("local_ip", local_ip);
349
383
    x.args().add("local_port", local_port);
350
384
    x.args().add("peer_ip", peer_ip);
352
386
    x.args().add("as", as);
353
387
    x.args().add("next_hop", next_hop);
354
388
    x.args().add("holdtime", holdtime);
355
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_add_peer, cb));
 
389
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_add_peer, cb));
356
390
}
357
391
 
358
392
 
359
393
/* Unmarshall add_peer */
360
394
void
361
 
XrlBgpV0p2Client::unmarshall_add_peer(
 
395
XrlBgpV0p3Client::unmarshall_add_peer(
362
396
        const XrlError& e,
363
397
        XrlArgs*        a,
364
398
        AddPeerCB               cb
376
410
}
377
411
 
378
412
bool
379
 
XrlBgpV0p2Client::send_delete_peer(
 
413
XrlBgpV0p3Client::send_delete_peer(
380
414
        const char*     dst_xrl_target_name,
381
415
        const string&   local_ip,
382
416
        const uint32_t& local_port,
385
419
        const DeletePeerCB&     cb
386
420
)
387
421
{
388
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/delete_peer");
 
422
    Xrl x(dst_xrl_target_name, "bgp/0.3/delete_peer");
389
423
    x.args().add("local_ip", local_ip);
390
424
    x.args().add("local_port", local_port);
391
425
    x.args().add("peer_ip", peer_ip);
392
426
    x.args().add("peer_port", peer_port);
393
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_delete_peer, cb));
 
427
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_delete_peer, cb));
394
428
}
395
429
 
396
430
 
397
431
/* Unmarshall delete_peer */
398
432
void
399
 
XrlBgpV0p2Client::unmarshall_delete_peer(
 
433
XrlBgpV0p3Client::unmarshall_delete_peer(
400
434
        const XrlError& e,
401
435
        XrlArgs*        a,
402
436
        DeletePeerCB            cb
414
448
}
415
449
 
416
450
bool
417
 
XrlBgpV0p2Client::send_enable_peer(
 
451
XrlBgpV0p3Client::send_enable_peer(
418
452
        const char*     dst_xrl_target_name,
419
453
        const string&   local_ip,
420
454
        const uint32_t& local_port,
423
457
        const EnablePeerCB&     cb
424
458
)
425
459
{
426
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/enable_peer");
 
460
    Xrl x(dst_xrl_target_name, "bgp/0.3/enable_peer");
427
461
    x.args().add("local_ip", local_ip);
428
462
    x.args().add("local_port", local_port);
429
463
    x.args().add("peer_ip", peer_ip);
430
464
    x.args().add("peer_port", peer_port);
431
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_enable_peer, cb));
 
465
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_enable_peer, cb));
432
466
}
433
467
 
434
468
 
435
469
/* Unmarshall enable_peer */
436
470
void
437
 
XrlBgpV0p2Client::unmarshall_enable_peer(
 
471
XrlBgpV0p3Client::unmarshall_enable_peer(
438
472
        const XrlError& e,
439
473
        XrlArgs*        a,
440
474
        EnablePeerCB            cb
452
486
}
453
487
 
454
488
bool
455
 
XrlBgpV0p2Client::send_disable_peer(
 
489
XrlBgpV0p3Client::send_disable_peer(
456
490
        const char*     dst_xrl_target_name,
457
491
        const string&   local_ip,
458
492
        const uint32_t& local_port,
461
495
        const DisablePeerCB&    cb
462
496
)
463
497
{
464
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/disable_peer");
 
498
    Xrl x(dst_xrl_target_name, "bgp/0.3/disable_peer");
465
499
    x.args().add("local_ip", local_ip);
466
500
    x.args().add("local_port", local_port);
467
501
    x.args().add("peer_ip", peer_ip);
468
502
    x.args().add("peer_port", peer_port);
469
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_disable_peer, cb));
 
503
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_disable_peer, cb));
470
504
}
471
505
 
472
506
 
473
507
/* Unmarshall disable_peer */
474
508
void
475
 
XrlBgpV0p2Client::unmarshall_disable_peer(
 
509
XrlBgpV0p3Client::unmarshall_disable_peer(
476
510
        const XrlError& e,
477
511
        XrlArgs*        a,
478
512
        DisablePeerCB           cb
490
524
}
491
525
 
492
526
bool
493
 
XrlBgpV0p2Client::send_change_local_ip(
 
527
XrlBgpV0p3Client::send_change_local_ip(
494
528
        const char*     dst_xrl_target_name,
495
529
        const string&   local_ip,
496
530
        const uint32_t& local_port,
500
534
        const ChangeLocalIpCB&  cb
501
535
)
502
536
{
503
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/change_local_ip");
 
537
    Xrl x(dst_xrl_target_name, "bgp/0.3/change_local_ip");
504
538
    x.args().add("local_ip", local_ip);
505
539
    x.args().add("local_port", local_port);
506
540
    x.args().add("peer_ip", peer_ip);
507
541
    x.args().add("peer_port", peer_port);
508
542
    x.args().add("new_local_ip", new_local_ip);
509
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_change_local_ip, cb));
 
543
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_change_local_ip, cb));
510
544
}
511
545
 
512
546
 
513
547
/* Unmarshall change_local_ip */
514
548
void
515
 
XrlBgpV0p2Client::unmarshall_change_local_ip(
 
549
XrlBgpV0p3Client::unmarshall_change_local_ip(
516
550
        const XrlError& e,
517
551
        XrlArgs*        a,
518
552
        ChangeLocalIpCB         cb
530
564
}
531
565
 
532
566
bool
533
 
XrlBgpV0p2Client::send_change_local_port(
 
567
XrlBgpV0p3Client::send_change_local_port(
534
568
        const char*     dst_xrl_target_name,
535
569
        const string&   local_ip,
536
570
        const uint32_t& local_port,
540
574
        const ChangeLocalPortCB&        cb
541
575
)
542
576
{
543
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/change_local_port");
 
577
    Xrl x(dst_xrl_target_name, "bgp/0.3/change_local_port");
544
578
    x.args().add("local_ip", local_ip);
545
579
    x.args().add("local_port", local_port);
546
580
    x.args().add("peer_ip", peer_ip);
547
581
    x.args().add("peer_port", peer_port);
548
582
    x.args().add("new_local_port", new_local_port);
549
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_change_local_port, cb));
 
583
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_change_local_port, cb));
550
584
}
551
585
 
552
586
 
553
587
/* Unmarshall change_local_port */
554
588
void
555
 
XrlBgpV0p2Client::unmarshall_change_local_port(
 
589
XrlBgpV0p3Client::unmarshall_change_local_port(
556
590
        const XrlError& e,
557
591
        XrlArgs*        a,
558
592
        ChangeLocalPortCB               cb
570
604
}
571
605
 
572
606
bool
573
 
XrlBgpV0p2Client::send_change_peer_port(
 
607
XrlBgpV0p3Client::send_change_peer_port(
574
608
        const char*     dst_xrl_target_name,
575
609
        const string&   local_ip,
576
610
        const uint32_t& local_port,
580
614
        const ChangePeerPortCB& cb
581
615
)
582
616
{
583
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/change_peer_port");
 
617
    Xrl x(dst_xrl_target_name, "bgp/0.3/change_peer_port");
584
618
    x.args().add("local_ip", local_ip);
585
619
    x.args().add("local_port", local_port);
586
620
    x.args().add("peer_ip", peer_ip);
587
621
    x.args().add("peer_port", peer_port);
588
622
    x.args().add("new_peer_port", new_peer_port);
589
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_change_peer_port, cb));
 
623
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_change_peer_port, cb));
590
624
}
591
625
 
592
626
 
593
627
/* Unmarshall change_peer_port */
594
628
void
595
 
XrlBgpV0p2Client::unmarshall_change_peer_port(
 
629
XrlBgpV0p3Client::unmarshall_change_peer_port(
596
630
        const XrlError& e,
597
631
        XrlArgs*        a,
598
632
        ChangePeerPortCB                cb
610
644
}
611
645
 
612
646
bool
613
 
XrlBgpV0p2Client::send_set_peer_as(
 
647
XrlBgpV0p3Client::send_set_peer_as(
614
648
        const char*     dst_xrl_target_name,
615
649
        const string&   local_ip,
616
650
        const uint32_t& local_port,
617
651
        const string&   peer_ip,
618
652
        const uint32_t& peer_port,
619
 
        const uint32_t& peer_as,
 
653
        const string&   peer_as,
620
654
        const SetPeerAsCB&      cb
621
655
)
622
656
{
623
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_peer_as");
 
657
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_peer_as");
624
658
    x.args().add("local_ip", local_ip);
625
659
    x.args().add("local_port", local_port);
626
660
    x.args().add("peer_ip", peer_ip);
627
661
    x.args().add("peer_port", peer_port);
628
662
    x.args().add("peer_as", peer_as);
629
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_peer_as, cb));
 
663
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_peer_as, cb));
630
664
}
631
665
 
632
666
 
633
667
/* Unmarshall set_peer_as */
634
668
void
635
 
XrlBgpV0p2Client::unmarshall_set_peer_as(
 
669
XrlBgpV0p3Client::unmarshall_set_peer_as(
636
670
        const XrlError& e,
637
671
        XrlArgs*        a,
638
672
        SetPeerAsCB             cb
650
684
}
651
685
 
652
686
bool
653
 
XrlBgpV0p2Client::send_set_holdtime(
 
687
XrlBgpV0p3Client::send_set_holdtime(
654
688
        const char*     dst_xrl_target_name,
655
689
        const string&   local_ip,
656
690
        const uint32_t& local_port,
660
694
        const SetHoldtimeCB&    cb
661
695
)
662
696
{
663
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_holdtime");
 
697
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_holdtime");
664
698
    x.args().add("local_ip", local_ip);
665
699
    x.args().add("local_port", local_port);
666
700
    x.args().add("peer_ip", peer_ip);
667
701
    x.args().add("peer_port", peer_port);
668
702
    x.args().add("holdtime", holdtime);
669
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_holdtime, cb));
 
703
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_holdtime, cb));
670
704
}
671
705
 
672
706
 
673
707
/* Unmarshall set_holdtime */
674
708
void
675
 
XrlBgpV0p2Client::unmarshall_set_holdtime(
 
709
XrlBgpV0p3Client::unmarshall_set_holdtime(
676
710
        const XrlError& e,
677
711
        XrlArgs*        a,
678
712
        SetHoldtimeCB           cb
690
724
}
691
725
 
692
726
bool
693
 
XrlBgpV0p2Client::send_set_delay_open_time(
 
727
XrlBgpV0p3Client::send_set_delay_open_time(
694
728
        const char*     dst_xrl_target_name,
695
729
        const string&   local_ip,
696
730
        const uint32_t& local_port,
700
734
        const SetDelayOpenTimeCB&       cb
701
735
)
702
736
{
703
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_delay_open_time");
 
737
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_delay_open_time");
704
738
    x.args().add("local_ip", local_ip);
705
739
    x.args().add("local_port", local_port);
706
740
    x.args().add("peer_ip", peer_ip);
707
741
    x.args().add("peer_port", peer_port);
708
742
    x.args().add("delay_open_time", delay_open_time);
709
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_delay_open_time, cb));
 
743
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_delay_open_time, cb));
710
744
}
711
745
 
712
746
 
713
747
/* Unmarshall set_delay_open_time */
714
748
void
715
 
XrlBgpV0p2Client::unmarshall_set_delay_open_time(
 
749
XrlBgpV0p3Client::unmarshall_set_delay_open_time(
716
750
        const XrlError& e,
717
751
        XrlArgs*        a,
718
752
        SetDelayOpenTimeCB              cb
730
764
}
731
765
 
732
766
bool
733
 
XrlBgpV0p2Client::send_set_route_reflector_client(
 
767
XrlBgpV0p3Client::send_set_route_reflector_client(
734
768
        const char*     dst_xrl_target_name,
735
769
        const string&   local_ip,
736
770
        const uint32_t& local_port,
740
774
        const SetRouteReflectorClientCB&        cb
741
775
)
742
776
{
743
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_route_reflector_client");
 
777
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_route_reflector_client");
744
778
    x.args().add("local_ip", local_ip);
745
779
    x.args().add("local_port", local_port);
746
780
    x.args().add("peer_ip", peer_ip);
747
781
    x.args().add("peer_port", peer_port);
748
782
    x.args().add("state", state);
749
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_route_reflector_client, cb));
 
783
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_route_reflector_client, cb));
750
784
}
751
785
 
752
786
 
753
787
/* Unmarshall set_route_reflector_client */
754
788
void
755
 
XrlBgpV0p2Client::unmarshall_set_route_reflector_client(
 
789
XrlBgpV0p3Client::unmarshall_set_route_reflector_client(
756
790
        const XrlError& e,
757
791
        XrlArgs*        a,
758
792
        SetRouteReflectorClientCB               cb
770
804
}
771
805
 
772
806
bool
773
 
XrlBgpV0p2Client::send_set_confederation_member(
 
807
XrlBgpV0p3Client::send_set_confederation_member(
774
808
        const char*     dst_xrl_target_name,
775
809
        const string&   local_ip,
776
810
        const uint32_t& local_port,
780
814
        const SetConfederationMemberCB& cb
781
815
)
782
816
{
783
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_confederation_member");
 
817
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_confederation_member");
784
818
    x.args().add("local_ip", local_ip);
785
819
    x.args().add("local_port", local_port);
786
820
    x.args().add("peer_ip", peer_ip);
787
821
    x.args().add("peer_port", peer_port);
788
822
    x.args().add("state", state);
789
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_confederation_member, cb));
 
823
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_confederation_member, cb));
790
824
}
791
825
 
792
826
 
793
827
/* Unmarshall set_confederation_member */
794
828
void
795
 
XrlBgpV0p2Client::unmarshall_set_confederation_member(
 
829
XrlBgpV0p3Client::unmarshall_set_confederation_member(
796
830
        const XrlError& e,
797
831
        XrlArgs*        a,
798
832
        SetConfederationMemberCB                cb
810
844
}
811
845
 
812
846
bool
813
 
XrlBgpV0p2Client::send_set_prefix_limit(
 
847
XrlBgpV0p3Client::send_set_prefix_limit(
814
848
        const char*     dst_xrl_target_name,
815
849
        const string&   local_ip,
816
850
        const uint32_t& local_port,
821
855
        const SetPrefixLimitCB& cb
822
856
)
823
857
{
824
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_prefix_limit");
 
858
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_prefix_limit");
825
859
    x.args().add("local_ip", local_ip);
826
860
    x.args().add("local_port", local_port);
827
861
    x.args().add("peer_ip", peer_ip);
828
862
    x.args().add("peer_port", peer_port);
829
863
    x.args().add("maximum", maximum);
830
864
    x.args().add("state", state);
831
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_prefix_limit, cb));
 
865
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_prefix_limit, cb));
832
866
}
833
867
 
834
868
 
835
869
/* Unmarshall set_prefix_limit */
836
870
void
837
 
XrlBgpV0p2Client::unmarshall_set_prefix_limit(
 
871
XrlBgpV0p3Client::unmarshall_set_prefix_limit(
838
872
        const XrlError& e,
839
873
        XrlArgs*        a,
840
874
        SetPrefixLimitCB                cb
852
886
}
853
887
 
854
888
bool
855
 
XrlBgpV0p2Client::send_set_nexthop4(
 
889
XrlBgpV0p3Client::send_set_nexthop4(
856
890
        const char*     dst_xrl_target_name,
857
891
        const string&   local_ip,
858
892
        const uint32_t& local_port,
862
896
        const SetNexthop4CB&    cb
863
897
)
864
898
{
865
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_nexthop4");
 
899
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_nexthop4");
866
900
    x.args().add("local_ip", local_ip);
867
901
    x.args().add("local_port", local_port);
868
902
    x.args().add("peer_ip", peer_ip);
869
903
    x.args().add("peer_port", peer_port);
870
904
    x.args().add("next_hop", next_hop);
871
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_nexthop4, cb));
 
905
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_nexthop4, cb));
872
906
}
873
907
 
874
908
 
875
909
/* Unmarshall set_nexthop4 */
876
910
void
877
 
XrlBgpV0p2Client::unmarshall_set_nexthop4(
 
911
XrlBgpV0p3Client::unmarshall_set_nexthop4(
878
912
        const XrlError& e,
879
913
        XrlArgs*        a,
880
914
        SetNexthop4CB           cb
892
926
}
893
927
 
894
928
bool
895
 
XrlBgpV0p2Client::send_set_nexthop6(
 
929
XrlBgpV0p3Client::send_set_nexthop6(
896
930
        const char*     dst_xrl_target_name,
897
931
        const string&   local_ip,
898
932
        const uint32_t& local_port,
902
936
        const SetNexthop6CB&    cb
903
937
)
904
938
{
905
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_nexthop6");
 
939
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_nexthop6");
906
940
    x.args().add("local_ip", local_ip);
907
941
    x.args().add("local_port", local_port);
908
942
    x.args().add("peer_ip", peer_ip);
909
943
    x.args().add("peer_port", peer_port);
910
944
    x.args().add("next_hop", next_hop);
911
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_nexthop6, cb));
 
945
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_nexthop6, cb));
912
946
}
913
947
 
914
948
 
915
949
/* Unmarshall set_nexthop6 */
916
950
void
917
 
XrlBgpV0p2Client::unmarshall_set_nexthop6(
 
951
XrlBgpV0p3Client::unmarshall_set_nexthop6(
918
952
        const XrlError& e,
919
953
        XrlArgs*        a,
920
954
        SetNexthop6CB           cb
932
966
}
933
967
 
934
968
bool
935
 
XrlBgpV0p2Client::send_get_nexthop6(
 
969
XrlBgpV0p3Client::send_get_nexthop6(
936
970
        const char*     dst_xrl_target_name,
937
971
        const string&   local_ip,
938
972
        const uint32_t& local_port,
941
975
        const GetNexthop6CB&    cb
942
976
)
943
977
{
944
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_nexthop6");
 
978
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_nexthop6");
945
979
    x.args().add("local_ip", local_ip);
946
980
    x.args().add("local_port", local_port);
947
981
    x.args().add("peer_ip", peer_ip);
948
982
    x.args().add("peer_port", peer_port);
949
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_nexthop6, cb));
 
983
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_nexthop6, cb));
950
984
}
951
985
 
952
986
 
953
987
/* Unmarshall get_nexthop6 */
954
988
void
955
 
XrlBgpV0p2Client::unmarshall_get_nexthop6(
 
989
XrlBgpV0p3Client::unmarshall_get_nexthop6(
956
990
        const XrlError& e,
957
991
        XrlArgs*        a,
958
992
        GetNexthop6CB           cb
978
1012
}
979
1013
 
980
1014
bool
981
 
XrlBgpV0p2Client::send_set_peer_state(
 
1015
XrlBgpV0p3Client::send_set_peer_state(
982
1016
        const char*     dst_xrl_target_name,
983
1017
        const string&   local_ip,
984
1018
        const uint32_t& local_port,
988
1022
        const SetPeerStateCB&   cb
989
1023
)
990
1024
{
991
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_peer_state");
 
1025
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_peer_state");
992
1026
    x.args().add("local_ip", local_ip);
993
1027
    x.args().add("local_port", local_port);
994
1028
    x.args().add("peer_ip", peer_ip);
995
1029
    x.args().add("peer_port", peer_port);
996
1030
    x.args().add("toggle", toggle);
997
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_peer_state, cb));
 
1031
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_peer_state, cb));
998
1032
}
999
1033
 
1000
1034
 
1001
1035
/* Unmarshall set_peer_state */
1002
1036
void
1003
 
XrlBgpV0p2Client::unmarshall_set_peer_state(
 
1037
XrlBgpV0p3Client::unmarshall_set_peer_state(
1004
1038
        const XrlError& e,
1005
1039
        XrlArgs*        a,
1006
1040
        SetPeerStateCB          cb
1018
1052
}
1019
1053
 
1020
1054
bool
1021
 
XrlBgpV0p2Client::send_set_peer_md5_password(
 
1055
XrlBgpV0p3Client::send_set_peer_md5_password(
1022
1056
        const char*     dst_xrl_target_name,
1023
1057
        const string&   local_ip,
1024
1058
        const uint32_t& local_port,
1028
1062
        const SetPeerMd5PasswordCB&     cb
1029
1063
)
1030
1064
{
1031
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_peer_md5_password");
 
1065
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_peer_md5_password");
1032
1066
    x.args().add("local_ip", local_ip);
1033
1067
    x.args().add("local_port", local_port);
1034
1068
    x.args().add("peer_ip", peer_ip);
1035
1069
    x.args().add("peer_port", peer_port);
1036
1070
    x.args().add("password", password);
1037
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_peer_md5_password, cb));
 
1071
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_peer_md5_password, cb));
1038
1072
}
1039
1073
 
1040
1074
 
1041
1075
/* Unmarshall set_peer_md5_password */
1042
1076
void
1043
 
XrlBgpV0p2Client::unmarshall_set_peer_md5_password(
 
1077
XrlBgpV0p3Client::unmarshall_set_peer_md5_password(
1044
1078
        const XrlError& e,
1045
1079
        XrlArgs*        a,
1046
1080
        SetPeerMd5PasswordCB            cb
1058
1092
}
1059
1093
 
1060
1094
bool
1061
 
XrlBgpV0p2Client::send_activate(
 
1095
XrlBgpV0p3Client::send_activate(
1062
1096
        const char*     dst_xrl_target_name,
1063
1097
        const string&   local_ip,
1064
1098
        const uint32_t& local_port,
1067
1101
        const ActivateCB&       cb
1068
1102
)
1069
1103
{
1070
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/activate");
 
1104
    Xrl x(dst_xrl_target_name, "bgp/0.3/activate");
1071
1105
    x.args().add("local_ip", local_ip);
1072
1106
    x.args().add("local_port", local_port);
1073
1107
    x.args().add("peer_ip", peer_ip);
1074
1108
    x.args().add("peer_port", peer_port);
1075
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_activate, cb));
 
1109
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_activate, cb));
1076
1110
}
1077
1111
 
1078
1112
 
1079
1113
/* Unmarshall activate */
1080
1114
void
1081
 
XrlBgpV0p2Client::unmarshall_activate(
 
1115
XrlBgpV0p3Client::unmarshall_activate(
1082
1116
        const XrlError& e,
1083
1117
        XrlArgs*        a,
1084
1118
        ActivateCB              cb
1096
1130
}
1097
1131
 
1098
1132
bool
1099
 
XrlBgpV0p2Client::send_set_parameter(
 
1133
XrlBgpV0p3Client::send_set_parameter(
1100
1134
        const char*     dst_xrl_target_name,
1101
1135
        const string&   local_ip,
1102
1136
        const uint32_t& local_port,
1107
1141
        const SetParameterCB&   cb
1108
1142
)
1109
1143
{
1110
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/set_parameter");
 
1144
    Xrl x(dst_xrl_target_name, "bgp/0.3/set_parameter");
1111
1145
    x.args().add("local_ip", local_ip);
1112
1146
    x.args().add("local_port", local_port);
1113
1147
    x.args().add("peer_ip", peer_ip);
1114
1148
    x.args().add("peer_port", peer_port);
1115
1149
    x.args().add("parameter", parameter);
1116
1150
    x.args().add("toggle", toggle);
1117
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_set_parameter, cb));
 
1151
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_set_parameter, cb));
1118
1152
}
1119
1153
 
1120
1154
 
1121
1155
/* Unmarshall set_parameter */
1122
1156
void
1123
 
XrlBgpV0p2Client::unmarshall_set_parameter(
 
1157
XrlBgpV0p3Client::unmarshall_set_parameter(
1124
1158
        const XrlError& e,
1125
1159
        XrlArgs*        a,
1126
1160
        SetParameterCB          cb
1138
1172
}
1139
1173
 
1140
1174
bool
1141
 
XrlBgpV0p2Client::send_next_hop_rewrite_filter(
 
1175
XrlBgpV0p3Client::send_next_hop_rewrite_filter(
1142
1176
        const char*     dst_xrl_target_name,
1143
1177
        const string&   local_ip,
1144
1178
        const uint32_t& local_port,
1148
1182
        const NextHopRewriteFilterCB&   cb
1149
1183
)
1150
1184
{
1151
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/next_hop_rewrite_filter");
 
1185
    Xrl x(dst_xrl_target_name, "bgp/0.3/next_hop_rewrite_filter");
1152
1186
    x.args().add("local_ip", local_ip);
1153
1187
    x.args().add("local_port", local_port);
1154
1188
    x.args().add("peer_ip", peer_ip);
1155
1189
    x.args().add("peer_port", peer_port);
1156
1190
    x.args().add("next_hop", next_hop);
1157
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_next_hop_rewrite_filter, cb));
 
1191
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_next_hop_rewrite_filter, cb));
1158
1192
}
1159
1193
 
1160
1194
 
1161
1195
/* Unmarshall next_hop_rewrite_filter */
1162
1196
void
1163
 
XrlBgpV0p2Client::unmarshall_next_hop_rewrite_filter(
 
1197
XrlBgpV0p3Client::unmarshall_next_hop_rewrite_filter(
1164
1198
        const XrlError& e,
1165
1199
        XrlArgs*        a,
1166
1200
        NextHopRewriteFilterCB          cb
1178
1212
}
1179
1213
 
1180
1214
bool
1181
 
XrlBgpV0p2Client::send_originate_route4(
 
1215
XrlBgpV0p3Client::send_originate_route4(
1182
1216
        const char*     dst_xrl_target_name,
1183
1217
        const IPv4Net&  nlri,
1184
1218
        const IPv4&     next_hop,
1187
1221
        const OriginateRoute4CB&        cb
1188
1222
)
1189
1223
{
1190
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/originate_route4");
 
1224
    Xrl x(dst_xrl_target_name, "bgp/0.3/originate_route4");
1191
1225
    x.args().add("nlri", nlri);
1192
1226
    x.args().add("next_hop", next_hop);
1193
1227
    x.args().add("unicast", unicast);
1194
1228
    x.args().add("multicast", multicast);
1195
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_originate_route4, cb));
 
1229
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_originate_route4, cb));
1196
1230
}
1197
1231
 
1198
1232
 
1199
1233
/* Unmarshall originate_route4 */
1200
1234
void
1201
 
XrlBgpV0p2Client::unmarshall_originate_route4(
 
1235
XrlBgpV0p3Client::unmarshall_originate_route4(
1202
1236
        const XrlError& e,
1203
1237
        XrlArgs*        a,
1204
1238
        OriginateRoute4CB               cb
1216
1250
}
1217
1251
 
1218
1252
bool
1219
 
XrlBgpV0p2Client::send_originate_route6(
 
1253
XrlBgpV0p3Client::send_originate_route6(
1220
1254
        const char*     dst_xrl_target_name,
1221
1255
        const IPv6Net&  nlri,
1222
1256
        const IPv6&     next_hop,
1225
1259
        const OriginateRoute6CB&        cb
1226
1260
)
1227
1261
{
1228
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/originate_route6");
 
1262
    Xrl x(dst_xrl_target_name, "bgp/0.3/originate_route6");
1229
1263
    x.args().add("nlri", nlri);
1230
1264
    x.args().add("next_hop", next_hop);
1231
1265
    x.args().add("unicast", unicast);
1232
1266
    x.args().add("multicast", multicast);
1233
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_originate_route6, cb));
 
1267
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_originate_route6, cb));
1234
1268
}
1235
1269
 
1236
1270
 
1237
1271
/* Unmarshall originate_route6 */
1238
1272
void
1239
 
XrlBgpV0p2Client::unmarshall_originate_route6(
 
1273
XrlBgpV0p3Client::unmarshall_originate_route6(
1240
1274
        const XrlError& e,
1241
1275
        XrlArgs*        a,
1242
1276
        OriginateRoute6CB               cb
1254
1288
}
1255
1289
 
1256
1290
bool
1257
 
XrlBgpV0p2Client::send_withdraw_route4(
 
1291
XrlBgpV0p3Client::send_withdraw_route4(
1258
1292
        const char*     dst_xrl_target_name,
1259
1293
        const IPv4Net&  nlri,
1260
1294
        const bool&     unicast,
1262
1296
        const WithdrawRoute4CB& cb
1263
1297
)
1264
1298
{
1265
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/withdraw_route4");
 
1299
    Xrl x(dst_xrl_target_name, "bgp/0.3/withdraw_route4");
1266
1300
    x.args().add("nlri", nlri);
1267
1301
    x.args().add("unicast", unicast);
1268
1302
    x.args().add("multicast", multicast);
1269
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_withdraw_route4, cb));
 
1303
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_withdraw_route4, cb));
1270
1304
}
1271
1305
 
1272
1306
 
1273
1307
/* Unmarshall withdraw_route4 */
1274
1308
void
1275
 
XrlBgpV0p2Client::unmarshall_withdraw_route4(
 
1309
XrlBgpV0p3Client::unmarshall_withdraw_route4(
1276
1310
        const XrlError& e,
1277
1311
        XrlArgs*        a,
1278
1312
        WithdrawRoute4CB                cb
1290
1324
}
1291
1325
 
1292
1326
bool
1293
 
XrlBgpV0p2Client::send_withdraw_route6(
 
1327
XrlBgpV0p3Client::send_withdraw_route6(
1294
1328
        const char*     dst_xrl_target_name,
1295
1329
        const IPv6Net&  nlri,
1296
1330
        const bool&     unicast,
1298
1332
        const WithdrawRoute6CB& cb
1299
1333
)
1300
1334
{
1301
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/withdraw_route6");
 
1335
    Xrl x(dst_xrl_target_name, "bgp/0.3/withdraw_route6");
1302
1336
    x.args().add("nlri", nlri);
1303
1337
    x.args().add("unicast", unicast);
1304
1338
    x.args().add("multicast", multicast);
1305
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_withdraw_route6, cb));
 
1339
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_withdraw_route6, cb));
1306
1340
}
1307
1341
 
1308
1342
 
1309
1343
/* Unmarshall withdraw_route6 */
1310
1344
void
1311
 
XrlBgpV0p2Client::unmarshall_withdraw_route6(
 
1345
XrlBgpV0p3Client::unmarshall_withdraw_route6(
1312
1346
        const XrlError& e,
1313
1347
        XrlArgs*        a,
1314
1348
        WithdrawRoute6CB                cb
1326
1360
}
1327
1361
 
1328
1362
bool
1329
 
XrlBgpV0p2Client::send_trace(
 
1363
XrlBgpV0p3Client::send_trace(
1330
1364
        const char*     dst_xrl_target_name,
1331
1365
        const string&   tvar,
1332
1366
        const bool&     enable,
1333
1367
        const TraceCB&  cb
1334
1368
)
1335
1369
{
1336
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/trace");
 
1370
    Xrl x(dst_xrl_target_name, "bgp/0.3/trace");
1337
1371
    x.args().add("tvar", tvar);
1338
1372
    x.args().add("enable", enable);
1339
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_trace, cb));
 
1373
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_trace, cb));
1340
1374
}
1341
1375
 
1342
1376
 
1343
1377
/* Unmarshall trace */
1344
1378
void
1345
 
XrlBgpV0p2Client::unmarshall_trace(
 
1379
XrlBgpV0p3Client::unmarshall_trace(
1346
1380
        const XrlError& e,
1347
1381
        XrlArgs*        a,
1348
1382
        TraceCB         cb
1360
1394
}
1361
1395
 
1362
1396
bool
1363
 
XrlBgpV0p2Client::send_get_peer_list_start(
 
1397
XrlBgpV0p3Client::send_get_peer_list_start(
1364
1398
        const char*     dst_xrl_target_name,
1365
1399
        const GetPeerListStartCB&       cb
1366
1400
)
1367
1401
{
1368
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_list_start");
1369
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_list_start, cb));
 
1402
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_list_start");
 
1403
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_list_start, cb));
1370
1404
}
1371
1405
 
1372
1406
 
1373
1407
/* Unmarshall get_peer_list_start */
1374
1408
void
1375
 
XrlBgpV0p2Client::unmarshall_get_peer_list_start(
 
1409
XrlBgpV0p3Client::unmarshall_get_peer_list_start(
1376
1410
        const XrlError& e,
1377
1411
        XrlArgs*        a,
1378
1412
        GetPeerListStartCB              cb
1400
1434
}
1401
1435
 
1402
1436
bool
1403
 
XrlBgpV0p2Client::send_get_peer_list_next(
 
1437
XrlBgpV0p3Client::send_get_peer_list_next(
1404
1438
        const char*     dst_xrl_target_name,
1405
1439
        const uint32_t& token,
1406
1440
        const GetPeerListNextCB&        cb
1407
1441
)
1408
1442
{
1409
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_list_next");
 
1443
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_list_next");
1410
1444
    x.args().add("token", token);
1411
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_list_next, cb));
 
1445
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_list_next, cb));
1412
1446
}
1413
1447
 
1414
1448
 
1415
1449
/* Unmarshall get_peer_list_next */
1416
1450
void
1417
 
XrlBgpV0p2Client::unmarshall_get_peer_list_next(
 
1451
XrlBgpV0p3Client::unmarshall_get_peer_list_next(
1418
1452
        const XrlError& e,
1419
1453
        XrlArgs*        a,
1420
1454
        GetPeerListNextCB               cb
1448
1482
}
1449
1483
 
1450
1484
bool
1451
 
XrlBgpV0p2Client::send_get_peer_id(
 
1485
XrlBgpV0p3Client::send_get_peer_id(
1452
1486
        const char*     dst_xrl_target_name,
1453
1487
        const string&   local_ip,
1454
1488
        const uint32_t& local_port,
1457
1491
        const GetPeerIdCB&      cb
1458
1492
)
1459
1493
{
1460
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_id");
 
1494
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_id");
1461
1495
    x.args().add("local_ip", local_ip);
1462
1496
    x.args().add("local_port", local_port);
1463
1497
    x.args().add("peer_ip", peer_ip);
1464
1498
    x.args().add("peer_port", peer_port);
1465
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_id, cb));
 
1499
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_id, cb));
1466
1500
}
1467
1501
 
1468
1502
 
1469
1503
/* Unmarshall get_peer_id */
1470
1504
void
1471
 
XrlBgpV0p2Client::unmarshall_get_peer_id(
 
1505
XrlBgpV0p3Client::unmarshall_get_peer_id(
1472
1506
        const XrlError& e,
1473
1507
        XrlArgs*        a,
1474
1508
        GetPeerIdCB             cb
1494
1528
}
1495
1529
 
1496
1530
bool
1497
 
XrlBgpV0p2Client::send_get_peer_status(
 
1531
XrlBgpV0p3Client::send_get_peer_status(
1498
1532
        const char*     dst_xrl_target_name,
1499
1533
        const string&   local_ip,
1500
1534
        const uint32_t& local_port,
1503
1537
        const GetPeerStatusCB&  cb
1504
1538
)
1505
1539
{
1506
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_status");
 
1540
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_status");
1507
1541
    x.args().add("local_ip", local_ip);
1508
1542
    x.args().add("local_port", local_port);
1509
1543
    x.args().add("peer_ip", peer_ip);
1510
1544
    x.args().add("peer_port", peer_port);
1511
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_status, cb));
 
1545
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_status, cb));
1512
1546
}
1513
1547
 
1514
1548
 
1515
1549
/* Unmarshall get_peer_status */
1516
1550
void
1517
 
XrlBgpV0p2Client::unmarshall_get_peer_status(
 
1551
XrlBgpV0p3Client::unmarshall_get_peer_status(
1518
1552
        const XrlError& e,
1519
1553
        XrlArgs*        a,
1520
1554
        GetPeerStatusCB         cb
1542
1576
}
1543
1577
 
1544
1578
bool
1545
 
XrlBgpV0p2Client::send_get_peer_negotiated_version(
 
1579
XrlBgpV0p3Client::send_get_peer_negotiated_version(
1546
1580
        const char*     dst_xrl_target_name,
1547
1581
        const string&   local_ip,
1548
1582
        const uint32_t& local_port,
1551
1585
        const GetPeerNegotiatedVersionCB&       cb
1552
1586
)
1553
1587
{
1554
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_negotiated_version");
 
1588
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_negotiated_version");
1555
1589
    x.args().add("local_ip", local_ip);
1556
1590
    x.args().add("local_port", local_port);
1557
1591
    x.args().add("peer_ip", peer_ip);
1558
1592
    x.args().add("peer_port", peer_port);
1559
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_negotiated_version, cb));
 
1593
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_negotiated_version, cb));
1560
1594
}
1561
1595
 
1562
1596
 
1563
1597
/* Unmarshall get_peer_negotiated_version */
1564
1598
void
1565
 
XrlBgpV0p2Client::unmarshall_get_peer_negotiated_version(
 
1599
XrlBgpV0p3Client::unmarshall_get_peer_negotiated_version(
1566
1600
        const XrlError& e,
1567
1601
        XrlArgs*        a,
1568
1602
        GetPeerNegotiatedVersionCB              cb
1588
1622
}
1589
1623
 
1590
1624
bool
1591
 
XrlBgpV0p2Client::send_get_peer_as(
 
1625
XrlBgpV0p3Client::send_get_peer_as(
1592
1626
        const char*     dst_xrl_target_name,
1593
1627
        const string&   local_ip,
1594
1628
        const uint32_t& local_port,
1597
1631
        const GetPeerAsCB&      cb
1598
1632
)
1599
1633
{
1600
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_as");
 
1634
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_as");
1601
1635
    x.args().add("local_ip", local_ip);
1602
1636
    x.args().add("local_port", local_port);
1603
1637
    x.args().add("peer_ip", peer_ip);
1604
1638
    x.args().add("peer_port", peer_port);
1605
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_as, cb));
 
1639
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_as, cb));
1606
1640
}
1607
1641
 
1608
1642
 
1609
1643
/* Unmarshall get_peer_as */
1610
1644
void
1611
 
XrlBgpV0p2Client::unmarshall_get_peer_as(
 
1645
XrlBgpV0p3Client::unmarshall_get_peer_as(
1612
1646
        const XrlError& e,
1613
1647
        XrlArgs*        a,
1614
1648
        GetPeerAsCB             cb
1622
1656
        cb->dispatch(XrlError::BAD_ARGS(), 0);
1623
1657
        return;
1624
1658
    }
1625
 
    uint32_t peer_as;
 
1659
    string peer_as;
1626
1660
    try {
1627
1661
        a->get("peer_as", peer_as);
1628
1662
    } catch (const XrlArgs::BadArgs& e) {
1634
1668
}
1635
1669
 
1636
1670
bool
1637
 
XrlBgpV0p2Client::send_get_peer_msg_stats(
 
1671
XrlBgpV0p3Client::send_get_peer_msg_stats(
1638
1672
        const char*     dst_xrl_target_name,
1639
1673
        const string&   local_ip,
1640
1674
        const uint32_t& local_port,
1643
1677
        const GetPeerMsgStatsCB&        cb
1644
1678
)
1645
1679
{
1646
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_msg_stats");
 
1680
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_msg_stats");
1647
1681
    x.args().add("local_ip", local_ip);
1648
1682
    x.args().add("local_port", local_port);
1649
1683
    x.args().add("peer_ip", peer_ip);
1650
1684
    x.args().add("peer_port", peer_port);
1651
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_msg_stats, cb));
 
1685
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_msg_stats, cb));
1652
1686
}
1653
1687
 
1654
1688
 
1655
1689
/* Unmarshall get_peer_msg_stats */
1656
1690
void
1657
 
XrlBgpV0p2Client::unmarshall_get_peer_msg_stats(
 
1691
XrlBgpV0p3Client::unmarshall_get_peer_msg_stats(
1658
1692
        const XrlError& e,
1659
1693
        XrlArgs*        a,
1660
1694
        GetPeerMsgStatsCB               cb
1690
1724
}
1691
1725
 
1692
1726
bool
1693
 
XrlBgpV0p2Client::send_get_peer_established_stats(
 
1727
XrlBgpV0p3Client::send_get_peer_established_stats(
1694
1728
        const char*     dst_xrl_target_name,
1695
1729
        const string&   local_ip,
1696
1730
        const uint32_t& local_port,
1699
1733
        const GetPeerEstablishedStatsCB&        cb
1700
1734
)
1701
1735
{
1702
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_established_stats");
 
1736
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_established_stats");
1703
1737
    x.args().add("local_ip", local_ip);
1704
1738
    x.args().add("local_port", local_port);
1705
1739
    x.args().add("peer_ip", peer_ip);
1706
1740
    x.args().add("peer_port", peer_port);
1707
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_established_stats, cb));
 
1741
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_established_stats, cb));
1708
1742
}
1709
1743
 
1710
1744
 
1711
1745
/* Unmarshall get_peer_established_stats */
1712
1746
void
1713
 
XrlBgpV0p2Client::unmarshall_get_peer_established_stats(
 
1747
XrlBgpV0p3Client::unmarshall_get_peer_established_stats(
1714
1748
        const XrlError& e,
1715
1749
        XrlArgs*        a,
1716
1750
        GetPeerEstablishedStatsCB               cb
1738
1772
}
1739
1773
 
1740
1774
bool
1741
 
XrlBgpV0p2Client::send_get_peer_timer_config(
 
1775
XrlBgpV0p3Client::send_get_peer_timer_config(
1742
1776
        const char*     dst_xrl_target_name,
1743
1777
        const string&   local_ip,
1744
1778
        const uint32_t& local_port,
1747
1781
        const GetPeerTimerConfigCB&     cb
1748
1782
)
1749
1783
{
1750
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_timer_config");
 
1784
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_peer_timer_config");
1751
1785
    x.args().add("local_ip", local_ip);
1752
1786
    x.args().add("local_port", local_port);
1753
1787
    x.args().add("peer_ip", peer_ip);
1754
1788
    x.args().add("peer_port", peer_port);
1755
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_timer_config, cb));
 
1789
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_peer_timer_config, cb));
1756
1790
}
1757
1791
 
1758
1792
 
1759
1793
/* Unmarshall get_peer_timer_config */
1760
1794
void
1761
 
XrlBgpV0p2Client::unmarshall_get_peer_timer_config(
 
1795
XrlBgpV0p3Client::unmarshall_get_peer_timer_config(
1762
1796
        const XrlError& e,
1763
1797
        XrlArgs*        a,
1764
1798
        GetPeerTimerConfigCB            cb
1796
1830
}
1797
1831
 
1798
1832
bool
1799
 
XrlBgpV0p2Client::send_register_rib(
 
1833
XrlBgpV0p3Client::send_register_rib(
1800
1834
        const char*     dst_xrl_target_name,
1801
1835
        const string&   name,
1802
1836
        const RegisterRibCB&    cb
1803
1837
)
1804
1838
{
1805
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/register_rib");
 
1839
    Xrl x(dst_xrl_target_name, "bgp/0.3/register_rib");
1806
1840
    x.args().add("name", name);
1807
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_register_rib, cb));
 
1841
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_register_rib, cb));
1808
1842
}
1809
1843
 
1810
1844
 
1811
1845
/* Unmarshall register_rib */
1812
1846
void
1813
 
XrlBgpV0p2Client::unmarshall_register_rib(
 
1847
XrlBgpV0p3Client::unmarshall_register_rib(
1814
1848
        const XrlError& e,
1815
1849
        XrlArgs*        a,
1816
1850
        RegisterRibCB           cb
1828
1862
}
1829
1863
 
1830
1864
bool
1831
 
XrlBgpV0p2Client::send_get_v4_route_list_start(
 
1865
XrlBgpV0p3Client::send_get_v4_route_list_start(
1832
1866
        const char*     dst_xrl_target_name,
1833
1867
        const IPv4Net&  net,
1834
1868
        const bool&     unicast,
1836
1870
        const GetV4RouteListStartCB&    cb
1837
1871
)
1838
1872
{
1839
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v4_route_list_start");
 
1873
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_v4_route_list_start");
1840
1874
    x.args().add("net", net);
1841
1875
    x.args().add("unicast", unicast);
1842
1876
    x.args().add("multicast", multicast);
1843
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v4_route_list_start, cb));
 
1877
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_v4_route_list_start, cb));
1844
1878
}
1845
1879
 
1846
1880
 
1847
1881
/* Unmarshall get_v4_route_list_start */
1848
1882
void
1849
 
XrlBgpV0p2Client::unmarshall_get_v4_route_list_start(
 
1883
XrlBgpV0p3Client::unmarshall_get_v4_route_list_start(
1850
1884
        const XrlError& e,
1851
1885
        XrlArgs*        a,
1852
1886
        GetV4RouteListStartCB           cb
1872
1906
}
1873
1907
 
1874
1908
bool
1875
 
XrlBgpV0p2Client::send_get_v6_route_list_start(
 
1909
XrlBgpV0p3Client::send_get_v6_route_list_start(
1876
1910
        const char*     dst_xrl_target_name,
1877
1911
        const IPv6Net&  net,
1878
1912
        const bool&     unicast,
1880
1914
        const GetV6RouteListStartCB&    cb
1881
1915
)
1882
1916
{
1883
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v6_route_list_start");
 
1917
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_v6_route_list_start");
1884
1918
    x.args().add("net", net);
1885
1919
    x.args().add("unicast", unicast);
1886
1920
    x.args().add("multicast", multicast);
1887
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v6_route_list_start, cb));
 
1921
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_v6_route_list_start, cb));
1888
1922
}
1889
1923
 
1890
1924
 
1891
1925
/* Unmarshall get_v6_route_list_start */
1892
1926
void
1893
 
XrlBgpV0p2Client::unmarshall_get_v6_route_list_start(
 
1927
XrlBgpV0p3Client::unmarshall_get_v6_route_list_start(
1894
1928
        const XrlError& e,
1895
1929
        XrlArgs*        a,
1896
1930
        GetV6RouteListStartCB           cb
1916
1950
}
1917
1951
 
1918
1952
bool
1919
 
XrlBgpV0p2Client::send_get_v4_route_list_next(
 
1953
XrlBgpV0p3Client::send_get_v4_route_list_next(
1920
1954
        const char*     dst_xrl_target_name,
1921
1955
        const uint32_t& token,
1922
1956
        const GetV4RouteListNextCB&     cb
1923
1957
)
1924
1958
{
1925
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v4_route_list_next");
 
1959
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_v4_route_list_next");
1926
1960
    x.args().add("token", token);
1927
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v4_route_list_next, cb));
 
1961
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_v4_route_list_next, cb));
1928
1962
}
1929
1963
 
1930
1964
 
1931
1965
/* Unmarshall get_v4_route_list_next */
1932
1966
void
1933
 
XrlBgpV0p2Client::unmarshall_get_v4_route_list_next(
 
1967
XrlBgpV0p3Client::unmarshall_get_v4_route_list_next(
1934
1968
        const XrlError& e,
1935
1969
        XrlArgs*        a,
1936
1970
        GetV4RouteListNextCB            cb
1982
2016
}
1983
2017
 
1984
2018
bool
1985
 
XrlBgpV0p2Client::send_get_v6_route_list_next(
 
2019
XrlBgpV0p3Client::send_get_v6_route_list_next(
1986
2020
        const char*     dst_xrl_target_name,
1987
2021
        const uint32_t& token,
1988
2022
        const GetV6RouteListNextCB&     cb
1989
2023
)
1990
2024
{
1991
 
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v6_route_list_next");
 
2025
    Xrl x(dst_xrl_target_name, "bgp/0.3/get_v6_route_list_next");
1992
2026
    x.args().add("token", token);
1993
 
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v6_route_list_next, cb));
 
2027
    return _sender->send(x, callback(this, &XrlBgpV0p3Client::unmarshall_get_v6_route_list_next, cb));
1994
2028
}
1995
2029
 
1996
2030
 
1997
2031
/* Unmarshall get_v6_route_list_next */
1998
2032
void
1999
 
XrlBgpV0p2Client::unmarshall_get_v6_route_list_next(
 
2033
XrlBgpV0p3Client::unmarshall_get_v6_route_list_next(
2000
2034
        const XrlError& e,
2001
2035
        XrlArgs*        a,
2002
2036
        GetV6RouteListNextCB            cb