| blob | e0ef4c700a8ef3ef48ddbab4d5fce74524fb1586 |
1 /* packet-opensafety.c
2 *
3 * openSAFETY is a machine-safety protocol, encapsulated in modern fieldbus
4 * and industrial ethernet solutions.
5 *
6 * For more information see http://www.open-safety.org
7 *
8 * This dissector currently supports the following transport protocols
9 *
10 * - openSAFETY using POWERLINK
11 * - openSAFETY using SercosIII
12 * - openSAFETY using Generic UDP
13 * - openSAFETY using Modbus/TCP
14 * - openSAFETY using (openSAFETY over UDP) transport
15 * - openSAFETY using ProfiNet IO
16 *
17 * By Roland Knall <roland.knall@br-automation.com>
18 * Copyright 2011-2012 Bernecker + Rainer Industrie-Elektronik Ges.m.b.H.
19 *
20 * Wireshark - Network traffic analyzer
21 * By Gerald Combs <gerald@wireshark.org>
22 * Copyright 1998 Gerald Combs
23 *
24 * SPDX-License-Identifier: GPL-2.0-or-later
25 */
29 #include <epan/packet.h>
30 #include <epan/prefs.h>
31 #include <epan/etypes.h>
32 #include <epan/expert.h>
33 #include <epan/reassemble.h>
34 #include <epan/strutil.h>
35 #include <epan/tap.h>
36 #include <epan/conversation_table.h>
38 #include <wsutil/crc8.h>
39 #include <wsutil/crc16.h>
44 /* General definitions */
46 /* Used to classify incoming traffic and presort the heuristic */
47 #define OPENSAFETY_ANY_TRANSPORT 0x00
48 #define OPENSAFETY_CYCLIC_DATA 0x01
49 #define OPENSAFETY_ACYCLIC_DATA 0x02
51 #ifndef OPENSAFETY_PINFO_CONST_DATA
52 #define OPENSAFETY_PINFO_CONST_DATA 0xAABBCCDD
53 #endif
55 #define OPENSAFETY_REQUEST true
56 #define OPENSAFETY_RESPONSE false
58 /* SPDO Feature Flags
59 * Because featureflags are part of the TR field (which is only 6 bit), the field get's shifted */
60 #define OPENSAFETY_SPDO_FEAT_40BIT_AVAIL 0x20
61 #define OPENSAFETY_SPDO_FEAT_40BIT_USED 0x10
62 #define OPENSAFETY_SPDO_FEATURE_FLAGS (OPENSAFETY_SPDO_FEAT_40BIT_USED | OPENSAFETY_SPDO_FEAT_40BIT_AVAIL)
64 #define OSS_FRAME_POS_ADDR 0
65 #define OSS_FRAME_POS_ID 1
66 #define OSS_FRAME_POS_LEN 2
67 #define OSS_FRAME_POS_CT 3
68 #define OSS_FRAME_POS_DATA 4
70 #define OSS_PAYLOAD_MAXSIZE_FOR_CRC8 0x08
75 #define OSS_BROADCAST_ADDRESS 0x3ff
77 #define OPENSAFETY_SPDO_CONNECTION_VALID 0x04
79 #define OPENSAFETY_SOD_DVI 0x1018
80 #define OPENSAFETY_SOD_RXMAP 0x1800
81 #define OPENSAFETY_SOD_TXMAP 0xC000
83 #define OSS_FRAME_ADDR(f, offset) (f[OSS_FRAME_POS_ADDR + offset] + ((uint8_t)((f[OSS_FRAME_POS_ADDR + offset + 1]) << 6) << 2))
84 #define OSS_FRAME_ID(f, offset) (f[OSS_FRAME_POS_ID + offset] & 0xFC )
85 #define OSS_FRAME_LENGTH(f, offset) (f[OSS_FRAME_POS_LEN + offset])
86 #define OSS_FRAME_FIELD(f, position) (f[position])
88 #define OSS_FRAME_ADDR_T(f, offset) (tvb_get_uint8(f, OSS_FRAME_POS_ADDR + offset) + ((uint8_t)((tvb_get_uint8( f, OSS_FRAME_POS_ADDR + offset + 1)) << 6) << 2))
89 #define OSS_FRAME_ADDR_T2(f, offset, su1, su2) (( tvb_get_uint8(f, OSS_FRAME_POS_ADDR + offset) ^ su1) + ((uint8_t)(((tvb_get_uint8( f, OSS_FRAME_POS_ADDR + offset + 1) ^ su2)) << 6) << 2))
90 #define OSS_FRAME_ID_T(f, offset) (tvb_get_uint8(f, OSS_FRAME_POS_ID + offset) & 0xFC)
91 #define OSS_FRAME_LENGTH_T(f, offset) (tvb_get_uint8(f, OSS_FRAME_POS_LEN + offset))
179 #if 0
181 #endif
222 /* Definitions for the openSAFETY ov. UDP transport protocol */
242 /* Fragment subtrees */
245 /* Fragment fields */
254 /* Reassembled in field */
256 /* Reassembled length field */
258 /* Reassembled data */
260 /* Tag */
261 "Message fragments"
262 };
294 /* Using local_scm_udid as read variable for global_scm_udid, to
295 * enable automatic detection of scm udid */
300 /* Resets the dissector in case the dissection is malformed and the dissector crashes */
301 static void
303 {
305 }
307 static void
309 {
312 /* create list if it does not exist, but clean existing elements anyway,
313 * as options might have changed */
318 {
321 }
326 }
328 static void
330 {
334 {
337 }
338 }
343 /* Conversation functions */
345 /* This is defined by the specification. The Address field is 10 bits long, and the node with the number
346 * 1 is always the SCM, therefore ( 2 ^ 10 ) - 1 nodes can be addressed. We use 2 ^ 10 here, because the
347 * SCM can talk to himself (Assign SADR for instance ) */
348 /* #define MAX_NUMBER_OF_SAFETY_NODES ( 1 << 10 ) */
350 /* Tracks the information that the packet pinfo has been received by receiver, and adds that information to the tree, using pos, as
351 * byte position in the PDU */
352 static void
355 {
365 {
372 }
374 }
376 static void
377 opensafety_packet_receiver(tvbuff_t * message_tvb, packet_info *pinfo, proto_tree *tree, proto_item *opensafety_item,
380 {
385 opensafety_packet_node (message_tvb, pinfo, tree, hf_oss_msg_receiver, recv, posInFrame, posSdnInFrame, sdn );
387 }
389 /* Tracks the information that the packet pinfo has been sent by sender, and received by everyone else, and adds that information to
390 * the tree, using pos, as byte position in the PDU */
391 static void
392 opensafety_packet_sender(tvbuff_t * message_tvb, packet_info *pinfo, proto_tree *tree, proto_item *opensafety_item,
395 {
400 opensafety_packet_node (message_tvb, pinfo, tree, hf_oss_msg_sender, sender, posInFrame, posSdnInFrame, sdn );
402 }
404 /* Tracks the information that the packet pinfo has been sent by sender, and received by receiver, and adds that information to
405 * the tree, using pos for the sender and pos2 for the receiver, as byte position in the PDU */
406 static void
407 opensafety_packet_sendreceiv(tvbuff_t * message_tvb, packet_info *pinfo, proto_tree *tree, proto_item *opensafety_item,
410 {
411 opensafety_packet_receiver(message_tvb, pinfo, tree, opensafety_item, packet, recv, pos2, posnet, sdn);
412 opensafety_packet_sender(message_tvb, pinfo, tree, opensafety_item, packet, send, pos, posnet, sdn);
413 }
416 opensafety_packet_response(tvbuff_t *message_tvb, proto_tree *sub_tree, opensafety_packet_info *packet, bool isResponse)
417 {
422 {
425 }
426 else
427 {
428 /* SPDOs code the connection valid bit on offset 0x04. SSDO and SNMT frames use this
429 * bit for messages. Therefore setting a bitmask on the hf-field would not work. */
431 proto_tree_add_uint(sub_tree, hf_oss_msg, message_tvb, OSS_FRAME_POS_ID + packet->frame.subframe1, 1, b_id);
432 }
434 item = proto_tree_add_item(sub_tree, packet->msg_type != OPENSAFETY_SPDO_MESSAGE_TYPE ? hf_oss_msg_direction : hf_oss_spdo_direction,
440 }
443 opensafety_packet_payloadtree(packet_info *pinfo, tvbuff_t *message_tvb, proto_tree *opensafety_tree,
445 {
448 item = proto_tree_add_item(opensafety_tree, hf_oss_msg_category, message_tvb, OSS_FRAME_POS_ID + packet->frame.subframe1, 1, ENC_NA );
453 else if ( packet->msg_type == OPENSAFETY_SSDO_MESSAGE_TYPE || packet->msg_type == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE )
454 {
458 }
463 }
465 static uint16_t
466 findFrame1Position ( packet_info *pinfo, tvbuff_t *message_tvb, uint16_t byte_offset, uint8_t dataLength, bool checkIfSlimMistake )
467 {
474 /*
475 * First, a normal package is assumed. Calculation of frame 1 position is
476 * pretty easy, because, the length of the whole package is 11 + 2*n + 2*o, which
477 * results in frame 1 start at (6 + n + o), which is length / 2 + 1
478 */
481 /* Calculating the assumed frame length, taking CRC8/CRC16 into account */
482 i_calculatedLength = i_payloadLength * 2 + 11 + 2 * (i_payloadLength > OSS_PAYLOAD_MAXSIZE_FOR_CRC8 ? 1 : 0);
484 /* To prevent miscalculations, where by chance the byte at [length / 2] + 3 is a value matching a possible payload length,
485 * but in reality the frame is a slim ssdo, the CRC of frame 1 gets checked additionally. This check
486 * is somewhat time consuming, so it will only run if the normal check led to a mistake detected along the line */
488 {
490 frameCRC = tvb_get_letohs(message_tvb, byte_offset + i_wFrame1Position + dataLength + OSS_FRAME_POS_DATA);
491 else
492 frameCRC = tvb_get_uint8(message_tvb, byte_offset + i_wFrame1Position + dataLength + OSS_FRAME_POS_DATA);
494 bytes = (uint8_t*)tvb_memdup(pinfo->pool, message_tvb, byte_offset + i_wFrame1Position, dataLength + 4);
496 {
500 }
501 else
504 /* if the calculated crc does not match the detected, the package is not a normal openSAFETY package */
507 }
509 /* If the calculated length differs from the given length, a slim package is assumed. */
511 {
512 /* possible slim package */
514 /*
515 * Slim packages have a fixed sublength of either 6 bytes for frame 2 in
516 * case of crc8 and 7 bytes in case of crc16
517 */
518 i_offset = OSS_SLIM_FRAME2_WITH_CRC8 + ( dataLength < (OSS_SLIM_FRAME_WITH_CRC8_MAXSIZE + 1) ? 0 : 1 );
519 /* Last 2 digits belong to addr, therefore have to be cleared */
522 /* If the id byte xor 0xE8 is 0, we have a slim package */
525 {
526 /* Slim package found */
528 }
529 }
532 }
534 static bool findSafetyFrame ( packet_info *pinfo, tvbuff_t *message_tvb, unsigned u_Offset, bool b_frame2first,
536 {
548 /* Search will allways start at the second byte of the frame ( cause it determines )
549 * the type of package and therefore everything else. Therefore the mininmum length - 1
550 * is the correct minimum length */
552 {
553 /* The ID byte must ALWAYS be the second byte, therefore 0 is invalid,
554 * also, the byte we want to access, must at least exist, otherwise,
555 * the frame is not detectable as an openSAFETY frame.
556 * We check for ID and length */
558 {
566 {
569 /* 0xFF is often used, but always false, otherwise start detection, if the highest
570 * bit is set */
572 {
573 /* The rem_length value might be polluted, due to the else statement of
574 * above if-decision (frame at end position detection). Therefore we
575 * calculate it here again, to have a sane value */
578 /* Plausibility check on length */
580 {
582 /* The calculated length must fit, but for the CRC16 check, also the calculated length
583 * plus the CRC16 end position must fit in the remaining length */
586 {
587 /* Ensure, that the correct length for CRC calculation
588 * still exists in byte stream, so that we can calculate the crc */
590 {
591 /* An openSAFETY command has to have a high-byte range between 0x0A and 0x0E
592 * b_ID & 0x80 took care of everything underneath, we check for 0x09 and 0x0F,
593 * as they remain the only values left, which are not valid */
595 {
596 /* Read CRC from position */
599 /* There exists some false positives, where the only possible
600 * data information in the frame is the ID and the ADDR fields.
601 * The rest of the fields in frame 1 are zeroed out. The packet
602 * must be filtered out and may not be used. To detect it, we
603 * check for the CT value, which, if zero indicates strongly
604 * that this is false-positive. */
607 /* If either length, crc or CTl is not zero, this may be a
608 * correct package. If all three are 0, this is most certainly
609 * an incorrect package, because the possibility of a valid
610 * package with all three values being zero is next to impossible */
612 {
613 /* calculate checksum */
616 {
623 {
627 else
629 }
633 }
636 {
637 /* Check if this is a Slim SSDO message */
639 {
640 /* Slim SSDO messages must have a length != 0, as the first byte
641 * in the payload contains the SOD access command */
643 {
647 /* It is highly unlikely, that both frame 1 and frame 2 generate
648 * a crc == 0 or equal crc's. Therefore we check, if both crc's are
649 * equal. If so, it is a falsely detected frame. */
654 {
657 }
658 }
659 }
660 else
661 {
665 /* If the first crc is zero, the second one must not be 0. The header
666 * for each subfields differ, therefore it is impossible, that both
667 * crcs are zero */
669 {
674 /* The crc's differ, everything is ok */
676 {
679 }
680 }
681 else
682 {
683 /* At this point frames had been checked for SoC and SoA types of
684 * EPL. This is no longer necessary and leads to false-negatives.
685 * SoC and SoA frames get filtered out at the EPL entry point, cause
686 * EPL only provides payload, no longer complete frames. */
689 }
690 }
691 }
692 }
693 }
694 }
695 }
696 }
697 }
698 else
699 {
700 /* There exist frames, where the last openSAFETY frame is sitting in the
701 * very last bytes of the frame, and the complete frame itself contains
702 * more than one openSAFETY frame. It so happens that in such a case, the
703 * last openSAFETY frame will miss detection.
704 *
705 * If so we look at the transported length, calculate the frame length,
706 * and take a look if the calculated frame length, might be a fit for the
707 * remaining length. If such is the case, we increment ctr and increment
708 * rem_length (to hit the while loop one more time) and the frame will be
709 * detected correctly. */
711 {
716 else
720 {
721 ctr++;
722 rem_length++;
724 }
725 }
726 }
727 }
728 }
730 ctr++;
733 }
735 /* Store packet information in packet_info */
737 {
742 /* Should be the calculated crc, which is the same as the frame crc */
747 else
749 }
751 /* Seem redundant if b_frame2First is false. But in this case, the function is needed for the
752 * simple detection of a possible openSAFETY frame. */
757 }
759 static int
760 dissect_data_payload ( proto_tree *epl_tree, tvbuff_t *tvb, packet_info *pinfo, int offset, int len, uint8_t msgType )
761 {
769 {
770 payload_tvb = tvb_new_subset_length_caplen(tvb, off, len, tvb_reported_length_remaining(tvb, offset) );
771 if ( ! dissector_try_heuristic(heur_opensafety_spdo_subdissector_list, payload_tvb, pinfo, epl_tree, &hdtbl_entry, &msgType))
775 }
778 }
780 static void
781 dissect_opensafety_spdo_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *opensafety_tree,
783 {
795 /* Network address is xor'ed into the start of the second frame, but only legible, if the scm given is valid */
797 ( OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2, packet->scm_udid[0], packet->scm_udid[1]) ) );
801 /* taddr is the 4th octet in the second frame */
804 /* allow only valid SPDO flags */
807 /* An SPDO is always sent by the producer, to everybody else .
808 * For a 40bit connection OPENSAFETY_DEFAULT_DOMAIN is assumed as sdn value for now */
812 /* Determine the producer and set it, as opensafety_packet_node does not */
820 spdo_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_spdo );
822 /* Determine SPDO Flags. Attention packet->payload.spdo exists ONLY AFTER opensafety_packet_payloadtree */
828 if ( packet->payload.spdo->flags.requested40bit && ( (OPENSAFETY_SPDO_FEAT_40BIT_USED & spdoFlags ) == OPENSAFETY_SPDO_FEAT_40BIT_USED ) )
831 diritem = opensafety_packet_response(message_tvb, spdo_tree, packet, b_ID == OPENSAFETY_MSG_SPDO_DATA_WITH_TIME_RESPONSE );
832 proto_tree_add_item(spdo_tree, hf_oss_spdo_connection_valid, message_tvb, OSS_FRAME_POS_ID + packet->frame.subframe1, 1, ENC_NA);
834 packet->payload.spdo->conn_valid = (tvb_get_uint8(message_tvb, OSS_FRAME_POS_ID + packet->frame.subframe1) & 0x04) == 0x04;
836 /* taddr is the 4th octet in the second frame */
837 taddr = OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2 + 3, packet->scm_udid[3], packet->scm_udid[4]);
840 /* determine the ct value. if complete it can be used for analysis of the package */
843 {
844 ct = (uint16_t)((tvb_get_uint8(message_tvb, packet->frame.subframe2 + 2) ^ packet->scm_udid[2]) << 8) +
846 }
849 {
862 }
863 else
864 {
866 {
871 }
872 else
873 {
874 /* 40bit counter is calculated from various fields. Therefore it cannot be read
875 * directly from the frame. All fields starting after or with packet->frame.subframe2 have to
876 * be decoded using the scm udid */
879 ct40bit += ((uint64_t)(tvb_get_uint8(message_tvb, packet->frame.subframe2 + 1) ^ packet->scm_udid[1]) ^ tvb_get_uint8(message_tvb, packet->frame.subframe1 + 1));
881 ct40bit += (tvb_get_uint8(message_tvb, packet->frame.subframe2 + 0) ^ packet->scm_udid[0]) ^ OPENSAFETY_DEFAULT_DOMAIN ^ tvb_get_uint8(message_tvb, packet->frame.subframe1 + 0);
893 }
897 {
905 }
906 else
907 {
919 }
920 }
923 {
924 dissect_data_payload(spdo_tree, message_tvb, pinfo, OSS_FRAME_POS_ID + 3, dataLength, OPENSAFETY_SPDO_MESSAGE_TYPE);
925 }
926 }
928 static void dissect_opensafety_ssdo_payload ( packet_info *pinfo, tvbuff_t *new_tvb, proto_tree *ssdo_payload, uint8_t sacmd )
929 {
943 /* first check for extended parameter */
945 {
946 /* extended parameter header & data */
964 {
965 item = proto_tree_add_item(ext_tree, hf_oss_ssdo_extpar_data, new_tvb, 16, dataLength - 16, ENC_NA );
969 }
970 }
971 else
972 {
973 /* If == upload, it is most likely a par upload */
975 {
992 /* This is to avoid a compiler loop optimization warning */
995 {
999 }
1000 }
1001 /* If != upload, it is most likely a 101A download */
1002 else
1003 {
1005 /* normal parameter set */
1007 {
1034 {
1039 }
1040 else
1045 /* reading real size */
1054 {
1055 proto_tree_add_item( sod_tree, hf_oss_sod_par_timestamp, new_tvb, ctr + 5, 4, ENC_LITTLE_ENDIAN );
1057 /* This is to avoid a compiler loop optimization warning */
1060 {
1064 }
1066 proto_tree_add_item( sod_tree, hf_oss_sod_par_timestamp, new_tvb, ctr + 5, 4, ENC_LITTLE_ENDIAN );
1067 } else if ( ( dispSSDOIndex == OPENSAFETY_SOD_RXMAP || dispSSDOIndex == OPENSAFETY_SOD_TXMAP ) && ssdoSubIndex != 0x0 ) {
1069 item = proto_tree_add_item(sod_tree, hf_oss_ssdo_sodmapping, new_tvb, ctr + 5, sodLength, ENC_NA );
1080 proto_tree_add_item(sod_tree, hf_oss_ssdo_sodentry_data, new_tvb, ctr + 5, sodLength, ENC_NA );
1081 }
1083 }
1084 }
1085 }
1088 }
1090 static void
1091 dissect_opensafety_ssdo_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *opensafety_tree,
1093 {
1113 NULL
1114 };
1123 /* Response is determined by the openSAFETY message field */
1127 {
1128 /* taddr is the 4th octet in the second frame */
1129 taddr = OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2 + 3, packet->scm_udid[3], packet->scm_udid[4]);
1131 ( OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2, packet->scm_udid[0], packet->scm_udid[1]) ) );
1133 opensafety_packet_sendreceiv ( message_tvb, pinfo, opensafety_tree, opensafety_item, packet, taddr,
1136 }
1138 {
1142 ( OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2, packet->scm_udid[0], packet->scm_udid[1]) ) ) );
1143 }
1145 {
1149 ( OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2, packet->scm_udid[0], packet->scm_udid[1]) ) ) );
1150 }
1152 ssdo_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_ssdo );
1156 packet->payload.ssdo->sacmd.toggle = ( db0 & OPENSAFETY_SSDO_SACMD_TGL ) == OPENSAFETY_SSDO_SACMD_TGL;
1157 packet->payload.ssdo->sacmd.abort_transfer = ( db0 & OPENSAFETY_SSDO_SACMD_ABRT ) == OPENSAFETY_SSDO_SACMD_ABRT;
1158 packet->payload.ssdo->sacmd.preload = ( db0 & OPENSAFETY_SSDO_SACMD_PRLD ) == OPENSAFETY_SSDO_SACMD_PRLD;
1159 packet->payload.ssdo->sacmd.read_access = ( db0 & OPENSAFETY_SSDO_DOWNLOAD ) == OPENSAFETY_SSDO_DOWNLOAD;
1160 packet->payload.ssdo->sacmd.initiate = ( db0 & OPENSAFETY_SSDO_SACMD_INI ) == OPENSAFETY_SSDO_SACMD_INI;
1161 packet->payload.ssdo->sacmd.segmented = ( db0 & OPENSAFETY_SSDO_SACMD_SEG ) == OPENSAFETY_SSDO_SACMD_SEG;
1162 packet->payload.ssdo->sacmd.end_segment = ( db0 & OPENSAFETY_SSDO_SACMD_ENSG ) == OPENSAFETY_SSDO_SACMD_ENSG;
1165 {
1172 {
1173 proto_tree_add_uint(ssdo_tree, hf_oss_ssdo_server, message_tvb, packet->frame.subframe2 + 3, 2, taddr);
1175 }
1176 }
1178 {
1179 proto_tree_add_uint(ssdo_tree, hf_oss_ssdo_server, message_tvb, packet->frame.subframe1, 2, OSS_FRAME_ADDR_T(message_tvb, packet->frame.subframe1));
1182 {
1186 }
1187 }
1189 /* Toggle bit must be removed, otherwise the values cannot be displayed correctly */
1195 col_append_fstr(pinfo->cinfo, COL_INFO, ", SACMD: %s", val_to_str_const(db0, opensafety_ssdo_sacmd_values, " "));
1201 {
1202 ct = (uint16_t)((tvb_get_uint8(message_tvb, packet->frame.subframe2 + 2) ^ packet->scm_udid[2]) << 8);
1204 }
1206 proto_tree_add_uint(ssdo_tree, hf_oss_ssdo_sano, message_tvb, packet->frame.subframe1 + 3, 1, ct );
1208 /* Evaluate preload field [field TR] */
1210 {
1211 /* Preload info are the higher 6 bit of the TR field */
1212 preload = ( (tvb_get_uint8(message_tvb, packet->frame.subframe2 + 4) ^ packet->scm_udid[4]) & 0xFC ) >> 2;
1215 {
1216 /* Use the lower 4 bits from the preload as size */
1217 proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_preload_queue, message_tvb, packet->frame.subframe2 + 4, 1,
1219 }
1220 else
1221 {
1222 /* The highest 2 bits of information contain an error flag */
1223 item = proto_tree_add_item(ssdo_tree, hf_oss_ssdo_preload_error, message_tvb, packet->frame.subframe2 + 4, 1, ENC_NA );
1226 }
1227 }
1229 /* When the following clause is met, DB1,2 contain the SOD index, and DB3 the SOD subindex */
1231 {
1235 proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_sod_index, message_tvb, db0Offset + 1, 2,
1237 val_to_str_ext_const(((uint32_t) (ssdoIndex << 16)), &opensafety_sod_idx_names_ext, "Unknown") );
1238 col_append_fstr(pinfo->cinfo, COL_INFO, " [%s", val_to_str_ext_const(((uint32_t) (ssdoIndex << 16)), &opensafety_sod_idx_names_ext, "Unknown"));
1240 /* Some SOD downloads (0x101A for instance) don't have sub-indices */
1242 {
1243 proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_sod_subindex, message_tvb, db0Offset + 3, 1,
1245 val_to_str_ext_const(((uint32_t) (ssdoIndex << 16) + ssdoSubIndex), &opensafety_sod_idx_names_ext, "Unknown") );
1247 val_to_str_ext_const(((uint32_t) (ssdoIndex << 16) + ssdoSubIndex), &opensafety_sod_idx_names_ext, "Unknown"));
1248 }
1251 }
1254 {
1257 proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_abort_code, message_tvb, packet->frame.subframe1 + OSS_FRAME_POS_DATA + 4, 4, abortcode,
1260 col_append_fstr(pinfo->cinfo, COL_INFO, " - %s", val_to_str_ext_const(abortcode, &opensafety_abort_codes_ext, "Unknown"));
1264 /* Either the SSDO msg is a response, then data is sent by the server and only in uploads,
1265 * or the message is a request, then data is coming from the client and payload data is
1266 * sent in downloads. Data is only sent in initiate, segmented or end-segment messages */
1267 if ( ( packet->payload.ssdo->sacmd.initiate || packet->payload.ssdo->sacmd.segmented || packet->payload.ssdo->sacmd.end_segment ) &&
1270 {
1275 /* If payload data has to be calculated, either a total size is given, or not */
1277 {
1281 /* reading real size */
1286 item = proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_payload_size, message_tvb, payloadOffset - 4, 4,
1290 {
1292 {
1299 {
1300 item = proto_tree_add_bytes_format_value(ssdo_tree, hf_oss_ssdo_payload, message_tvb, 0, 0, NULL, "Reassembled" );
1304 process_reassembled_data(message_tvb, 0, pinfo, "Reassembled Message", frag_msg, &oss_frag_items, NULL, ssdo_payload );
1305 }
1306 }
1308 proto_tree_add_item(ssdo_tree, hf_oss_ssdo_payload, message_tvb, payloadOffset, calcDataLength, ENC_NA );
1312 "Calculation for payload length yielded non-positive result [%d]", (unsigned) calcDataLength );
1313 }
1314 }
1315 else
1316 {
1319 {
1324 }
1327 {
1333 }
1336 {
1345 {
1346 item = proto_tree_add_uint_format_value(ssdo_payload, hf_oss_ssdo_payload_size, message_tvb, 0, 0,
1352 }
1353 }
1354 else
1355 {
1356 item = proto_tree_add_uint_format_value(ssdo_tree, hf_oss_ssdo_payload_size, message_tvb, 0, 0, payloadSize,
1361 {
1362 proto_tree_add_item( ssdo_tree, hf_oss_sod_par_timestamp, message_tvb, payloadOffset, 4, ENC_LITTLE_ENDIAN );
1364 {
1366 proto_tree_add_uint_format_value ( ssdo_tree, hf_oss_sod_par_checksum, message_tvb, (payloadOffset + n ),
1368 }
1370 proto_tree_add_item ( ssdo_tree, hf_oss_sod_par_timestamp, message_tvb, payloadOffset, 4, ENC_LITTLE_ENDIAN );
1372 proto_tree_add_item(ssdo_tree, hf_oss_ssdo_payload, message_tvb, payloadOffset, payloadSize, ENC_NA );
1373 }
1374 }
1377 }
1378 }
1379 }
1381 static void
1384 {
1393 {
1395 {
1398 if ( ( global_scm_udid_autoset == true ) && ( memcmp ( global_scm_udid, scm_udid_test, 17 ) != 0 ) )
1399 {
1401 {
1406 }
1407 }
1408 }
1409 }
1410 }
1412 static void
1413 dissect_opensafety_snmt_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *opensafety_tree,
1415 {
1423 /* addr is the first field, as well as the recipient of the message */
1426 /* taddr is the 4th octet in the second frame */
1428 /* domain is xor'ed on the first field in the second frame. As this is also addr, it is easy to obtain */
1441 {
1442 opensafety_packet_receiver( message_tvb, pinfo, opensafety_tree, opensafety_item, packet, addr,
1444 }
1445 else
1446 {
1447 opensafety_packet_sendreceiv ( message_tvb, pinfo, opensafety_tree, opensafety_item, packet, taddr,
1450 }
1452 snmt_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_snmt );
1453 /* Just a precaution, cause payloadtree actually sets the snmt pointer */
1461 opensafety_packet_response(message_tvb, snmt_tree, packet, ( packet->msg_id & 0x04 ) == 0x04 );
1464 {
1465 proto_tree_add_uint(snmt_tree, hf_oss_snmt_master, message_tvb, packet->frame.subframe2 + 3, 2, taddr);
1466 proto_tree_add_uint(snmt_tree, hf_oss_snmt_slave, message_tvb, OSS_FRAME_POS_ADDR + packet->frame.subframe1, 2, addr);
1467 }
1468 else
1469 {
1470 proto_tree_add_uint(snmt_tree, hf_oss_snmt_master, message_tvb, OSS_FRAME_POS_ADDR + packet->frame.subframe1, 2, addr);
1471 proto_tree_add_uint(snmt_tree, hf_oss_snmt_slave, message_tvb, packet->frame.subframe2 + 3, 2, taddr);
1472 }
1474 /* Handle Acknowledge and Fail specifically */
1475 if ( ( ( db0 ^ OPENSAFETY_MSG_SNMT_EXT_SN_ACKNOWLEDGE) == 0 ) || ( db0 ^ OPENSAFETY_MSG_SNMT_EXT_SN_FAIL) == 0 )
1476 {
1479 /* Handle a normal SN Fail */
1481 {
1483 {
1487 val_to_str_const(packet->payload.snmt->ext_msg_id, opensafety_message_service_type, "Unknown"));
1488 }
1490 {
1491 proto_tree_add_uint(snmt_tree, hf_oss_snmt_service_id, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 1, db0);
1492 col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str_const(db0, opensafety_message_service_type, "Unknown"));
1493 }
1495 proto_tree_add_uint_format_value(snmt_tree, hf_oss_snmt_error_group, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 1,
1496 byte, "%s", ( byte == 0 ? "Device" : val_to_str(byte, opensafety_sn_fail_error_group, "Reserved [%d]" ) ) );
1499 proto_tree_add_uint_format_value(snmt_tree, hf_oss_snmt_error_code, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 2, 1,
1505 );
1509 }
1510 else
1511 {
1513 {
1514 proto_tree_add_uint_format_value(snmt_tree, hf_oss_snmt_service_id, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 1,
1516 val_to_str_const(byte, opensafety_sn_fail_error_group, "Unknown"), packet->payload.snmt->ext_msg_id);
1517 col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str_const(byte, opensafety_sn_fail_error_group, "Unknown"));
1519 {
1520 proto_tree_add_uint_format_value(snmt_tree, hf_oss_snmt_service_id, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 1,
1521 packet->payload.snmt->ext_msg_id, "Additional parameter missing [Response via SN Acknowledge] (0x%02X)", packet->payload.snmt->ext_msg_id);
1523 }
1531 /* Handle an additional parameter request */
1537 }
1538 }
1539 else if ( (OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) ^ OPENSAFETY_MSG_SNMT_SERVICE_RESPONSE) == 0 )
1540 {
1544 val_to_str_const(packet->payload.snmt->ext_msg_id, opensafety_message_service_type, "Unknown"));
1547 {
1548 opensafety_parse_scm_udid ( message_tvb, pinfo, snmt_tree, packet, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1 );
1549 }
1551 {
1552 packet->payload.snmt->add_saddr.actual = OSS_FRAME_ADDR_T(message_tvb, packet->frame.subframe1 + OSS_FRAME_POS_DATA + 1);
1553 proto_tree_add_uint(snmt_tree, hf_oss_snmt_ext_addsaddr, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 2,
1556 packet->payload.snmt->add_saddr.additional = OSS_FRAME_ADDR_T(message_tvb, packet->frame.subframe1 + OSS_FRAME_POS_DATA + 3);
1557 proto_tree_add_uint(snmt_tree, hf_oss_snmt_ext_addtxspdo, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 3, 2,
1563 }
1565 {
1570 }
1571 }
1572 else if ( (OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) ^ OPENSAFETY_MSG_SNMT_SERVICE_REQUEST) == 0 )
1573 {
1574 proto_tree_add_uint(snmt_tree, hf_oss_snmt_service_id, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 1, db0);
1575 col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str_const(db0, opensafety_message_service_type, "Unknown"));
1577 if ( (db0 ^ OPENSAFETY_MSG_SNMT_EXT_SCM_SET_TO_STOP) == 0 || (db0 ^ OPENSAFETY_MSG_SNMT_EXT_SCM_SET_TO_OP) == 0 )
1578 {
1579 proto_tree_add_uint(snmt_tree, hf_oss_snmt_scm, message_tvb, OSS_FRAME_POS_ADDR + packet->frame.subframe1, 2, addr);
1580 proto_tree_add_uint(snmt_tree, hf_oss_snmt_tool, message_tvb, packet->frame.subframe2 + 3, 2, taddr);
1581 }
1583 {
1584 opensafety_parse_scm_udid ( message_tvb, pinfo, snmt_tree, packet, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1 );
1585 }
1587 {
1592 }
1593 else
1594 {
1596 {
1599 }
1601 {
1602 packet->payload.snmt->add_saddr.actual = OSS_FRAME_ADDR_T(message_tvb, packet->frame.subframe1 + OSS_FRAME_POS_DATA + 1);
1603 proto_tree_add_uint(snmt_tree, hf_oss_snmt_ext_addsaddr, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 2,
1606 packet->payload.snmt->add_saddr.additional = OSS_FRAME_ADDR_T(message_tvb, packet->frame.subframe1 + OSS_FRAME_POS_DATA + 3);
1607 proto_tree_add_uint(snmt_tree, hf_oss_snmt_ext_addtxspdo, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 3, 2,
1613 }
1615 }
1616 }
1617 else if ( (OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) ^ OPENSAFETY_MSG_SNMT_SADR_ASSIGNED) == 0 ||
1618 (OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) ^ OPENSAFETY_MSG_SNMT_ASSIGN_SADR) == 0 ||
1619 (OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) ^ OPENSAFETY_MSG_SNMT_RESPONSE_UDID) == 0 )
1620 {
1622 {
1624 tvb_bytes_to_str_punct(pinfo->pool, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 6, ':' ) );
1625 proto_tree_add_item(snmt_tree, hf_oss_snmt_udid, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 6, ENC_NA);
1626 }
1627 }
1628 }
1630 static bool
1631 dissect_opensafety_checksum(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *opensafety_tree,
1633 {
1652 else
1664 length = (dataLength > OSS_PAYLOAD_MAXSIZE_FOR_CRC8 ? OPENSAFETY_CHECKSUM_CRC16 : OPENSAFETY_CHECKSUM_CRC8);
1665 item = proto_tree_add_uint_format(opensafety_tree, hf_oss_crc, message_tvb, start, length, frame1_crc,
1670 bytesf1 = (uint8_t*)tvb_memdup(pinfo->pool, message_tvb, packet->frame.subframe1, dataLength + 4);
1684 /* using the defines, as the values can change */
1690 else
1693 /* 0xFFFF is an invalid CRC16 value, therefore valid for initialization. Needed, because
1694 * otherwise this function may return without setting calc2_crc, and this does not go well
1695 * with the compiler */
1698 /* Currently SPDO 40 Bit CRC2 support is broken. Will be implemented at a later state, after
1699 * the first generation of openSAFETY devices using 40 bit counter are available */
1703 /* This used to be an option. But only, because otherwise there would be three different
1704 * crc calculations taking place within dissection. As we could reduce this by one, the
1705 * global option has been changed to the simple validity question, if we have enough information
1706 * to calculate the second crc, meaning, if the SCM udid is known, or if we have an SNMT msg */
1708 {
1709 bytesf2 = (uint8_t*)tvb_memdup(pinfo->pool, message_tvb, packet->frame.subframe2, frame2Length + length);
1711 /* SLIM SSDO messages, do not contain a payload in frame2 */
1717 if ( isSNMT || ( hex_str_to_bytes((local_scm_udid != NULL ? local_scm_udid : global_scm_udid), scmUDID, true) && scmUDID->len == 6 ) )
1718 {
1720 {
1724 {
1726 /* allow only valid SPDO flags */
1728 {
1730 {
1731 /* we assume the OPENSAFETY_DEFAULT_DOMAIN (0x01) for 40 bit for now */
1735 }
1736 }
1737 }
1742 /*
1743 * If the second frame is 6 or 7 (slim) bytes in length, we have to decode the found
1744 * frame crc again. This must be done using the byte array, as the unxor operation
1745 * had to take place.
1746 */
1748 {
1751 }
1753 }
1755 item = proto_tree_add_uint_format(opensafety_tree, hf_oss_crc, message_tvb, start, length, frame2_crc,
1761 {
1765 }
1766 else
1774 {
1779 }
1780 else
1781 {
1782 if ( global_opensafety_debug_verbose && ( isSlim || ( !isSNMT && packet->frame.length == 11 ) ) )
1786 }
1787 }
1788 else
1792 }
1794 /* For a correct calculation of the second crc we need to know the scm udid.
1795 * If the dissection of the second frame has been triggered, we integrate the
1796 * crc for frame2 into the result */
1799 }
1801 static int
1803 {
1810 if ( hex_str_to_bytes((local_scm_udid != NULL ? local_scm_udid : global_scm_udid), scmUDID, true) && scmUDID->len == 6 )
1811 {
1814 /* Now confirm, that the xor operation was successful. The ID fields of both frames have to be the same */
1815 b_ID = tvb_get_uint8(message_tvb, packet->frame.subframe2 + 1) ^ (uint8_t)(scmUDID->data[OSS_FRAME_POS_ID]);
1819 /* The IDs do not match, but the SCM UDID could still be ok. This happens, if this packet
1820 * utilizes the 40 bit counter. Therefore we reduce the check here only to the feature
1821 * flags, but only if the package is a SPDO Data Only (because everything else uses 16 bit. */
1823 {
1828 }
1832 }
1839 }
1841 static bool
1846 {
1857 /* Sender / Receiver is determined by message type */
1861 /* SPDO is handled below */
1863 {
1866 }
1868 item = proto_tree_add_uint(opensafety_tree, hf_oss_byte_offset, packet->frame.frame_tvb, 0, 1, packet->frame.byte_offset);
1872 {
1874 dissect_opensafety_snmt_message ( message_tvb, pinfo, opensafety_tree, packet, opensafety_item );
1875 }
1876 else
1877 {
1880 if ( strlen( (local_scm_udid != NULL ? local_scm_udid : global_scm_udid) ) > 0 && udidLen == 6 )
1881 {
1883 {
1884 item = proto_tree_add_string(opensafety_tree, hf_oss_scm_udid_auto, message_tvb, 0, 0, local_scm_udid);
1887 }
1888 else
1889 item = proto_tree_add_string(opensafety_tree, hf_oss_scm_udid, message_tvb, 0, 0, global_scm_udid);
1891 }
1893 item = proto_tree_add_boolean(opensafety_tree, hf_oss_scm_udid_valid, message_tvb, 0, 0, packet->scm_udid_valid);
1898 if ( packet->msg_type == OPENSAFETY_SSDO_MESSAGE_TYPE || packet->msg_type == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE )
1899 {
1902 dissect_opensafety_ssdo_message ( message_tvb, pinfo, opensafety_tree, packet, opensafety_item );
1903 }
1905 {
1907 dissect_opensafety_spdo_message ( message_tvb, pinfo, opensafety_tree, packet, opensafety_item );
1909 /* Now we know packet->sender, therefore we can add the info text */
1911 {
1912 col_append_fstr(pinfo->cinfo, COL_INFO, (u_nrInPackage > 1 ? " | %s - 0x%03X" : "%s - 0x%03X" ),
1917 }
1918 }
1919 else
1920 {
1923 }
1924 }
1931 {
1933 }
1934 else
1935 {
1937 }
1939 /* with SNMT's we can check if the ID's for the frames match. Rare randomized packages do have
1940 * an issue, where an frame 1 can be valid. The id's for both frames must differ, as well as
1941 * the addresses, but addresses won't be checked yet, as there are issues with SDN xored on it. */
1943 {
1944 if ( OSS_FRAME_ID_T(message_tvb, packet->frame.subframe1) != OSS_FRAME_ID_T(message_tvb, packet->frame.subframe2) )
1946 }
1949 }
1951 static const char* opensafety_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)
1952 {
1956 }
1961 }
1966 }
1969 }
1973 static const char* opensafety_get_filter_type(endpoint_item_t* endpoint, conv_filter_type_e filter)
1974 {
1982 }
1985 }
1989 static tap_packet_status
1992 {
2007 add_conversation_table_data(hash, src, dst, 0, 0, 1, osinfo->msg_len, &pinfo->rel_ts, &pinfo->abs_ts,
2011 }
2013 static tap_packet_status
2016 {
2031 add_endpoint_table_data(hash, src, 0, true, 1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
2032 add_endpoint_table_data(hash, dst, 0, false, 1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
2035 }
2037 static gboolean
2041 {
2061 /* registering frame end routine, to prevent a malformed dissection preventing
2062 * further dissector calls (see bug #6950) */
2066 /* Minimum package length is 11 */
2070 /* Determine dissector handle for sub-dissection */
2072 {
2077 }
2081 /* This will swap the bytes according to MBTCP encoding */
2083 {
2084 /* Because of padding bytes at the end of the frame, tvb_memdup could lead
2085 * to a "openSAFETY truncated" message. By ensuring, that we have enough
2086 * bytes to copy, this will be prevented. */
2092 /* Wordswapping for modbus detection */
2093 /* Only a even number of bytes can be swapped */
2096 {
2097 tempByte = swbytes [ 2 * i ]; swbytes [ 2 * i ] = swbytes [ 2 * i + 1 ]; swbytes [ 2 * i + 1 ] = tempByte;
2098 }
2103 }
2109 /* Counter to determine gaps between openSAFETY packages */
2113 {
2114 /* Reset the next_tvb buffer */
2117 /* Smallest possible frame size is 11, but this check must ensure, that even the last frame
2118 * will get considered, which leads us with 10, as the first byte checked is the second one */
2122 /* Resetting packet, to ensure, that findSafetyFrame starts with a fresh frame.
2123 * As only packet_scope is used, this will not pollute memory too much and get's
2124 * cleared with the next packet anyway */
2127 /* Finding the start of the first possible safety frame */
2128 if ( findSafetyFrame(pinfo, message_tvb, frameOffset, b_frame2First, &frameOffset, &frameLength, packet) )
2129 {
2130 /* if packet msg_id is not null, it still might be an incorrect frame, as there is no validity
2131 * check in findSafetyFrame for the msg id (this happens later in this routine)
2132 * frameLength is calculated/read directly from the dissected data. If frameLength and frameOffset together
2133 * are bigger than the reported length, the package is not really an openSAFETY package */
2137 found++;
2140 /* We determine a possible position for frame 1 and frame 2 */
2142 {
2145 }
2146 else
2147 {
2150 (OSS_FRAME_LENGTH_T(message_tvb, byte_offset + frameStart1) > OSS_PAYLOAD_MAXSIZE_FOR_CRC8 ? OSS_SLIM_FRAME2_WITH_CRC16 : OSS_SLIM_FRAME2_WITH_CRC8));
2151 }
2153 /* If both frame starts are equal, something went wrong. In which case, we retract the found entry, and
2154 * also increase the search offset, just doing a continue will result in an infinite loop. */
2156 {
2157 found--;
2160 }
2162 /* We determine the possible type, and return false, if there could not be one */
2164 if ( ( packet->msg_id & OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE ) == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE )
2172 else
2173 {
2174 /* This is an invalid openSAFETY package, but it could be an undetected slim ssdo message. This specific error
2175 * will only occur, if findFrame1Position is in play. So we search once more, but this time calculating the CRC.
2176 * The reason for the second run is, that calculating the CRC is time consuming. */
2178 {
2179 /* Now let's check again, but this time calculate the CRC */
2180 frameStart1 = findFrame1Position(pinfo, message_tvb, ( b_frame2First ? 0 : frameOffset ), frameLength, true );
2184 if ( ( packet->msg_id & OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE ) == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE )
2193 /* Skip this frame. We cannot continue without
2194 advancing frameOffset - just doing a continue
2195 will result in an infinite loop. Advancing with 1 will
2196 lead to infinite loop, advancing with frameLength might miss
2197 some packages*/
2199 found--;
2201 }
2203 /* As stated above, you cannot just continue
2204 without advancing frameOffset. Advancing with 1 will
2205 lead to infinite loop, advancing with frameLength might miss
2206 some packages*/
2208 found--;
2210 }
2211 }
2213 /* Sorting messages for transporttype */
2215 {
2216 /* Cyclic data is transported via SPDOs and acyclic is transported via SNMT, SSDO. Everything
2217 * else is misclassification */
2220 {
2222 found--;
2224 }
2225 }
2227 /* Some faulty packages do indeed have a valid first frame, but the second is
2228 * invalid. These checks should prevent most faulty detections */
2230 {
2231 /* Is the given type at least known? */
2233 try_val_to_str_idx(OSS_FRAME_ID_T(message_tvb, byte_offset + frameStart1), opensafety_message_type_values, &idx );
2234 /* Unknown Frame Type */
2236 {
2238 found--;
2240 }
2241 /* Frame IDs do not match */
2243 (OSS_FRAME_ID_T(message_tvb, byte_offset + frameStart1) != OSS_FRAME_ID_T(message_tvb, byte_offset + frameStart2)) )
2244 {
2246 found--;
2248 }
2249 }
2251 /* If this package is not valid, the next step, which normally occurs in unxorFrame will lead to a
2252 * frameLength bigger than the maximum data size. This is an indicator, that the package in general
2253 * is fault, and therefore we return false. Increasing the frameOffset will lead to out-of-bounds
2254 * for tvb_* functions. And frameLength errors are misidentified packages most of the times anyway */
2255 if ( ( (int)frameLength - (int)( frameStart2 > frameStart1 ? frameStart2 : frameLength - frameStart1 ) ) < 0 )
2258 /* Some SPDO based sanity checks, still a lot of faulty SPDOs remain, because they
2259 * cannot be filtered, without throwing out too many positives. */
2261 {
2262 /* Checking if there is a node address set, or the package is invalid. Some PRes
2263 * messages in EPL may double as valid subframes 1. If the nodeAddress is out of
2264 * range, the package is marked as malformed */
2268 }
2270 /* SPDO Reserved is invalid, therefore all packages using this ID can be discarded */
2272 {
2274 found--;
2276 }
2277 }
2279 /* Filter node list */
2282 {
2283 bool found_in_list = wmem_list_find(global_filter_list, GINT_TO_POINTER( addr )) ? true : false;
2287 {
2288 opensafety_item = proto_tree_add_item(tree, proto_opensafety, message_tvb, frameOffset, frameLength, ENC_NA);
2291 found--;
2293 }
2294 }
2296 /* From here on, the package should be correct. Even if it is not correct, it will be dissected
2297 * anyway and marked as malformed. Therefore it can be assumed, that a gap will end here.
2298 */
2300 {
2301 /* Storing the gap data in subset, and calling the data dissector to display it */
2302 gap_tvb = tvb_new_subset_length_caplen(message_tvb, gapStart, (frameOffset - gapStart), reported_len);
2304 }
2305 /* Setting the gap to the next offset */
2308 /* Adding second data source */
2309 next_tvb = tvb_new_subset_length_caplen ( message_tvb, frameOffset, frameLength, reported_len );
2311 /* Adding a visual aid to the dissector tree */
2314 /* A new subtype for package dissection will need to set the actual nr. for the whole dissected package */
2316 {
2320 }
2323 {
2330 }
2332 /* if the tree is NULL, we are called for the overview, otherwise for the
2333 more detailed view of the package */
2335 {
2336 /* create the opensafety protocol tree */
2337 opensafety_item = proto_tree_add_item(tree, proto_opensafety, message_tvb, frameOffset, frameLength, ENC_NA);
2342 }
2344 /* Setting type to packet_info */
2354 /* Clearing connection valid bit */
2358 if ( dissect_opensafety_message(packet, next_tvb, pinfo, opensafety_item, opensafety_tree, found, previous_msg_id) != true )
2364 {
2368 }
2372 /* Something is being displayed, therefore this dissector returns true */
2374 }
2375 else
2378 /* findSafetyFrame starts at frameOffset with the search for the next position. But the
2379 * offset is assumed to be the ID, which can lead to scenarios, where the CRC of a previous
2380 * detected frame is assumed to be the addr of the next one. +1 prevents such a scenario.
2381 * It must be checked, if the resulting frameOffset does not scratch the max length. It
2382 * cannot exceed by adding just frameLength, as this value is a result of the heuristic, and
2383 * therefore must be within the correct length, but it can exceed if +1 is added unchecked. */
2387 }
2390 {
2391 /* There might be some undissected data at the end of the frame (e.g. SercosIII) */
2393 {
2394 /* Storing the gap data in subset, and calling the data dissector to display it */
2395 gap_tvb = tvb_new_subset_length_caplen(message_tvb, gapStart, (length - gapStart), reported_len);
2397 }
2398 }
2401 }
2403 static bool
2404 dissect_opensafety_epl(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data )
2405 {
2410 /* We will call the epl dissector by using call_dissector(). The epl dissector will then call
2411 * the heuristic openSAFETY dissector again. By setting this information, we prevent a dissector
2412 * loop */
2414 {
2417 /* Set the tree up, until it is par with the top-level */
2422 /* Ordering message type to traffic types */
2425 else
2428 /* We check if we have a asynchronous message, or a synchronous message. In case of
2429 * asynchronous messages, SPDO packages are not valid. */
2435 }
2438 }
2440 static bool
2441 dissect_opensafety_siii(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ )
2442 {
2447 /* The UDP dissection is not done by a heuristic, but rather by a normal dissector. But
2448 * the customer may not expect, that if (s)he disables the SercosIII dissector, that the
2449 * SercosIII UDP packages get still dissected. This will disable them as well. */
2453 /* We will call the SercosIII dissector by using call_dissector(). The SercosIII dissector will
2454 * then call the heuristic openSAFETY dissector again. By setting this information, we prevent
2455 * a dissector loop. */
2457 {
2461 /* No frames can be sent in AT messages, therefore those get filtered right away */
2464 {
2469 }
2471 }
2474 }
2476 static bool
2478 {
2480 }
2482 static gboolean
2483 dissect_opensafety_pn_io(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ )
2484 {
2487 /* We will call the pn_io dissector by using call_dissector(). The epl dissector will then call
2488 * the heuristic openSAFETY dissector again. By setting this information, we prevent a dissector
2489 * loop */
2491 {
2496 }
2499 }
2501 static bool
2503 {
2505 }
2508 static gboolean
2509 dissect_opensafety_mbtcp(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ )
2510 {
2514 /* When Modbus/TCP gets dissected, openSAFETY would be sorted as a child protocol. Although,
2515 * this behaviour is technically correct, it differs from other implemented IEM protocol handlers.
2516 * Therefore, the openSAFETY frame gets put one up, if the parent is not NULL */
2519 OPENSAFETY_ANY_TRANSPORT);
2520 }
2522 static gboolean
2523 opensafety_udp_transport_dissector(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree)
2524 {
2536 proto_tree_add_item(transport_tree, hf_oss_udp_transport_version, message_tvb, 0, 1, ENC_BIG_ENDIAN);
2537 proto_tree_add_item(transport_tree, hf_oss_udp_transport_flags_type, message_tvb, 1, 1, ENC_BIG_ENDIAN);
2538 proto_tree_add_item(transport_tree, hf_oss_udp_transport_counter, message_tvb, 2, 2, ENC_LITTLE_ENDIAN);
2540 proto_tree_add_item(transport_tree, hf_oss_udp_transport_sender, message_tvb, 4, 4, ENC_LITTLE_ENDIAN);
2541 proto_tree_add_item(transport_tree, hf_oss_udp_transport_datapoint, message_tvb, 8, 2, ENC_LITTLE_ENDIAN);
2542 proto_tree_add_item(transport_tree, hf_oss_udp_transport_length, message_tvb, 10, 2, ENC_LITTLE_ENDIAN);
2552 }
2554 static gboolean
2555 dissect_opensafety_udpdata(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ )
2556 {
2571 /* An openSAFETY frame has at least OSS_MINIMUM_LENGTH bytes */
2575 /* More than one openSAFETY package could be transported in the same frame,
2576 * in such a case, we need to establish the number of packages inside the frame */
2578 {
2581 }
2583 /* check for openSAFETY frame at beginning of data */
2585 frameFound = findSafetyFrame(pinfo, message_tvb, 0, global_udp_frame2_first, &frameOffset, &frameLength, NULL );
2587 {
2592 }
2593 else
2598 frameIdx++;
2601 }
2603 static void
2605 {
2610 /* It only should delete dissectors, if run for any time except the first */
2612 {
2613 /* Delete dissectors in preparation of a changed config setting */
2614 dissector_delete_uint ("udp.port", opensafety_udp_port_number, opensafety_udptransport_handle);
2615 dissector_delete_uint ("udp.port", opensafety_udp_siii_port_number, opensafety_udpdata_handle);
2616 }
2619 /* Storing the port numbers locally, to being able to delete the old associations */
2623 /* Default UDP only based dissector, will hand traffic to SIII dissector if needed */
2624 /* Preference names to specific to use "auto" preference */
2627 }
2629 void
2631 {
2632 /* Setup list of header fields */
2685 /* SNMT Specific fields */
2723 /* SSDO Specific fields */
2839 /* SSDO SACmd specific fields */
2861 #if 0
2865 #endif
2867 /* SPDO Specific fields */
2894 FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), (OPENSAFETY_SPDO_FEAT_40BIT_AVAIL << 2), NULL, HFILL } },
2897 FT_BOOLEAN, 8, TFS(&tfs_enabled_disabled), (OPENSAFETY_SPDO_FEAT_40BIT_USED << 2), NULL, HFILL } },
2898 };
2900 /* Setup list of header fields */
2902 /* UDP transport specific fields */
2922 };
2924 /* Setup protocol subtree array */
2940 };
2944 };
2964 "Frame 2 CRC is encoded with byte 6 of SCM UDID due to payload length of 0 in frame 2 or SLIM SSDO", EXPFILL } },
2984 "openSAFETY protocol settings are invalid! SCM UDID first octet will be assumed to be 00", EXPFILL } },
3000 };
3005 /* Register the protocol name and description */
3008 proto_oss_udp_transport = proto_register_protocol("openSAFETY over UDP", "openSAFETY ov. UDP", "opensafety_udp");
3011 /* Register data dissector */
3012 heur_opensafety_spdo_subdissector_list = register_heur_dissector_list_with_description("opensafety.spdo", "openSAFETY data", proto_opensafety);
3014 /* Required function calls to register the header fields and subtrees used */
3017 proto_register_field_array(proto_oss_udp_transport, hf_oss_udp_transport, array_length(hf_oss_udp_transport));
3020 /* Register tap */
3026 /* register user preferences */
3029 "To be able to fully dissect SSDO and SPDO packages, a valid UDID for the SCM has to be provided",
3033 "Automatically assign a detected SCM UDID (by reading SNMT->SNTM_assign_UDID_SCM) and set it for the file",
3064 "Modbus/TCP words can be transcoded either big- or little endian. Default will be little endian",
3076 "Enable heuristic dissection for openSAFETY over UDP encoded traffic", "Enable heuristic dissection for openSAFETY over UDP encoded traffic",
3095 /* Registering default and ModBus/TCP dissector */
3096 opensafety_udpdata_handle = register_dissector("opensafety_udp", dissect_opensafety_udpdata, proto_opensafety );
3097 opensafety_udptransport_handle =
3098 register_dissector("opensafety_udptransport", dissect_opensafety_udpdata, proto_oss_udp_transport );
3099 opensafety_mbtcp_handle = register_dissector("opensafety_mbtcp", dissect_opensafety_mbtcp, proto_opensafety );
3100 opensafety_pnio_handle = register_dissector("opensafety_pnio", dissect_opensafety_pn_io, proto_opensafety);
3102 register_conversation_table(proto_opensafety, true, opensafety_conversation_packet, opensafety_endpoint_packet);
3103 }
3105 void
3107 {
3108 /* Storing global data_dissector */
3111 /* EPL & SercosIII dissector registration */
3112 heur_dissector_add("epl_data", dissect_opensafety_epl, "openSAFETY over EPL", "opensafety_epl_data", proto_opensafety, HEURISTIC_ENABLE);
3113 heur_dissector_add("sercosiii", dissect_opensafety_siii_heur, "openSAFETY over SercosIII", "opensafety_sercosiii", proto_opensafety, HEURISTIC_ENABLE);
3115 /* Modbus TCP dissector registration */
3118 /* For Profinet we have to register as a heuristic dissector, as Profinet
3119 * is implemented as a plugin, and therefore the heuristic dissector is not
3120 * added by the time this method is being called
3121 */
3123 {
3124 heur_dissector_add("pn_io", dissect_opensafety_pn_io_heur, "openSAFETY over Profinet", "opensafety_pn_io", proto_opensafety, HEURISTIC_DISABLE);
3125 }
3126 else
3127 {
3128 /* The native dissector cannot be loaded. so we add our protocol directly to
3129 * the ethernet subdissector list. No PNIO specific data will be dissected
3130 * and a warning will be displayed, recognizing the missing dissector plugin.
3131 */
3133 }
3142 /* registering frame end routine, to prevent a malformed dissection preventing
3143 * further dissector calls (see bug #6950) */
3144 /* register_frame_end_routine(reset_dissector); */
3145 }
3147 /*
3148 * Editor modelines - https://www.wireshark.org/tools/modelines.html
3149 *
3150 * Local variables:
3151 * c-basic-offset: 4
3152 * tab-width: 8
3153 * indent-tabs-mode: nil
3154 * End:
3155 *
3156 * vi: set shiftwidth=4 tabstop=8 expandtab:
3157 * :indentSize=4:tabSize=8:noTabs=true:
3158 */