FilesExpand file tree

main

/

message-validator.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

140 lines (120 loc) · 4.52 KB

main

/

message-validator.js

Copy path

Top

File metadata and controls

• Code
• Blame

140 lines (120 loc) · 4.52 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

/**

* Message validator for WebSocket signaling protocol

*

* Validates signaling messages (offer, answer, ice-candidate, register)

* to ensure they contain required fields and proper structure.

*/

/**

* Validate a signaling message

* @param {object} message - Parsed message object

* @param {string|null} registeredPeerId - The peer ID of the sender (null if not registered)

* @returns {{valid: boolean, errors: string[]}}

*/

export function validateSignalingMessage(message, registeredPeerId = null) {

const errors = [];

// Check message is an object

if (!message || typeof message !== 'object') {

return { valid: false, errors: ['Message must be a valid JSON object'] };

}

// Check message type exists

if (!message.type || typeof message.type !== 'string') {

errors.push('Missing or invalid "type" field (must be non-empty string)');

return { valid: false, errors }; // Can't validate further without type

}

// Validate based on message type

switch (message.type) {

case 'register':

validateRegisterMessage(message, errors);

break;

case 'offer':

case 'answer':

validateOfferAnswerMessage(message, registeredPeerId, errors);

break;

case 'ice-candidate':

validateIceCandidateMessage(message, registeredPeerId, errors);

break;

case 'ping':

// Ping messages don't require additional validation

break;

default:

// Unknown message types are allowed (for extensibility)

// They'll be handled by the protocol layer

break;

}

return {

valid: errors.length === 0,

errors

};

}

/**

* Validate register message

* @param {object} message - Message to validate

* @param {string[]} errors - Array to accumulate errors

*/

const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

function validateRegisterMessage(message, errors) {

if (!message.peerId || typeof message.peerId !== 'string') {

errors.push('Missing or invalid "peerId" field (must be non-empty string)');

} else if (message.peerId.trim().length === 0) {

errors.push('Field "peerId" cannot be empty or whitespace');

} else if (!UUID_V4_REGEX.test(message.peerId)) {

errors.push('Field "peerId" must be a valid UUID v4');

}

}

/**

* Validate offer or answer message

* @param {object} message - Message to validate

* @param {string|null} registeredPeerId - Sender's registered peer ID

* @param {string[]} errors - Array to accumulate errors

*/

function validateOfferAnswerMessage(message, registeredPeerId, errors) {

// Check sender is registered

if (!registeredPeerId) {

errors.push('Peer must register before sending offer/answer messages');

return;

}

// Validate from field

if (!message.from || typeof message.from !== 'string') {

errors.push('Missing or invalid "from" field (must be non-empty string)');

} else if (message.from !== registeredPeerId) {

errors.push(`Field "from" must match registered peer ID (expected: ${registeredPeerId}, got: ${message.from})`);

}

// Validate to field

if (!message.to || typeof message.to !== 'string') {

errors.push('Missing or invalid "to" field (must be non-empty string)');

}

// Validate sdp field

if (!message.sdp || typeof message.sdp !== 'string') {

errors.push('Missing or invalid "sdp" field (must be non-empty string)');

}

}

/**

* Validate ICE candidate message

* @param {object} message - Message to validate

* @param {string|null} registeredPeerId - Sender's registered peer ID

* @param {string[]} errors - Array to accumulate errors

*/

function validateIceCandidateMessage(message, registeredPeerId, errors) {

// Check sender is registered

if (!registeredPeerId) {

errors.push('Peer must register before sending ICE candidate messages');

return;

}

// Validate from field

if (!message.from || typeof message.from !== 'string') {

errors.push('Missing or invalid "from" field (must be non-empty string)');

} else if (message.from !== registeredPeerId) {

errors.push(`Field "from" must match registered peer ID (expected: ${registeredPeerId}, got: ${message.from})`);

}

// Validate to field

if (!message.to || typeof message.to !== 'string') {

errors.push('Missing or invalid "to" field (must be non-empty string)');

}

// Validate candidate field (should be an object)

if (!message.candidate) {

errors.push('Missing "candidate" field');

} else if (typeof message.candidate !== 'object') {

errors.push('Field "candidate" must be an object');

}

}

export default { validateSignalingMessage };