3 * Copyright (C) 2008 Everton da Silva Marques
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #include "pim_iface.h"
34 #include "pim_hello.h"
35 #include "pim_macro.h"
36 #include "pim_assert.h"
37 #include "pim_ifchannel.h"
39 static int assert_action_a3(struct pim_ifchannel
*ch
);
40 static void assert_action_a2(struct pim_ifchannel
*ch
,
41 struct pim_assert_metric winner_metric
);
42 static void assert_action_a6(struct pim_ifchannel
*ch
,
43 struct pim_assert_metric winner_metric
);
45 void pim_ifassert_winner_set(struct pim_ifchannel
*ch
,
46 enum pim_ifassert_state new_state
,
47 struct in_addr winner
,
48 struct pim_assert_metric winner_metric
)
50 int winner_changed
= (ch
->ifassert_winner
.s_addr
!= winner
.s_addr
);
51 int metric_changed
= !pim_assert_metric_match(&ch
->ifassert_winner_metric
,
54 if (PIM_DEBUG_PIM_EVENTS
) {
55 if (ch
->ifassert_state
!= new_state
) {
56 zlog_debug("%s: (S,G)=%s assert state changed from %s to %s on interface %s",
59 pim_ifchannel_ifassert_name(ch
->ifassert_state
),
60 pim_ifchannel_ifassert_name(new_state
),
65 char was_str
[INET_ADDRSTRLEN
];
66 char winner_str
[INET_ADDRSTRLEN
];
67 pim_inet4_dump("<was?>", ch
->ifassert_winner
, was_str
, sizeof(was_str
));
68 pim_inet4_dump("<winner?>", winner
, winner_str
, sizeof(winner_str
));
69 zlog_debug("%s: (S,G)=%s assert winner changed from %s to %s on interface %s",
72 was_str
, winner_str
, ch
->interface
->name
);
74 } /* PIM_DEBUG_PIM_EVENTS */
76 ch
->ifassert_state
= new_state
;
77 ch
->ifassert_winner
= winner
;
78 ch
->ifassert_winner_metric
= winner_metric
;
79 ch
->ifassert_creation
= pim_time_monotonic_sec();
81 if (winner_changed
|| metric_changed
) {
82 pim_upstream_update_join_desired(ch
->upstream
);
83 pim_ifchannel_update_could_assert(ch
);
84 pim_ifchannel_update_assert_tracking_desired(ch
);
88 static void on_trace(const char *label
,
89 struct interface
*ifp
, struct in_addr src
)
91 if (PIM_DEBUG_PIM_TRACE
) {
92 char src_str
[INET_ADDRSTRLEN
];
93 pim_inet4_dump("<src?>", src
, src_str
, sizeof(src_str
));
94 zlog_debug("%s: from %s on %s",
95 label
, src_str
, ifp
->name
);
99 static int preferred_assert(const struct pim_ifchannel
*ch
,
100 const struct pim_assert_metric
*recv_metric
)
102 return pim_assert_metric_better(recv_metric
,
103 &ch
->ifassert_winner_metric
);
106 static int acceptable_assert(const struct pim_assert_metric
*my_metric
,
107 const struct pim_assert_metric
*recv_metric
)
109 return pim_assert_metric_better(recv_metric
,
113 static int inferior_assert(const struct pim_assert_metric
*my_metric
,
114 const struct pim_assert_metric
*recv_metric
)
116 return pim_assert_metric_better(my_metric
,
120 static int cancel_assert(const struct pim_assert_metric
*recv_metric
)
122 return (recv_metric
->metric_preference
== PIM_ASSERT_METRIC_PREFERENCE_MAX
)
124 (recv_metric
->route_metric
== PIM_ASSERT_ROUTE_METRIC_MAX
);
127 static void if_could_assert_do_a1(const char *caller
,
128 struct pim_ifchannel
*ch
)
130 if (PIM_IF_FLAG_TEST_COULD_ASSERT(ch
->flags
)) {
131 if (assert_action_a1(ch
)) {
132 zlog_warn("%s: %s: (S,G)=%s assert_action_a1 failure on interface %s",
133 __PRETTY_FUNCTION__
, caller
,
134 ch
->sg_str
, ch
->interface
->name
);
135 /* log warning only */
140 static int dispatch_assert(struct interface
*ifp
,
141 struct in_addr source_addr
,
142 struct in_addr group_addr
,
143 struct pim_assert_metric recv_metric
)
145 struct pim_ifchannel
*ch
;
148 memset (&sg
, 0, sizeof (struct prefix_sg
));
149 sg
.src
= source_addr
;
151 ch
= pim_ifchannel_add(ifp
, &sg
, 0);
153 zlog_warn("%s: (S,G)=%s failure creating channel on interface %s",
155 pim_str_sg_dump (&sg
), ifp
->name
);
159 switch (ch
->ifassert_state
) {
160 case PIM_IFASSERT_NOINFO
:
161 if (recv_metric
.rpt_bit_flag
) {
163 if_could_assert_do_a1(__PRETTY_FUNCTION__
, ch
);
167 if (inferior_assert(&ch
->ifassert_my_metric
, &recv_metric
)) {
168 if_could_assert_do_a1(__PRETTY_FUNCTION__
, ch
);
170 else if (acceptable_assert(&ch
->ifassert_my_metric
, &recv_metric
)) {
171 if (PIM_IF_FLAG_TEST_ASSERT_TRACKING_DESIRED(ch
->flags
)) {
172 assert_action_a6(ch
, recv_metric
);
177 case PIM_IFASSERT_I_AM_WINNER
:
178 if (preferred_assert(ch
, &recv_metric
)) {
179 assert_action_a2(ch
, recv_metric
);
182 if (inferior_assert(&ch
->ifassert_my_metric
, &recv_metric
)) {
183 assert_action_a3(ch
);
187 case PIM_IFASSERT_I_AM_LOSER
:
188 if (recv_metric
.ip_address
.s_addr
== ch
->ifassert_winner
.s_addr
) {
189 /* Assert from current winner */
191 if (cancel_assert(&recv_metric
)) {
192 assert_action_a5(ch
);
195 if (inferior_assert(&ch
->ifassert_my_metric
, &recv_metric
)) {
196 assert_action_a5(ch
);
198 else if (acceptable_assert(&ch
->ifassert_my_metric
, &recv_metric
)) {
199 if (!recv_metric
.rpt_bit_flag
) {
200 assert_action_a2(ch
, recv_metric
);
205 else if (preferred_assert(ch
, &recv_metric
)) {
206 assert_action_a2(ch
, recv_metric
);
211 zlog_warn("%s: (S,G)=%s invalid assert state %d on interface %s",
213 ch
->sg_str
, ch
->ifassert_state
, ifp
->name
);
221 int pim_assert_recv(struct interface
*ifp
,
222 struct pim_neighbor
*neigh
,
223 struct in_addr src_addr
,
224 uint8_t *buf
, int buf_size
)
227 struct prefix msg_source_addr
;
228 struct pim_assert_metric msg_metric
;
232 struct pim_interface
*pim_ifp
= NULL
;
234 on_trace(__PRETTY_FUNCTION__
, ifp
, src_addr
);
237 curr_size
= buf_size
;
240 Parse assert group addr
242 memset (&sg
, 0, sizeof (struct prefix_sg
));
243 offset
= pim_parse_addr_group (&sg
, curr
, curr_size
);
245 char src_str
[INET_ADDRSTRLEN
];
246 pim_inet4_dump("<src?>", src_addr
, src_str
, sizeof(src_str
));
247 zlog_warn("%s: pim_parse_addr_group() failure: from %s on %s",
256 Parse assert source addr
258 offset
= pim_parse_addr_ucast (&msg_source_addr
, curr
, curr_size
);
260 char src_str
[INET_ADDRSTRLEN
];
261 pim_inet4_dump("<src?>", src_addr
, src_str
, sizeof(src_str
));
262 zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
270 if (curr_size
!= 8) {
271 char src_str
[INET_ADDRSTRLEN
];
272 pim_inet4_dump("<src?>", src_addr
, src_str
, sizeof(src_str
));
273 zlog_warn("%s: preference/metric size is not 8: size=%d from %s on interface %s",
281 Parse assert metric preference
284 msg_metric
.metric_preference
= pim_read_uint32_host(curr
);
286 msg_metric
.rpt_bit_flag
= msg_metric
.metric_preference
& 0x80000000; /* save highest bit */
287 msg_metric
.metric_preference
&= ~0x80000000; /* clear highest bit */
292 Parse assert route metric
295 msg_metric
.route_metric
= pim_read_uint32_host(curr
);
297 if (PIM_DEBUG_PIM_TRACE
) {
298 char neigh_str
[INET_ADDRSTRLEN
];
299 char source_str
[INET_ADDRSTRLEN
];
300 char group_str
[INET_ADDRSTRLEN
];
301 pim_inet4_dump("<neigh?>", src_addr
, neigh_str
, sizeof(neigh_str
));
302 pim_inet4_dump("<src?>", msg_source_addr
.u
.prefix4
, source_str
, sizeof(source_str
));
303 pim_inet4_dump("<grp?>", sg
.grp
, group_str
, sizeof(group_str
));
304 zlog_debug("%s: from %s on %s: (S,G)=(%s,%s) pref=%u metric=%u rpt_bit=%u",
305 __PRETTY_FUNCTION__
, neigh_str
, ifp
->name
,
306 source_str
, group_str
,
307 msg_metric
.metric_preference
,
308 msg_metric
.route_metric
,
309 PIM_FORCE_BOOLEAN(msg_metric
.rpt_bit_flag
));
312 msg_metric
.ip_address
= src_addr
;
316 ++pim_ifp
->pim_ifstat_assert_recv
;
318 return dispatch_assert(ifp
,
319 msg_source_addr
.u
.prefix4
,
325 RFC 4601: 4.6.3. Assert Metrics
327 Assert metrics are defined as:
329 When comparing assert_metrics, the rpt_bit_flag, metric_preference,
330 and route_metric field are compared in order, where the first lower
331 value wins. If all fields are equal, the primary IP address of the
332 router that sourced the Assert message is used as a tie-breaker,
333 with the highest IP address winning.
335 int pim_assert_metric_better(const struct pim_assert_metric
*m1
,
336 const struct pim_assert_metric
*m2
)
338 if (m1
->rpt_bit_flag
< m2
->rpt_bit_flag
)
340 if (m1
->rpt_bit_flag
> m2
->rpt_bit_flag
)
343 if (m1
->metric_preference
< m2
->metric_preference
)
345 if (m1
->metric_preference
> m2
->metric_preference
)
348 if (m1
->route_metric
< m2
->route_metric
)
350 if (m1
->route_metric
> m2
->route_metric
)
353 return ntohl(m1
->ip_address
.s_addr
) > ntohl(m2
->ip_address
.s_addr
);
356 int pim_assert_metric_match(const struct pim_assert_metric
*m1
,
357 const struct pim_assert_metric
*m2
)
359 if (m1
->rpt_bit_flag
!= m2
->rpt_bit_flag
)
361 if (m1
->metric_preference
!= m2
->metric_preference
)
363 if (m1
->route_metric
!= m2
->route_metric
)
366 return m1
->ip_address
.s_addr
== m2
->ip_address
.s_addr
;
369 int pim_assert_build_msg(uint8_t *pim_msg
, int buf_size
,
370 struct interface
*ifp
,
371 struct in_addr group_addr
,
372 struct in_addr source_addr
,
373 uint32_t metric_preference
,
374 uint32_t route_metric
,
375 uint32_t rpt_bit_flag
)
377 uint8_t *buf_pastend
= pim_msg
+ buf_size
;
378 uint8_t *pim_msg_curr
;
382 pim_msg_curr
= pim_msg
+ PIM_MSG_HEADER_LEN
; /* skip room for pim header */
385 remain
= buf_pastend
- pim_msg_curr
;
386 pim_msg_curr
= pim_msg_addr_encode_ipv4_group(pim_msg_curr
, group_addr
);
388 char group_str
[INET_ADDRSTRLEN
];
389 pim_inet4_dump("<grp?>", group_addr
, group_str
, sizeof(group_str
));
390 zlog_warn("%s: failure encoding group address %s: space left=%d",
391 __PRETTY_FUNCTION__
, group_str
, remain
);
396 remain
= buf_pastend
- pim_msg_curr
;
397 pim_msg_curr
= pim_msg_addr_encode_ipv4_ucast(pim_msg_curr
, source_addr
);
399 char source_str
[INET_ADDRSTRLEN
];
400 pim_inet4_dump("<src?>", source_addr
, source_str
, sizeof(source_str
));
401 zlog_warn("%s: failure encoding source address %s: space left=%d",
402 __PRETTY_FUNCTION__
, source_str
, remain
);
406 /* Metric preference */
407 pim_write_uint32(pim_msg_curr
, rpt_bit_flag
?
408 metric_preference
| 0x80000000 :
413 pim_write_uint32(pim_msg_curr
, route_metric
);
419 pim_msg_size
= pim_msg_curr
- pim_msg
;
420 pim_msg_build_header(pim_msg
, pim_msg_size
,
421 PIM_MSG_TYPE_ASSERT
);
426 static int pim_assert_do(struct pim_ifchannel
*ch
,
427 struct pim_assert_metric metric
)
429 struct interface
*ifp
;
430 struct pim_interface
*pim_ifp
;
431 uint8_t pim_msg
[1000];
437 if (PIM_DEBUG_PIM_TRACE
)
438 zlog_debug("%s: channel%s has no associated interface!",
439 __PRETTY_FUNCTION__
, ch
->sg_str
);
444 if (PIM_DEBUG_PIM_TRACE
)
445 zlog_debug("%s: channel %s pim not enabled on interface: %s",
446 __PRETTY_FUNCTION__
, ch
->sg_str
, ifp
->name
);
450 pim_msg_size
= pim_assert_build_msg(pim_msg
, sizeof(pim_msg
), ifp
,
451 ch
->sg
.grp
, ch
->sg
.src
,
452 metric
.metric_preference
,
454 metric
.rpt_bit_flag
);
455 if (pim_msg_size
< 1) {
456 zlog_warn("%s: failure building PIM assert message: msg_size=%d",
457 __PRETTY_FUNCTION__
, pim_msg_size
);
462 RFC 4601: 4.3.1. Sending Hello Messages
464 Thus, if a router needs to send a Join/Prune or Assert message on
465 an interface on which it has not yet sent a Hello message with the
466 currently configured IP address, then it MUST immediately send the
467 relevant Hello message without waiting for the Hello Timer to
468 expire, followed by the Join/Prune or Assert message.
470 pim_hello_require(ifp
);
472 if (PIM_DEBUG_PIM_TRACE
) {
473 zlog_debug("%s: to %s: (S,G)=%s pref=%u metric=%u rpt_bit=%u",
475 ifp
->name
, ch
->sg_str
,
476 metric
.metric_preference
,
478 PIM_FORCE_BOOLEAN(metric
.rpt_bit_flag
));
480 ++pim_ifp
->pim_ifstat_assert_send
;
482 if (pim_msg_send(pim_ifp
->pim_sock_fd
,
483 pim_ifp
->primary_address
,
484 qpim_all_pim_routers_addr
,
488 zlog_warn("%s: could not send PIM message on interface %s",
489 __PRETTY_FUNCTION__
, ifp
->name
);
496 int pim_assert_send(struct pim_ifchannel
*ch
)
498 return pim_assert_do(ch
, ch
->ifassert_my_metric
);
502 RFC 4601: 4.6.4. AssertCancel Messages
504 An AssertCancel(S,G) is an infinite metric assert with the RPT bit
505 set that names S as the source.
507 static int pim_assert_cancel(struct pim_ifchannel
*ch
)
509 struct pim_assert_metric metric
;
511 metric
.rpt_bit_flag
= 0;
512 metric
.metric_preference
= PIM_ASSERT_METRIC_PREFERENCE_MAX
;
513 metric
.route_metric
= PIM_ASSERT_ROUTE_METRIC_MAX
;
514 metric
.ip_address
= ch
->sg
.src
;
516 return pim_assert_do(ch
, metric
);
519 static int on_assert_timer(struct thread
*t
)
521 struct pim_ifchannel
*ch
;
522 struct interface
*ifp
;
528 if (PIM_DEBUG_PIM_TRACE
) {
529 zlog_debug("%s: (S,G)=%s timer expired on interface %s",
531 ch
->sg_str
, ifp
->name
);
534 ch
->t_ifassert_timer
= NULL
;
536 switch (ch
->ifassert_state
) {
537 case PIM_IFASSERT_I_AM_WINNER
:
538 assert_action_a3(ch
);
540 case PIM_IFASSERT_I_AM_LOSER
:
541 assert_action_a5(ch
);
545 if (PIM_DEBUG_PIM_EVENTS
)
546 zlog_warn("%s: (S,G)=%s invalid assert state %d on interface %s",
548 ch
->sg_str
, ch
->ifassert_state
, ifp
->name
);
555 static void assert_timer_off(struct pim_ifchannel
*ch
)
557 if (PIM_DEBUG_PIM_TRACE
) {
558 if (ch
->t_ifassert_timer
) {
559 zlog_debug("%s: (S,G)=%s cancelling timer on interface %s",
561 ch
->sg_str
, ch
->interface
->name
);
564 THREAD_OFF(ch
->t_ifassert_timer
);
567 static void pim_assert_timer_set(struct pim_ifchannel
*ch
,
570 assert_timer_off(ch
);
572 if (PIM_DEBUG_PIM_TRACE
) {
573 zlog_debug("%s: (S,G)=%s starting %u sec timer on interface %s",
575 ch
->sg_str
, interval
, ch
->interface
->name
);
578 thread_add_timer(master
, on_assert_timer
, ch
, interval
,
579 &ch
->t_ifassert_timer
);
582 static void pim_assert_timer_reset(struct pim_ifchannel
*ch
)
584 pim_assert_timer_set(ch
, PIM_ASSERT_TIME
- PIM_ASSERT_OVERRIDE_INTERVAL
);
588 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
590 (S,G) Assert State machine Actions
592 A1: Send Assert(S,G).
593 Set Assert Timer to (Assert_Time - Assert_Override_Interval).
594 Store self as AssertWinner(S,G,I).
595 Store spt_assert_metric(S,I) as AssertWinnerMetric(S,G,I).
597 int assert_action_a1(struct pim_ifchannel
*ch
)
599 struct interface
*ifp
= ch
->interface
;
600 struct pim_interface
*pim_ifp
;
604 zlog_warn("%s: (S,G)=%s multicast not enabled on interface %s",
606 ch
->sg_str
, ifp
->name
);
607 return -1; /* must return since pim_ifp is used below */
610 /* Switch to I_AM_WINNER before performing action_a3 below */
611 pim_ifassert_winner_set(ch
, PIM_IFASSERT_I_AM_WINNER
,
612 pim_ifp
->primary_address
,
613 pim_macro_spt_assert_metric(&ch
->upstream
->rpf
,
614 pim_ifp
->primary_address
));
616 if (assert_action_a3(ch
)) {
617 zlog_warn("%s: (S,G)=%s assert_action_a3 failure on interface %s",
619 ch
->sg_str
, ifp
->name
);
623 if (ch
->ifassert_state
!= PIM_IFASSERT_I_AM_WINNER
)
625 if (PIM_DEBUG_PIM_EVENTS
)
626 zlog_warn("%s: channel%s not in expected PIM_IFASSERT_I_AM_WINNER state",
627 __PRETTY_FUNCTION__
, ch
->sg_str
);
634 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
636 (S,G) Assert State machine Actions
638 A2: Store new assert winner as AssertWinner(S,G,I) and assert
639 winner metric as AssertWinnerMetric(S,G,I).
640 Set Assert Timer to Assert_Time.
642 static void assert_action_a2(struct pim_ifchannel
*ch
,
643 struct pim_assert_metric winner_metric
)
645 pim_ifassert_winner_set(ch
, PIM_IFASSERT_I_AM_LOSER
,
646 winner_metric
.ip_address
,
649 pim_assert_timer_set(ch
, PIM_ASSERT_TIME
);
651 if (ch
->ifassert_state
!= PIM_IFASSERT_I_AM_LOSER
)
653 if (PIM_DEBUG_PIM_EVENTS
)
654 zlog_warn("%s: channel%s not in expected PIM_IFASSERT_I_AM_LOSER state",
655 __PRETTY_FUNCTION__
, ch
->sg_str
);
660 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
662 (S,G) Assert State machine Actions
664 A3: Send Assert(S,G).
665 Set Assert Timer to (Assert_Time - Assert_Override_Interval).
667 static int assert_action_a3(struct pim_ifchannel
*ch
)
669 if (ch
->ifassert_state
!= PIM_IFASSERT_I_AM_WINNER
)
671 if (PIM_DEBUG_PIM_EVENTS
)
672 zlog_warn("%s: channel%s expected to be in PIM_IFASSERT_I_AM_WINNER state",
673 __PRETTY_FUNCTION__
, ch
->sg_str
);
677 pim_assert_timer_reset(ch
);
679 if (pim_assert_send(ch
)) {
680 zlog_warn("%s: (S,G)=%s failure sending assert on interface %s",
682 ch
->sg_str
, ch
->interface
->name
);
690 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
692 (S,G) Assert State machine Actions
694 A4: Send AssertCancel(S,G).
695 Delete assert info (AssertWinner(S,G,I) and
696 AssertWinnerMetric(S,G,I) will then return their default
699 void assert_action_a4(struct pim_ifchannel
*ch
)
701 if (pim_assert_cancel(ch
)) {
702 zlog_warn("%s: failure sending AssertCancel%s on interface %s",
704 ch
->sg_str
, ch
->interface
->name
);
705 /* log warning only */
708 assert_action_a5(ch
);
710 if (ch
->ifassert_state
!= PIM_IFASSERT_NOINFO
)
712 if (PIM_DEBUG_PIM_EVENTS
)
713 zlog_warn("%s: channel%s not in PIM_IFASSERT_NOINFO state as expected",
714 __PRETTY_FUNCTION__
, ch
->sg_str
);
719 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
721 (S,G) Assert State machine Actions
723 A5: Delete assert info (AssertWinner(S,G,I) and
724 AssertWinnerMetric(S,G,I) will then return their default values).
726 void assert_action_a5(struct pim_ifchannel
*ch
)
728 reset_ifassert_state(ch
);
729 if (ch
->ifassert_state
!= PIM_IFASSERT_NOINFO
)
731 if (PIM_DEBUG_PIM_EVENTS
)
732 zlog_warn("%s: channel%s not in PIM_IFSSERT_NOINFO state as expected",
733 __PRETTY_FUNCTION__
, ch
->sg_str
);
738 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
740 (S,G) Assert State machine Actions
742 A6: Store new assert winner as AssertWinner(S,G,I) and assert
743 winner metric as AssertWinnerMetric(S,G,I).
744 Set Assert Timer to Assert_Time.
745 If (I is RPF_interface(S)) AND (UpstreamJPState(S,G) == true)
746 set SPTbit(S,G) to TRUE.
748 static void assert_action_a6(struct pim_ifchannel
*ch
,
749 struct pim_assert_metric winner_metric
)
751 assert_action_a2(ch
, winner_metric
);
754 If (I is RPF_interface(S)) AND (UpstreamJPState(S,G) == true) set
757 if (ch
->upstream
->rpf
.source_nexthop
.interface
== ch
->interface
)
758 if (ch
->upstream
->join_state
== PIM_UPSTREAM_JOINED
)
759 ch
->upstream
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
761 if (ch
->ifassert_state
!= PIM_IFASSERT_I_AM_LOSER
)
763 if(PIM_DEBUG_PIM_EVENTS
)
764 zlog_warn("%s: channel%s not in PIM_IFASSERT_I_AM_LOSER state as expected",
765 __PRETTY_FUNCTION__
, ch
->sg_str
);